@subwallet/extension-base 1.3.2-0 → 1.3.4-0

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

@@ -159,6 +159,7 @@ export default class AmplitudeNativeStakingPoolHandler extends BaseParaNativeSta
     }
     const totalBalance = new BN(activeStake).add(new BN(unstakingBalance));
     const stakingStatus = getEarningStatusByNominations(new BN(activeStake), nominationList);
+    await this.createWithdrawNotifications(unstakingList, this.nativeToken, address);
     return {
       status: stakingStatus,
       balanceToken: this.nativeToken.slug,
@@ -244,13 +245,20 @@ export default class AmplitudeNativeStakingPoolHandler extends BaseParaNativeSta
         if (cancel) {
           return;
         }
-        callBack({
+        const earningRewardItem = {
           ...this.baseInfo,
           address: address,
           type: this.type,
           unclaimedReward: _unclaimedReward.toString(),
           state: APIItemState.READY
-        });
+        };
+
+        // TODO: Enable this when claim action is ready
+        // if (_unclaimedReward.toString() !== '0') {
+        //   await this.createClaimNotification(earningRewardItem, this.nativeToken);
+        // }
+
+        callBack(earningRewardItem);
       }));
     }
     return () => {

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

@@ -209,6 +209,8 @@ export default class ParaNativeStakingPoolHandler extends BaseParaNativeStakingP
     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,

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

@@ -171,6 +171,8 @@ export default class RelayNativeStakingPoolHandler extends BaseNativeStakingPool
         targetTimestampMs: targetTimestampMs
       });
     });
+    const tokenInfo = this.state.chainService.getAssetBySlug(this.nativeToken.slug);
+    await this.createWithdrawNotifications(unstakingList, tokenInfo, address);
     return {
       status: stakingStatus,
       balanceToken: this.nativeToken.slug,

package/services/earning-service/handlers/native-staking/tao.d.ts

@@ -7,36 +7,40 @@ interface TaoStakingStakeOption {
     amount: string;
 }
 export interface RawDelegateState {
-    items: Array<{
-        balance: string;
-        delegate_address: {
+    data: Array<{
+        delegate: {
             ss58: string;
         };
+        balance: string;
     }>;
 }
 interface ValidatorResponse {
-    count: number;
-    validators: Validator[];
+    data: Validator[];
 }
 interface Validator {
-    validator_stake: string;
-    amount: string;
-    nominators: number;
-    apr: string;
-    hot_key: {
+    hotkey: {
         ss58: string;
     };
+    name: string;
+    nominators: number;
+    stake: string;
+    validator_stake: string;
     take: string;
-    system_total_stake: string;
+    apr: string;
 }
 export declare const BITTENSOR_API_KEY_1: string;
 export declare const BITTENSOR_API_KEY_2: string;
+export declare const BITTENSOR_API_KEY_3: string;
+export declare const BITTENSOR_API_KEY_4: string;
+export declare const BITTENSOR_API_KEY_5: string;
+export declare const BITTENSOR_API_KEY_6: string;
 export declare const bittensorApiKey: () => string;
 export declare function fetchDelegates(): Promise<ValidatorResponse>;
 export declare function fetchTaoDelegateState(address: string): Promise<RawDelegateState>;
 export default class TaoNativeStakingPoolHandler extends BaseParaStakingPoolHandler {
     handleYieldWithdraw(address: string, unstakingInfo: UnstakingInfo): Promise<TransactionData>;
     handleYieldCancelUnstake(params: StakeCancelWithdrawalParams): Promise<TransactionData>;
+    get maintainBalance(): string;
     subscribePoolInfo(callback: (data: YieldPoolInfo) => void): Promise<VoidFunction>;
     parseNominatorMetadata(chainInfo: _ChainInfo, address: string, delegatorState: TaoStakingStakeOption[]): Promise<Omit<YieldPositionInfo, keyof BaseYieldPositionInfo>>;
     subscribePoolPosition(useAddresses: string[], rsCallback: (rs: YieldPositionInfo) => void): Promise<VoidFunction>;

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

@@ -9,23 +9,21 @@ import BaseParaStakingPoolHandler from '@subwallet/extension-base/services/earni
 import { BasicTxErrorType, EarningStatus } from '@subwallet/extension-base/types';
 import { reformatAddress } from '@subwallet/extension-base/utils';
 import BigN from 'bignumber.js';
-import { BN, BN_ZERO } from '@polkadot/util';
+import { BN, BN_TEN, BN_ZERO } from '@polkadot/util';
 import { calculateReward } from "../../utils/index.js";
-// interface ValidatorName {
-//   count: number;
-//   delegates: {
-//     name: string;
-//   }[];
-// }
 export const BITTENSOR_API_KEY_1 = process.env.BITTENSOR_API_KEY_1 || '';
 export const BITTENSOR_API_KEY_2 = process.env.BITTENSOR_API_KEY_2 || '';
+export const BITTENSOR_API_KEY_3 = process.env.BITTENSOR_API_KEY_3 || '';
+export const BITTENSOR_API_KEY_4 = process.env.BITTENSOR_API_KEY_4 || '';
+export const BITTENSOR_API_KEY_5 = process.env.BITTENSOR_API_KEY_5 || '';
+export const BITTENSOR_API_KEY_6 = process.env.BITTENSOR_API_KEY_6 || '';
 function random(...keys) {
   const validKeys = keys.filter(key => key);
   const randomIndex = Math.floor(Math.random() * validKeys.length);
   return validKeys[randomIndex];
 }
 export const bittensorApiKey = () => {
-  return random(BITTENSOR_API_KEY_1, BITTENSOR_API_KEY_2);
+  return random(BITTENSOR_API_KEY_1, BITTENSOR_API_KEY_2, BITTENSOR_API_KEY_3, BITTENSOR_API_KEY_4, BITTENSOR_API_KEY_5, BITTENSOR_API_KEY_6);
 };
 
 /* Fetch data */
@@ -33,7 +31,7 @@ export const bittensorApiKey = () => {
 export async function fetchDelegates() {
   const apiKey = bittensorApiKey();
   return new Promise(function (resolve) {
-    fetch('https://api.taostats.io/api/v1/validator?order=amount%3Adesc&limit=100', {
+    fetch('https://api-prod-v2.taostats.io/api/validator/latest/v1', {
       method: 'GET',
       headers: {
         'Content-Type': 'application/json',
@@ -47,7 +45,7 @@ export async function fetchDelegates() {
 export async function fetchTaoDelegateState(address) {
   const apiKey = bittensorApiKey();
   return new Promise(function (resolve) {
-    fetch(`https://api.taostats.io/api/v1/delegate/balance?nominator_address=${address}`, {
+    fetch(`https://api-prod-v2.taostats.io/api/delegation/balance/latest/v1?nominator=${address}`, {
       method: 'GET',
       headers: {
         'Content-Type': 'application/json',
@@ -81,21 +79,12 @@ export default class TaoNativeStakingPoolHandler extends BaseParaStakingPoolHand
   }
   /* Unimplemented function  */
 
-  // async fetchDelegatesInfo (address: string): Promise<ValidatorName> {
-  //   const apiKey = this.bittensorApiKey;
-
-  //   return new Promise(function (resolve) {
-  //     fetch(`https://api.taostats.io/api/v1/delegate/info?address=${address}`, {
-  //       method: 'GET',
-  //       headers: {
-  //         'Content-Type': 'application/json',
-  //         Authorization: `${apiKey}`
-  //       }
-  //     }).then((resp) => {
-  //       resolve(resp.json());
-  //     }).catch(console.error);
-  //   });
-  // }
+  get maintainBalance() {
+    const ed = new BN(this.nativeToken.minAmount || '0');
+    const calculateMaintainBalance = new BN(15).mul(ed).div(BN_TEN);
+    const maintainBalance = calculateMaintainBalance;
+    return maintainBalance.toString();
+  }
 
   /* Subscribe pool info */
 
@@ -228,11 +217,11 @@ export default class TaoNativeStakingPoolHandler extends BaseParaStakingPoolHand
           const owner = reformatAddress(useAddresses[i], 42);
           const delegatorState = [];
           let bnTotalBalance = BN_ZERO;
-          const delegateStateInfo = rawDelegateStateInfo.items;
+          const delegateStateInfo = rawDelegateStateInfo.data;
           for (const delegate of delegateStateInfo) {
             bnTotalBalance = bnTotalBalance.add(new BN(delegate.balance));
             delegatorState.push({
-              owner: delegate.delegate_address.ss58,
+              owner: delegate.delegate.ss58,
               amount: delegate.balance.toString()
             });
           }
@@ -315,11 +304,11 @@ export default class TaoNativeStakingPoolHandler extends BaseParaStakingPoolHand
     const getNominatorMinRequiredStake = this.substrateApi.api.query.subtensorModule.nominatorMinRequiredStake();
     const nominatorMinRequiredStake = (await getNominatorMinRequiredStake).toString();
     const bnMinBond = new BN(nominatorMinRequiredStake);
-    const validatorList = topValidator.validators;
+    const validatorList = topValidator.data;
     const validatorAddresses = Object.keys(validatorList);
     const results = await Promise.all(validatorAddresses.map(i => {
-      const address = validatorList[i].hot_key.ss58;
-      const bnTotalStake = new BN(validatorList[i].amount);
+      const address = validatorList[i].hotkey.ss58;
+      const bnTotalStake = new BN(validatorList[i].stake);
       const bnOwnStake = new BN(validatorList[i].validator_stake);
       const otherStake = bnTotalStake.sub(bnOwnStake);
       const nominatorCount = validatorList[i].nominators;
@@ -327,12 +316,7 @@ export default class TaoNativeStakingPoolHandler extends BaseParaStakingPoolHand
       const roundedCommission = (parseFloat(commission) * 100).toFixed(0);
       const apr = (parseFloat(validatorList[i].apr) / 10 ** 9 * 100).toFixed(2);
       const apyCalculate = calculateReward(parseFloat(apr));
-
-      // let name = '';
-      // const delegateInfo = await this.fetchDelegatesInfo(address);
-
-      // name = delegateInfo.delegates[0]?.name || address;
-
+      const name = validatorList[i].name || address;
       return {
         address: address,
         totalStake: bnTotalStake.toString(),
@@ -346,10 +330,9 @@ export default class TaoNativeStakingPoolHandler extends BaseParaStakingPoolHand
         isVerified: false,
         chain: this.chain,
         isCrowded: false,
-        identity: address // name
+        identity: name
       };
     }));
-
     return results;
   }
   async getPoolTargets() {

package/services/earning-service/handlers/nomination-pool/index.d.ts

@@ -15,7 +15,7 @@ export default class NominationPoolHandler extends BasePoolHandler {
     constructor(state: KoniState, chain: string);
     protected getDescription(amount?: string): string;
     subscribePoolInfo(callback: (data: YieldPoolInfo) => void): Promise<VoidFunction>;
-    parsePoolMemberMetadata(substrateApi: _SubstrateApi, poolMemberInfo: PalletNominationPoolsPoolMember, currentEra: string, _deriveSessionProgress: DeriveSessionProgress): Promise<Omit<YieldPositionInfo, keyof BaseYieldPositionInfo>>;
+    parsePoolMemberMetadata(substrateApi: _SubstrateApi, poolMemberInfo: PalletNominationPoolsPoolMember, currentEra: string, _deriveSessionProgress: DeriveSessionProgress, address: string): Promise<Omit<YieldPositionInfo, keyof BaseYieldPositionInfo>>;
     subscribePoolPosition(useAddresses: string[], resultCallback: (rs: YieldPositionInfo) => void): Promise<VoidFunction>;
     getPoolReward(useAddresses: string[], callBack: (rs: EarningRewardItem) => void): Promise<VoidFunction>;
     getPoolRewardHistory(useAddresses: string[], callBack: (rs: EarningRewardHistoryItem) => void): Promise<VoidFunction>;

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

@@ -145,7 +145,7 @@ export default class NominationPoolHandler extends BasePoolHandler {
 
   /* Subscribe pool position */
 
-  async parsePoolMemberMetadata(substrateApi, poolMemberInfo, currentEra, _deriveSessionProgress) {
+  async parsePoolMemberMetadata(substrateApi, poolMemberInfo, currentEra, _deriveSessionProgress, address) {
     const chainInfo = this.chainInfo;
     const unlimitedNominatorRewarded = substrateApi.api.consts.staking.maxExposurePageSize !== undefined;
     const _maxNominatorRewardedPerValidator = (substrateApi.api.consts.staking.maxNominatorRewardedPerValidator || 0).toString();
@@ -215,6 +215,7 @@ export default class NominationPoolHandler extends BasePoolHandler {
     if (!bnActiveStake.gt(BN_ZERO)) {
       stakingStatus = EarningStatus.NOT_EARNING;
     }
+    await this.createWithdrawNotifications(unstakings, this.nativeToken, address);
     return {
       status: stakingStatus,
       balanceToken: this.nativeToken.slug,
@@ -246,7 +247,7 @@ export default class NominationPoolHandler extends BasePoolHandler {
           const poolMemberInfo = _poolMemberInfo.toPrimitive();
           const owner = reformatAddress(useAddresses[i], 42);
           if (poolMemberInfo) {
-            const nominatorMetadata = await this.parsePoolMemberMetadata(substrateApi, poolMemberInfo, currentEra, _deriveSessionProgress);
+            const nominatorMetadata = await this.parsePoolMemberMetadata(substrateApi, poolMemberInfo, currentEra, _deriveSessionProgress, owner);
             resultCallback({
               ...defaultInfo,
               ...nominatorMetadata,
@@ -292,13 +293,17 @@ export default class NominationPoolHandler extends BasePoolHandler {
           var _substrateApi$api$cal, _substrateApi$api$cal2;
           const _unclaimedReward = await ((_substrateApi$api$cal = substrateApi.api.call) === null || _substrateApi$api$cal === void 0 ? void 0 : (_substrateApi$api$cal2 = _substrateApi$api$cal.nominationPoolsApi) === null || _substrateApi$api$cal2 === void 0 ? void 0 : _substrateApi$api$cal2.pendingRewards(address));
           if (_unclaimedReward) {
-            callBack({
+            const earningRewardItem = {
               ...this.baseInfo,
               address: address,
               type: this.type,
               unclaimedReward: _unclaimedReward.toString(),
               state: APIItemState.READY
-            });
+            };
+            if (_unclaimedReward.toString() !== '0') {
+              await this.createClaimNotification(earningRewardItem, this.nativeToken);
+            }
+            callBack(earningRewardItem);
           }
         }
       }

package/services/earning-service/service.d.ts

@@ -69,6 +69,8 @@ export default class EarningService implements StoppableServiceInterface, Persis
     subscribeEarningReward(): BehaviorSubject<EarningRewardJson>;
     getEarningRewards(): EarningRewardJson;
     earningsRewardInterval: NodeJS.Timer | undefined;
+    earningRewardReady: PromiseHandler<void>;
+    waitEarningRewardReady(): Promise<void>;
     runSubscribeStakingRewardInterval(): void;
     runUnsubscribeStakingRewardInterval(): void;
     fetchPoolRewardHistory(addresses: string[], callback: (result: EarningRewardHistoryItem) => void): Promise<VoidFunction>;

package/services/earning-service/service.js

@@ -516,6 +516,7 @@ export default class EarningService {
       stakingRewardState.ready = true;
       this.earningRewardSubject.next(stakingRewardState);
       this.earningsRewardQueue = [];
+      this.earningRewardReady.resolve();
     });
   }
   async getPoolReward(addresses, callback) {
@@ -553,6 +554,10 @@ export default class EarningService {
   getEarningRewards() {
     return this.earningRewardSubject.getValue();
   }
+  earningRewardReady = createPromiseHandler();
+  waitEarningRewardReady() {
+    return this.earningRewardReady.promise;
+  }
   runSubscribeStakingRewardInterval() {
     const addresses = this.state.keyringService.context.getDecodedAddresses();
     if (!addresses.length) {

package/services/earning-service/utils/index.d.ts

@@ -1,5 +1,4 @@
 import { _SubstrateApi } from '@subwallet/extension-base/services/chain-service/types';
-import { RawDelegateState } from '@subwallet/extension-base/services/earning-service/handlers/native-staking/tao';
 import { LendingYieldPoolInfo, LiquidYieldPoolInfo, NativeYieldPoolInfo, NominationYieldPoolInfo, YieldAssetExpectedEarning, YieldCompoundingPeriod, YieldPoolInfo, YieldPoolType } from '@subwallet/extension-base/types';
 import { BN } from '@polkadot/util';
 export declare function calculateReward(apr: number, amount?: number, compoundingPeriod?: YieldCompoundingPeriod, isApy?: boolean): YieldAssetExpectedEarning;
@@ -19,4 +18,3 @@ export declare const isNativeStakingPool: (pool: YieldPoolInfo) => pool is Nativ
 export declare const isLiquidPool: (pool: YieldPoolInfo) => pool is LiquidYieldPoolInfo;
 export declare const isLendingPool: (pool: YieldPoolInfo) => pool is LendingYieldPoolInfo;
 export declare function applyDecimal(bnNumber: BN, decimals: number): BN;
-export declare function getTaoTotalStake(rawDelegateState: RawDelegateState): bigint;

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

@@ -123,14 +123,4 @@ export const isLendingPool = pool => {
 export function applyDecimal(bnNumber, decimals) {
   const bnDecimals = new BN((10 ** decimals).toString());
   return bnNumber.div(bnDecimals);
-}
-export function getTaoTotalStake(rawDelegateState) {
-  const nodeInfos = rawDelegateState.items;
-  const stakes = nodeInfos.map(stake => stake.balance);
-  let totalStake = BigInt(0);
-  for (const _stake of stakes) {
-    const stakeAmount = BigInt(_stake);
-    totalStake += stakeAmount;
-  }
-  return totalStake;
 }

package/services/inapp-notification-service/consts.d.ts

@@ -0,0 +1,18 @@
+import { getAvailBridgeClaimDescription, getClaimDescription, getReceiveDescription, getSendDescription, getWithdrawDescription } from '@subwallet/extension-base/services/inapp-notification-service/utils';
+export declare const NotificationTitleMap: {
+    WITHDRAW: string;
+    CLAIM: string;
+    SEND: string;
+    RECEIVE: string;
+    CLAIM_AVAIL_BRIDGE_ON_AVAIL: string;
+    CLAIM_AVAIL_BRIDGE_ON_ETHEREUM: string;
+};
+export declare const NotificationDescriptionMap: {
+    WITHDRAW: typeof getWithdrawDescription;
+    CLAIM: typeof getClaimDescription;
+    SEND: typeof getSendDescription;
+    RECEIVE: typeof getReceiveDescription;
+    CLAIM_AVAIL_BRIDGE_ON_AVAIL: typeof getAvailBridgeClaimDescription;
+    CLAIM_AVAIL_BRIDGE_ON_ETHEREUM: typeof getAvailBridgeClaimDescription;
+};
+export declare const ONE_DAY_MILLISECOND: number;

package/services/inapp-notification-service/consts.js

@@ -0,0 +1,22 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { NotificationActionType } from '@subwallet/extension-base/services/inapp-notification-service/interfaces';
+import { getAvailBridgeClaimDescription, getClaimDescription, getReceiveDescription, getSendDescription, getWithdrawDescription } from '@subwallet/extension-base/services/inapp-notification-service/utils';
+export const NotificationTitleMap = {
+  [NotificationActionType.WITHDRAW]: '[{{accountName}}] WITHDRAW {{tokenSymbol}}',
+  [NotificationActionType.CLAIM]: '[{{accountName}}] CLAIM {{tokenSymbol}}',
+  [NotificationActionType.SEND]: '[{{accountName}}] SEND {{tokenSymbol}}',
+  [NotificationActionType.RECEIVE]: '[{{accountName}}] RECEIVE {{tokenSymbol}}',
+  [NotificationActionType.CLAIM_AVAIL_BRIDGE_ON_AVAIL]: '[{{accountName}}] CLAIM {{tokenSymbol}}',
+  [NotificationActionType.CLAIM_AVAIL_BRIDGE_ON_ETHEREUM]: '[{{accountName}}] CLAIM {{tokenSymbol}}'
+};
+export const NotificationDescriptionMap = {
+  [NotificationActionType.WITHDRAW]: getWithdrawDescription,
+  [NotificationActionType.CLAIM]: getClaimDescription,
+  [NotificationActionType.SEND]: getSendDescription,
+  [NotificationActionType.RECEIVE]: getReceiveDescription,
+  [NotificationActionType.CLAIM_AVAIL_BRIDGE_ON_AVAIL]: getAvailBridgeClaimDescription,
+  [NotificationActionType.CLAIM_AVAIL_BRIDGE_ON_ETHEREUM]: getAvailBridgeClaimDescription
+};
+export const ONE_DAY_MILLISECOND = 1000 * 24 * 60 * 60;

package/services/inapp-notification-service/index.d.ts

@@ -0,0 +1,37 @@
+import { _ChainAsset } from '@subwallet/chain-list/types';
+import { CronServiceInterface, ServiceStatus } from '@subwallet/extension-base/services/base/types';
+import { ChainService } from '@subwallet/extension-base/services/chain-service';
+import { EventService } from '@subwallet/extension-base/services/event-service';
+import { _BaseNotificationInfo, _NotificationInfo, NotificationActionType } from '@subwallet/extension-base/services/inapp-notification-service/interfaces';
+import { AvailBridgeTransaction } from '@subwallet/extension-base/services/inapp-notification-service/utils';
+import { KeyringService } from '@subwallet/extension-base/services/keyring-service';
+import DatabaseService from '@subwallet/extension-base/services/storage-service/DatabaseService';
+import { GetNotificationParams, RequestSwitchStatusParams } from '@subwallet/extension-base/types/notification';
+export declare class InappNotificationService implements CronServiceInterface {
+    private readonly dbService;
+    private readonly keyringService;
+    private readonly eventService;
+    private readonly chainService;
+    status: ServiceStatus;
+    private refeshAvailBridgeClaimTimeOut;
+    constructor(dbService: DatabaseService, keyringService: KeyringService, eventService: EventService, chainService: ChainService);
+    init(): Promise<void>;
+    markAllRead(proxyId: string): Promise<void>;
+    switchReadStatus(params: RequestSwitchStatusParams): Promise<void>;
+    subscribeUnreadNotificationsCountMap(callback: (data: Record<string, number>) => void): import("dexie").Subscription;
+    getUnreadNotificationsCountMap(): Promise<Record<string, number>>;
+    fetchNotificationsByParams(params: GetNotificationParams): Promise<_NotificationInfo[]>;
+    getNotificationById(id: string): Promise<_NotificationInfo | undefined>;
+    cleanUpOldNotifications(overdueTime?: number): Promise<number>;
+    passValidateNotification(candidateNotification: _BaseNotificationInfo, comparedNotifications: _NotificationInfo[], remindTimeConfigInHrs: Record<NotificationActionType, number>): boolean;
+    validateAndWriteNotificationsToDB(notifications: _BaseNotificationInfo[], address: string): Promise<void>;
+    cronCreateAvailBridgeClaimNotification(): void;
+    createAvailBridgeClaimNotification(): void;
+    processWriteAvailBridgeClaim(address: string, transactions: AvailBridgeTransaction[], token: _ChainAsset): Promise<void>;
+    start(): Promise<void>;
+    startCron(): Promise<void>;
+    stop(): Promise<void>;
+    stopCron(): Promise<void>;
+    onAccountProxyRemove(): void;
+    removeAccountNotifications(proxyId: string): void;
+}