@subwallet/extension-base 1.1.52-0 → 1.1.53-beta.0

package/services/earning-service/handlers/native-staking/astar.js

@@ -242,11 +242,12 @@ export default class AstarNativeStakingPoolHandler extends BaseParaNativeStaking
     };
   }
   async subscribePoolPosition(useAddresses, resultCallback) {
+    var _substrateApi$api$que;
     let cancel = false;
     const substrateApi = await this.substrateApi.isReady;
     const defaultInfo = this.baseInfo;
     const chainInfo = this.chainInfo;
-    const unsub = await substrateApi.api.query.dappsStaking.ledger.multi(useAddresses, async ledgers => {
+    const unsub = await ((_substrateApi$api$que = substrateApi.api.query.dappsStaking) === null || _substrateApi$api$que === void 0 ? void 0 : _substrateApi$api$que.ledger.multi(useAddresses, async ledgers => {
       if (cancel) {
         unsub();
         return;
@@ -280,10 +281,10 @@ export default class AstarNativeStakingPoolHandler extends BaseParaNativeStaking
           }
         }));
       }
-    });
+    }));
     return () => {
       cancel = true;
-      unsub();
+      unsub && unsub();
     };
   }
 

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

@@ -3,10 +3,10 @@
 
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
 import { BasicTxErrorType, ExtrinsicType, StakingTxErrorType } from '@subwallet/extension-base/background/KoniTypes';
-import { calculateAlephZeroValidatorReturn, calculateChainStakedReturnV2, calculateInflation, calculateTernoaValidatorReturn, calculateValidatorStakedReturn, getAvgValidatorEraReward, getCommission, getMaxValidatorErrorMessage, getMinStakeErrorMessage, getSupportedDaysByHistoryDepth } from '@subwallet/extension-base/koni/api/staking/bonding/utils';
+import { calculateAlephZeroValidatorReturn, calculateChainStakedReturnV2, calculateInflation, calculateTernoaValidatorReturn, calculateValidatorStakedReturn, getAvgValidatorEraReward, getCommission, getMaxValidatorErrorMessage, getMinStakeErrorMessage, getSupportedDaysByHistoryDepth, getTopValidatorByPoints, getValidatorPointsMap } from '@subwallet/extension-base/koni/api/staking/bonding/utils';
 import { _STAKING_ERA_LENGTH_MAP } from '@subwallet/extension-base/services/chain-service/constants';
 import { _getChainSubstrateAddressPrefix } from '@subwallet/extension-base/services/chain-service/utils';
-import { _STAKING_CHAIN_GROUP } from '@subwallet/extension-base/services/earning-service/constants';
+import { _STAKING_CHAIN_GROUP, MaxEraRewardPointsEras } from '@subwallet/extension-base/services/earning-service/constants';
 import { parseIdentity } from '@subwallet/extension-base/services/earning-service/utils';
 import { EarningStatus, UnstakingStatus } from '@subwallet/extension-base/types';
 import { balanceFormatter, formatNumber, reformatAddress } from '@subwallet/extension-base/utils';
@@ -274,11 +274,23 @@ export default class RelayNativeStakingPoolHandler extends BaseNativeStakingPool
     if (!poolInfo || !poolInfo.statistic) {
       return Promise.reject(new TransactionError(BasicTxErrorType.INTERNAL_ERROR));
     }
-    const _era = await chainApi.api.query.staking.currentEra();
+    const [_era, _activeEraInfo] = await Promise.all([chainApi.api.query.staking.currentEra(), chainApi.api.query.staking.activeEra()]);
     const currentEra = _era.toString();
+    const activeEraInfo = _activeEraInfo.toPrimitive();
+    const activeEra = activeEraInfo.index;
     const allValidators = [];
     const validatorInfoList = [];
-    const [_totalEraStake, _eraStakers, _minBond, _stakingRewards, _validators] = await Promise.all([chainApi.api.query.staking.erasTotalStake(parseInt(currentEra)), chainApi.api.query.staking.erasStakers.entries(parseInt(currentEra)), chainApi.api.query.staking.minNominatorBond(), ((_chainApi$api$query$s = chainApi.api.query.stakingRewards) === null || _chainApi$api$query$s === void 0 ? void 0 : _chainApi$api$query$s.data) && chainApi.api.query.stakingRewards.data(), chainApi.api.query.staking.validators.entries()]);
+    const maxEraRewardPointsEras = MaxEraRewardPointsEras;
+    const endEraForPoints = parseInt(activeEra) - 1;
+    let startEraForPoints = endEraForPoints - maxEraRewardPointsEras + 1;
+    const [_totalEraStake, _eraStakers, _minBond, _stakingRewards, _validators, ..._eraRewardPoints] = await Promise.all([chainApi.api.query.staking.erasTotalStake(parseInt(currentEra)), chainApi.api.query.staking.erasStakers.entries(parseInt(currentEra)), chainApi.api.query.staking.minNominatorBond(), ((_chainApi$api$query$s = chainApi.api.query.stakingRewards) === null || _chainApi$api$query$s === void 0 ? void 0 : _chainApi$api$query$s.data) && chainApi.api.query.stakingRewards.data(), chainApi.api.query.staking.validators.entries(), chainApi.api.query.staking.erasRewardPoints.multi([...Array(maxEraRewardPointsEras).keys()].map(i => i + startEraForPoints))]);
+    const eraRewardMap = {};
+    for (const item of _eraRewardPoints[0]) {
+      eraRewardMap[startEraForPoints] = item.toHuman();
+      startEraForPoints++;
+    }
+    const validatorPointsMap = getValidatorPointsMap(eraRewardMap);
+    const topValidatorList = getTopValidatorByPoints(validatorPointsMap);
 
     // filter blocked validators
     const validators = _validators;
@@ -309,6 +321,11 @@ export default class RelayNativeStakingPoolHandler extends BaseNativeStakingPool
       const rawValidatorStat = item[1].toHuman();
       const validatorAddress = rawValidatorInfo[1];
       if (!blockValidatorList.includes(validatorAddress)) {
+        var _validatorPointsMap$v;
+        let isTopQuartile = false;
+        if (topValidatorList.includes(validatorAddress)) {
+          isTopQuartile = true;
+        }
         const rawTotalStake = rawValidatorStat.total;
         const rawOwnStake = rawValidatorStat.own;
         const bnTotalStake = new BN(rawTotalStake.replaceAll(',', ''));
@@ -333,7 +350,9 @@ export default class RelayNativeStakingPoolHandler extends BaseNativeStakingPool
           blocked: false,
           isVerified: false,
           minBond,
-          isCrowded: unlimitedNominatorRewarded ? false : nominatorCount > parseInt(maxNominatorRewarded)
+          isCrowded: unlimitedNominatorRewarded ? false : nominatorCount > parseInt(maxNominatorRewarded),
+          eraRewardPoint: ((_validatorPointsMap$v = validatorPointsMap[validatorAddress]) !== null && _validatorPointsMap$v !== void 0 ? _validatorPointsMap$v : BN_ZERO).toString(),
+          topQuartile: isTopQuartile
         });
       }
     }

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

@@ -38,6 +38,7 @@ export interface EventRegistry {
     'buy.tokens.ready': [boolean];
     'buy.services.ready': [boolean];
     'earning.ready': [boolean];
+    'swap.ready': [boolean];
 }
 export declare type EventType = keyof EventRegistry;
 export declare const COMMON_RELOAD_EVENTS: EventType[];

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

@@ -51,7 +51,6 @@ export default class ConnectWCRequestHandler {
       ...request
     };
     this.updateIconConnectWC();
-    this.#requestService.popupOpen();
   }
   resetWallet() {
     for (const request of Object.values(this.#connectWCRequests)) {

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

@@ -0,0 +1,38 @@
+import { SwapError } from '@subwallet/extension-base/background/errors/SwapError';
+import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
+import { BalanceService } from '@subwallet/extension-base/services/balance-service';
+import { ChainService } from '@subwallet/extension-base/services/chain-service';
+import { BaseStepDetail } from '@subwallet/extension-base/types/service-base';
+import { GenSwapStepFunc, OptimalSwapPath, OptimalSwapPathParams, SwapEarlyValidation, SwapFeeInfo, SwapProvider, SwapQuote, SwapRequest, SwapSubmitParams, SwapSubmitStepData, ValidateSwapProcessParams } from '@subwallet/extension-base/types/swap';
+export interface SwapBaseInterface {
+    getSwapQuote: (request: SwapRequest) => Promise<SwapQuote | SwapError>;
+    generateOptimalProcess: (params: OptimalSwapPathParams) => Promise<OptimalSwapPath>;
+    getSubmitStep: (params: OptimalSwapPathParams) => Promise<[BaseStepDetail, SwapFeeInfo] | undefined>;
+    validateSwapRequest: (request: SwapRequest) => Promise<SwapEarlyValidation>;
+    validateSwapProcess: (params: ValidateSwapProcessParams) => Promise<TransactionError[]>;
+    handleSwapProcess: (params: SwapSubmitParams) => Promise<SwapSubmitStepData>;
+    handleSubmitStep: (params: SwapSubmitParams) => Promise<SwapSubmitStepData>;
+    isReady?: boolean;
+    init?: () => Promise<void>;
+}
+export interface SwapBaseHandlerInitParams {
+    providerSlug: string;
+    providerName: string;
+    chainService: ChainService;
+    balanceService: BalanceService;
+}
+export declare class SwapBaseHandler {
+    private readonly providerSlug;
+    private readonly providerName;
+    chainService: ChainService;
+    balanceService: BalanceService;
+    constructor({ balanceService, chainService, providerName, providerSlug }: SwapBaseHandlerInitParams);
+    generateOptimalProcess(params: OptimalSwapPathParams, genStepFuncList: GenSwapStepFunc[]): Promise<OptimalSwapPath>;
+    validateXcmStep(params: ValidateSwapProcessParams, stepIndex: number): Promise<TransactionError[]>;
+    validateTokenApproveStep(params: ValidateSwapProcessParams, stepIndex: number): Promise<TransactionError[]>;
+    validateSetFeeTokenStep(params: ValidateSwapProcessParams, stepIndex: number): Promise<TransactionError[]>;
+    validateSwapStep(params: ValidateSwapProcessParams, isXcmOk: boolean, stepIndex: number): Promise<TransactionError[]>;
+    get name(): string;
+    get slug(): string;
+    get providerInfo(): SwapProvider;
+}

package/services/swap-service/handler/base-handler.js

@@ -0,0 +1,162 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
+import { BasicTxErrorType } from '@subwallet/extension-base/background/KoniTypes';
+import { _getAssetDecimals, _getTokenMinAmount, _isChainEvmCompatible, _isNativeToken } from '@subwallet/extension-base/services/chain-service/utils';
+import { DEFAULT_SWAP_FIRST_STEP, getSwapAlternativeAsset, MOCK_SWAP_FEE } from '@subwallet/extension-base/services/swap-service/utils';
+import { SwapErrorType, SwapFeeType } from '@subwallet/extension-base/types/swap';
+import { formatNumber } from '@subwallet/extension-base/utils';
+import BigNumber from 'bignumber.js';
+import { t } from 'i18next';
+import { isEthereumAddress } from '@polkadot/util-crypto';
+export class SwapBaseHandler {
+  constructor({
+    balanceService,
+    chainService,
+    providerName,
+    providerSlug
+  }) {
+    this.providerName = providerName;
+    this.providerSlug = providerSlug;
+    this.chainService = chainService;
+    this.balanceService = balanceService;
+  }
+
+  // public abstract getSwapQuote(request: SwapRequest): Promise<SwapQuote | SwapError>;
+  async generateOptimalProcess(params, genStepFuncList) {
+    const result = {
+      totalFee: [MOCK_SWAP_FEE],
+      steps: [DEFAULT_SWAP_FIRST_STEP]
+    };
+    try {
+      for (const genStepFunc of genStepFuncList) {
+        const step = await genStepFunc.bind(this, params)();
+        if (step) {
+          result.steps.push({
+            id: result.steps.length,
+            ...step[0]
+          });
+          result.totalFee.push(step[1]);
+        }
+      }
+      return result;
+    } catch (e) {
+      return result;
+    }
+  }
+  async validateXcmStep(params, stepIndex) {
+    const bnAmount = new BigNumber(params.selectedQuote.fromAmount);
+    const swapPair = params.selectedQuote.pair;
+    const alternativeAssetSlug = getSwapAlternativeAsset(swapPair);
+    if (!alternativeAssetSlug) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    const alternativeAsset = this.chainService.getAssetBySlug(alternativeAssetSlug);
+    const fromAsset = this.chainService.getAssetBySlug(swapPair.from);
+    const [alternativeAssetBalance, fromAssetBalance] = await Promise.all([this.balanceService.getTokenFreeBalance(params.address, alternativeAsset.originChain, alternativeAssetSlug), this.balanceService.getTokenFreeBalance(params.address, fromAsset.originChain, fromAsset.slug)]);
+    const bnAlternativeAssetBalance = new BigNumber(alternativeAssetBalance.value);
+    const bnFromAssetBalance = new BigNumber(fromAssetBalance.value);
+    const xcmFeeComponent = params.process.totalFee[stepIndex].feeComponent[0]; // todo: can do better than indexing
+    const xcmFee = new BigNumber(xcmFeeComponent.amount || '0');
+    let xcmAmount = bnAmount.minus(bnFromAssetBalance);
+    if (_isNativeToken(alternativeAsset)) {
+      xcmAmount = xcmAmount.plus(xcmFee);
+    }
+    const alternativeTokenMinAmount = new BigNumber(alternativeAsset.minAmount || '0');
+    if (!bnAlternativeAssetBalance.minus(xcmAmount).gte(alternativeTokenMinAmount)) {
+      const maxBn = bnFromAssetBalance.plus(new BigNumber(alternativeAssetBalance.value)).minus(xcmFee).minus(alternativeTokenMinAmount);
+      const maxValue = formatNumber(maxBn.toString(), fromAsset.decimals || 0);
+      const altInputTokenInfo = this.chainService.getAssetBySlug(alternativeAssetSlug);
+      const symbol = altInputTokenInfo.symbol;
+      const alternativeChain = this.chainService.getChainInfoByKey(altInputTokenInfo.originChain);
+      const chain = this.chainService.getChainInfoByKey(fromAsset.originChain);
+      const inputNetworkName = chain.name;
+      const altNetworkName = alternativeChain.name;
+      const currentValue = formatNumber(bnFromAssetBalance.toString(), fromAsset.decimals || 0);
+      const bnMaxXCM = new BigNumber(alternativeAssetBalance.value).minus(xcmFee).minus(alternativeTokenMinAmount);
+      const maxXCMValue = formatNumber(bnMaxXCM.toString(), fromAsset.decimals || 0);
+      if (maxBn.lte(0) || bnFromAssetBalance.lte(0) || bnMaxXCM.lte(0)) {
+        return [new TransactionError(BasicTxErrorType.NOT_ENOUGH_BALANCE, t(`Insufficient balance. Deposit ${fromAsset.symbol} and try again.`))];
+      }
+      return [new TransactionError(BasicTxErrorType.NOT_ENOUGH_BALANCE, t('You can only enter a maximum of {{maxValue}} {{symbol}}, which is {{currentValue}} {{symbol}} ({{inputNetworkName}}) and {{maxXCMValue}} {{symbol}} ({{altNetworkName}}). Lower your amount and try again.', {
+        replace: {
+          symbol,
+          maxValue,
+          inputNetworkName,
+          altNetworkName,
+          currentValue,
+          maxXCMValue
+        }
+      }))];
+    }
+    return [];
+  }
+  async validateTokenApproveStep(params, stepIndex) {
+    return Promise.resolve([]);
+  }
+  async validateSetFeeTokenStep(params, stepIndex) {
+    return Promise.resolve([]);
+  }
+  async validateSwapStep(params, isXcmOk, stepIndex) {
+    if (!params.selectedQuote) {
+      return Promise.resolve([new TransactionError(BasicTxErrorType.INTERNAL_ERROR)]);
+    }
+    const selectedQuote = params.selectedQuote;
+    const currentTimestamp = +Date.now();
+    if (selectedQuote.aliveUntil <= currentTimestamp) {
+      return Promise.resolve([new TransactionError(SwapErrorType.QUOTE_TIMEOUT)]);
+    }
+    const bnAmount = new BigNumber(params.selectedQuote.fromAmount);
+    const fromAsset = this.chainService.getAssetBySlug(params.selectedQuote.pair.from);
+    const stepFee = params.process.totalFee[stepIndex].feeComponent;
+    const networkFee = stepFee.find(fee => fee.feeType === SwapFeeType.NETWORK_FEE);
+    if (!networkFee) {
+      return Promise.resolve([new TransactionError(BasicTxErrorType.INTERNAL_ERROR)]);
+    }
+    const feeTokenInfo = this.chainService.getAssetBySlug(networkFee.tokenSlug);
+    const feeTokenChain = this.chainService.getChainInfoByKey(feeTokenInfo.originChain);
+    const [feeTokenBalance, fromAssetBalance] = await Promise.all([this.balanceService.getTokenFreeBalance(params.address, feeTokenInfo.originChain, feeTokenInfo.slug), this.balanceService.getTokenFreeBalance(params.address, fromAsset.originChain, fromAsset.slug)]);
+    const bnFeeTokenBalance = new BigNumber(feeTokenBalance.value);
+    const bnFromAssetBalance = new BigNumber(fromAssetBalance.value);
+    if (bnFeeTokenBalance.lte(new BigNumber(networkFee.amount))) {
+      return Promise.resolve([new TransactionError(BasicTxErrorType.NOT_ENOUGH_BALANCE, `You don't have enough ${feeTokenInfo.symbol} (${feeTokenChain.name}) to pay transaction fee`)]);
+    }
+    if (params.selectedQuote.minSwap) {
+      const minProtocolSwap = new BigNumber(params.selectedQuote.minSwap);
+      if (!isXcmOk && bnFromAssetBalance.lte(minProtocolSwap)) {
+        const parsedMinSwapValue = formatNumber(minProtocolSwap, _getAssetDecimals(fromAsset));
+        return Promise.resolve([new TransactionError(SwapErrorType.SWAP_NOT_ENOUGH_BALANCE, `Insufficient balance. You need more than ${parsedMinSwapValue} ${fromAsset.symbol} to start swapping. Deposit ${fromAsset.symbol} and try again.`)]); // todo: min swap or amount?
+      }
+    }
+
+    const bnSrcAssetMinAmount = new BigNumber(_getTokenMinAmount(fromAsset));
+    const bnMaxBalanceSwap = bnFromAssetBalance.minus(bnSrcAssetMinAmount);
+    if (!isXcmOk && bnAmount.gte(bnMaxBalanceSwap)) {
+      const parsedMaxBalanceSwap = formatNumber(bnMaxBalanceSwap, _getAssetDecimals(fromAsset));
+      return Promise.resolve([new TransactionError(SwapErrorType.SWAP_EXCEED_ALLOWANCE, `Amount too high. Lower your amount ${bnMaxBalanceSwap.gt(0) ? `below ${parsedMaxBalanceSwap} ${fromAsset.symbol}` : ''} and try again`)]);
+    }
+    if (params.recipient) {
+      const toAsset = this.chainService.getAssetBySlug(params.selectedQuote.pair.to);
+      const destChainInfo = this.chainService.getChainInfoByKey(toAsset.originChain);
+      const isEvmAddress = isEthereumAddress(params.recipient);
+      const isEvmDestChain = _isChainEvmCompatible(destChainInfo);
+      if (isEvmAddress && !isEvmDestChain || !isEvmAddress && isEvmDestChain) {
+        return Promise.resolve([new TransactionError(SwapErrorType.INVALID_RECIPIENT)]);
+      }
+    }
+    return Promise.resolve([]);
+  }
+  get name() {
+    return this.providerName;
+  }
+  get slug() {
+    return this.providerSlug;
+  }
+  get providerInfo() {
+    return {
+      id: this.providerSlug,
+      name: this.providerName
+    };
+  }
+}

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

@@ -0,0 +1,30 @@
+import { COMMON_ASSETS } from '@subwallet/chain-list';
+import { SwapError } from '@subwallet/extension-base/background/errors/SwapError';
+import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
+import { BalanceService } from '@subwallet/extension-base/services/balance-service';
+import { ChainService } from '@subwallet/extension-base/services/chain-service';
+import { SwapBaseInterface } from '@subwallet/extension-base/services/swap-service/handler/base-handler';
+import { BaseStepDetail } from '@subwallet/extension-base/types/service-base';
+import { OptimalSwapPath, OptimalSwapPathParams, SwapEarlyValidation, SwapFeeInfo, SwapQuote, SwapRequest, SwapSubmitParams, SwapSubmitStepData, ValidateSwapProcessParams } from '@subwallet/extension-base/types/swap';
+export declare class ChainflipSwapHandler implements SwapBaseInterface {
+    private swapSdk;
+    private readonly isTestnet;
+    private swapBaseHandler;
+    constructor(chainService: ChainService, balanceService: BalanceService, isTestnet?: boolean);
+    get chainService(): ChainService;
+    get balanceService(): BalanceService;
+    get providerInfo(): import("@subwallet/extension-base/types/swap").SwapProvider;
+    get name(): string;
+    get slug(): string;
+    get assetMapping(): Record<string, import("@chainflip/sdk/dist/contracts-b0BB7B5m").A>;
+    get chainMapping(): Record<string, import("@chainflip/sdk/dist/contracts-b0BB7B5m").C>;
+    get intermediaryAssetSlug(): COMMON_ASSETS.USDC_ETHEREUM | COMMON_ASSETS.USDC_SEPOLIA;
+    validateSwapRequest(request: SwapRequest): Promise<SwapEarlyValidation>;
+    private parseSwapPath;
+    getSwapQuote(request: SwapRequest): Promise<SwapQuote | SwapError>;
+    validateSwapProcess(params: ValidateSwapProcessParams): Promise<TransactionError[]>;
+    handleSubmitStep(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
+    handleSwapProcess(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
+    getSubmitStep(params: OptimalSwapPathParams): Promise<[BaseStepDetail, SwapFeeInfo] | undefined>;
+    generateOptimalProcess(params: OptimalSwapPathParams): Promise<OptimalSwapPath>;
+}