@subwallet/extension-base 1.3.3-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

@@ -30,6 +30,10 @@ interface Validator {
 }
 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>;

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

@@ -13,13 +13,17 @@ import { BN, BN_TEN, BN_ZERO } from '@polkadot/util';
 import { calculateReward } from "../../utils/index.js";
 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 */

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/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;
+}

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

@@ -0,0 +1,252 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import { CRON_LISTEN_AVAIL_BRIDGE_CLAIM } from '@subwallet/extension-base/constants';
+import { fetchLastestRemindNotificationTime } from '@subwallet/extension-base/constants/remind-notification-time';
+import { ServiceStatus } from '@subwallet/extension-base/services/base/types';
+import { NotificationDescriptionMap, NotificationTitleMap, ONE_DAY_MILLISECOND } from '@subwallet/extension-base/services/inapp-notification-service/consts';
+import { NotificationActionType, NotificationTab } from '@subwallet/extension-base/services/inapp-notification-service/interfaces';
+import { AvailBridgeSourceChain, fetchAllAvailBridgeClaimable, hrsToMillisecond } from '@subwallet/extension-base/services/inapp-notification-service/utils';
+import { categoryAddresses, formatNumber } from '@subwallet/extension-base/utils';
+import { isSubstrateAddress } from '@subwallet/keyring';
+export class InappNotificationService {
+  constructor(dbService, keyringService, eventService, chainService) {
+    this.dbService = dbService;
+    this.keyringService = keyringService;
+    this.eventService = eventService;
+    this.chainService = chainService;
+    this.status = ServiceStatus.NOT_INITIALIZED;
+  }
+  async init() {
+    this.status = ServiceStatus.INITIALIZING;
+    await this.eventService.waitAccountReady;
+    this.status = ServiceStatus.INITIALIZED;
+    await this.start();
+    this.onAccountProxyRemove();
+  }
+  async markAllRead(proxyId) {
+    await this.dbService.markAllRead(proxyId);
+  }
+  async switchReadStatus(params) {
+    await this.dbService.switchReadStatus(params);
+  }
+  subscribeUnreadNotificationsCountMap(callback) {
+    return this.dbService.subscribeUnreadNotificationsCountMap().subscribe({
+      next: callback
+    });
+  }
+  async getUnreadNotificationsCountMap() {
+    return await this.dbService.getUnreadNotificationsCountMap();
+  }
+  async fetchNotificationsByParams(params) {
+    return this.dbService.getNotificationsByParams(params);
+  }
+  async getNotificationById(id) {
+    return this.dbService.getNotification(id);
+  }
+  cleanUpOldNotifications(overdueTime = ONE_DAY_MILLISECOND * 60) {
+    return this.dbService.cleanUpOldNotifications(overdueTime);
+  }
+  passValidateNotification(candidateNotification, comparedNotifications, remindTimeConfigInHrs) {
+    // todo: simplify condition !!
+    if ([NotificationActionType.WITHDRAW, NotificationActionType.CLAIM].includes(candidateNotification.actionType)) {
+      const {
+        actionType,
+        address,
+        metadata,
+        time
+      } = candidateNotification;
+      const candidateMetadata = metadata;
+      const remindTime = hrsToMillisecond(remindTimeConfigInHrs[candidateNotification.actionType]);
+      for (const comparedNotification of comparedNotifications) {
+        const specialCase = comparedNotification.actionType === NotificationActionType.WITHDRAW && !comparedNotification.isRead;
+        if (comparedNotification.address !== address) {
+          continue;
+        }
+        if (comparedNotification.actionType !== actionType) {
+          continue;
+        }
+        const comparedMetadata = comparedNotification.metadata;
+        const sameNotification = candidateMetadata.stakingType === comparedMetadata.stakingType && candidateMetadata.stakingSlug === comparedMetadata.stakingSlug;
+        if (!sameNotification) {
+          continue;
+        }
+        if (time - comparedNotification.time <= remindTime) {
+          return false;
+        } else {
+          if (specialCase) {
+            return false;
+          }
+        }
+      }
+    }
+    if ([NotificationActionType.CLAIM_AVAIL_BRIDGE_ON_ETHEREUM, NotificationActionType.CLAIM_AVAIL_BRIDGE_ON_AVAIL].includes(candidateNotification.actionType)) {
+      const {
+        address,
+        metadata,
+        time
+      } = candidateNotification;
+      const candidateMetadata = metadata;
+      const remindTime = hrsToMillisecond(remindTimeConfigInHrs[candidateNotification.actionType]);
+      for (const notification of comparedNotifications) {
+        if (notification.address !== address) {
+          continue;
+        }
+        if (time - notification.time >= remindTime) {
+          continue;
+        }
+        const comparedMetadata = notification.metadata;
+        const sameNotification = candidateMetadata.messageId === comparedMetadata.messageId && candidateMetadata.sourceBlockHash === comparedMetadata.sourceBlockHash && candidateMetadata.sourceTransactionHash === comparedMetadata.sourceTransactionHash;
+        if (sameNotification) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+  async validateAndWriteNotificationsToDB(notifications, address) {
+    const proxyId = this.keyringService.context.belongUnifiedAccount(address) || address;
+    const accountName = this.keyringService.context.getCurrentAccountProxyName(proxyId);
+    const passNotifications = [];
+    const [comparedNotifications, remindTimeConfig] = await Promise.all([this.fetchNotificationsByParams({
+      notificationTab: NotificationTab.ALL,
+      proxyId
+    }), await fetchLastestRemindNotificationTime()]);
+    for (const candidateNotification of notifications) {
+      candidateNotification.title = candidateNotification.title.replace('{{accountName}}', accountName);
+      if (this.passValidateNotification(candidateNotification, comparedNotifications, remindTimeConfig)) {
+        passNotifications.push({
+          ...candidateNotification,
+          proxyId
+        });
+      }
+    }
+    await this.dbService.upsertNotifications(passNotifications);
+  }
+  cronCreateAvailBridgeClaimNotification() {
+    clearTimeout(this.refeshAvailBridgeClaimTimeOut);
+    this.createAvailBridgeClaimNotification();
+    this.refeshAvailBridgeClaimTimeOut = setTimeout(this.cronCreateAvailBridgeClaimNotification.bind(this), CRON_LISTEN_AVAIL_BRIDGE_CLAIM);
+  }
+  createAvailBridgeClaimNotification() {
+    const addresses = this.keyringService.context.getAllAddresses();
+    const {
+      evm: evmAddresses,
+      substrate: substrateAddresses
+    } = categoryAddresses(addresses);
+    const chainAssets = this.chainService.getAssetRegistry();
+    let ASSET_TYPE;
+    (function (ASSET_TYPE) {
+      ASSET_TYPE["TEST_EVM"] = "test_evm";
+      ASSET_TYPE["TEST_SUBSTRATE"] = "test_substrate";
+      ASSET_TYPE["MAIN_EVM"] = "main_evm";
+      ASSET_TYPE["MAIN_SUBSTRATE"] = "main_substrate";
+    })(ASSET_TYPE || (ASSET_TYPE = {}));
+    const chainAssetMap = Object.values(chainAssets).reduce((acc, chainAsset) => {
+      let type;
+      if (chainAsset.symbol === 'AVAIL') {
+        if (chainAsset.originChain === 'sepolia_ethereum') {
+          type = ASSET_TYPE.TEST_EVM;
+        } else if (chainAsset.originChain === 'availTuringTest') {
+          type = ASSET_TYPE.TEST_SUBSTRATE;
+        } else if (chainAsset.originChain === 'ethereum') {
+          type = ASSET_TYPE.MAIN_EVM;
+        } else if (chainAsset.originChain === 'avail_mainnet') {
+          type = ASSET_TYPE.MAIN_SUBSTRATE;
+        }
+      }
+      if (type) {
+        acc[type] = chainAsset;
+      }
+      return acc;
+    }, {});
+    substrateAddresses.forEach(address => {
+      fetchAllAvailBridgeClaimable(address, AvailBridgeSourceChain.ETHEREUM, true).then(async transactions => await this.processWriteAvailBridgeClaim(address, transactions, chainAssetMap[ASSET_TYPE.TEST_SUBSTRATE])).catch(console.error);
+      fetchAllAvailBridgeClaimable(address, AvailBridgeSourceChain.ETHEREUM, false).then(async transactions => await this.processWriteAvailBridgeClaim(address, transactions, chainAssetMap[ASSET_TYPE.MAIN_SUBSTRATE])).catch(console.error);
+    });
+    evmAddresses.forEach(address => {
+      fetchAllAvailBridgeClaimable(address, AvailBridgeSourceChain.AVAIL, true).then(async transactions => await this.processWriteAvailBridgeClaim(address, transactions, chainAssetMap[ASSET_TYPE.TEST_EVM])).catch(console.error);
+      fetchAllAvailBridgeClaimable(address, AvailBridgeSourceChain.AVAIL, false).then(async transactions => await this.processWriteAvailBridgeClaim(address, transactions, chainAssetMap[ASSET_TYPE.MAIN_EVM])).catch(console.error);
+    });
+  }
+  async processWriteAvailBridgeClaim(address, transactions, token) {
+    var _token$decimals;
+    const actionType = isSubstrateAddress(address) ? NotificationActionType.CLAIM_AVAIL_BRIDGE_ON_AVAIL : NotificationActionType.CLAIM_AVAIL_BRIDGE_ON_ETHEREUM;
+    const timestamp = Date.now();
+    const symbol = token.symbol;
+    const decimals = (_token$decimals = token.decimals) !== null && _token$decimals !== void 0 ? _token$decimals : 0;
+    const notifications = transactions.map(transaction => {
+      const {
+        amount,
+        depositorAddress,
+        messageId,
+        receiverAddress,
+        sourceBlockHash,
+        sourceChain,
+        sourceTransactionHash,
+        sourceTransactionIndex,
+        status
+      } = transaction;
+      const metadata = {
+        chainSlug: token.originChain,
+        tokenSlug: token.slug,
+        messageId,
+        sourceChain,
+        sourceTransactionHash,
+        depositorAddress,
+        receiverAddress,
+        amount,
+        sourceBlockHash,
+        sourceTransactionIndex,
+        status
+      };
+      return {
+        id: `${actionType}___${messageId}___${timestamp}`,
+        address: address,
+        // address is receiverAddress
+        title: NotificationTitleMap[actionType].replace('{{tokenSymbol}}', symbol),
+        description: NotificationDescriptionMap[actionType](formatNumber(amount, decimals), symbol),
+        time: timestamp,
+        extrinsicType: ExtrinsicType.CLAIM_AVAIL_BRIDGE,
+        isRead: false,
+        actionType,
+        metadata
+      };
+    });
+    await this.validateAndWriteNotificationsToDB(notifications, address);
+  }
+  async start() {
+    if (this.status === ServiceStatus.STARTED) {
+      return;
+    }
+    try {
+      this.status = ServiceStatus.STARTING;
+      await this.startCron();
+      this.status = ServiceStatus.STARTED;
+    } catch (e) {}
+  }
+  async startCron() {
+    this.cleanUpOldNotifications().catch(console.error);
+    this.cronCreateAvailBridgeClaimNotification();
+    return Promise.resolve();
+  }
+  async stop() {
+    try {
+      this.status = ServiceStatus.STOPPING;
+      await this.stopCron();
+      this.status = ServiceStatus.STOPPED;
+    } catch (e) {}
+  }
+  stopCron() {
+    return Promise.resolve(undefined);
+  }
+  onAccountProxyRemove() {
+    this.eventService.on('accountProxy.remove', proxyId => {
+      this.removeAccountNotifications(proxyId);
+    });
+  }
+  removeAccountNotifications(proxyId) {
+    this.dbService.removeAccountNotifications(proxyId).catch(console.error);
+  }
+}

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

@@ -0,0 +1,77 @@
+import { ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import { AvailBridgeSourceChain, AvailBridgeTransactionStatus } from '@subwallet/extension-base/services/inapp-notification-service/utils';
+import { YieldPoolType } from '@subwallet/extension-base/types';
+export interface _BaseNotificationInfo {
+    id: string;
+    title: string;
+    description: string;
+    address: string;
+    time: number;
+    extrinsicType: ExtrinsicType;
+    isRead: boolean;
+    actionType: NotificationActionType;
+    metadata: ActionTypeToMetadataMap[NotificationActionType];
+}
+export interface _NotificationInfo extends _BaseNotificationInfo {
+    proxyId: string;
+}
+export interface ActionTypeToMetadataMap {
+    [NotificationActionType.SEND]: SendReceiveNotificationMetadata;
+    [NotificationActionType.RECEIVE]: SendReceiveNotificationMetadata;
+    [NotificationActionType.WITHDRAW]: WithdrawClaimNotificationMetadata;
+    [NotificationActionType.CLAIM]: WithdrawClaimNotificationMetadata;
+    [NotificationActionType.CLAIM_AVAIL_BRIDGE_ON_AVAIL]: ClaimAvailBridgeNotificationMetadata;
+    [NotificationActionType.CLAIM_AVAIL_BRIDGE_ON_ETHEREUM]: ClaimAvailBridgeNotificationMetadata;
+}
+export interface SendReceiveNotificationMetadata {
+    chain: string;
+    from: string;
+    to: string;
+    extrinsicHash: string;
+    amount: bigint;
+    tokenSlug: string;
+}
+export interface WithdrawClaimNotificationMetadata {
+    stakingType: YieldPoolType;
+    stakingSlug: string;
+}
+export interface ClaimAvailBridgeNotificationMetadata {
+    chainSlug: string;
+    tokenSlug: string;
+    messageId: string;
+    sourceChain: AvailBridgeSourceChain;
+    sourceTransactionHash: string;
+    depositorAddress: string;
+    receiverAddress: string;
+    amount: string;
+    sourceBlockHash: string;
+    sourceTransactionIndex: string;
+    status: AvailBridgeTransactionStatus;
+}
+export declare enum NotificationTimePeriod {
+    TODAY = "TODAY",
+    THIS_WEEK = "THIS_WEEK",
+    THIS_MONTH = "THIS_MONTH"
+}
+export declare enum NotificationActionType {
+    SEND = "SEND",
+    RECEIVE = "RECEIVE",
+    WITHDRAW = "WITHDRAW",
+    CLAIM = "CLAIM",
+    CLAIM_AVAIL_BRIDGE_ON_AVAIL = "CLAIM_AVAIL_BRIDGE_ON_AVAIL",
+    CLAIM_AVAIL_BRIDGE_ON_ETHEREUM = "CLAIM_AVAIL_BRIDGE_ON_ETHEREUM"
+}
+export declare enum NotificationTab {
+    ALL = "ALL",
+    UNREAD = "UNREAD",
+    READ = "READ"
+}
+export interface ShowNotificationPayload {
+    earningClaim: boolean;
+    earningWithdraw: boolean;
+    availBridgeClaim: boolean;
+}
+export interface NotificationSetup {
+    isEnabled: boolean;
+    showNotice: ShowNotificationPayload;
+}

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

@@ -0,0 +1,24 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export let NotificationTimePeriod;
+(function (NotificationTimePeriod) {
+  NotificationTimePeriod["TODAY"] = "TODAY";
+  NotificationTimePeriod["THIS_WEEK"] = "THIS_WEEK";
+  NotificationTimePeriod["THIS_MONTH"] = "THIS_MONTH";
+})(NotificationTimePeriod || (NotificationTimePeriod = {}));
+export let NotificationActionType;
+(function (NotificationActionType) {
+  NotificationActionType["SEND"] = "SEND";
+  NotificationActionType["RECEIVE"] = "RECEIVE";
+  NotificationActionType["WITHDRAW"] = "WITHDRAW";
+  NotificationActionType["CLAIM"] = "CLAIM";
+  NotificationActionType["CLAIM_AVAIL_BRIDGE_ON_AVAIL"] = "CLAIM_AVAIL_BRIDGE_ON_AVAIL";
+  NotificationActionType["CLAIM_AVAIL_BRIDGE_ON_ETHEREUM"] = "CLAIM_AVAIL_BRIDGE_ON_ETHEREUM";
+})(NotificationActionType || (NotificationActionType = {}));
+export let NotificationTab;
+(function (NotificationTab) {
+  NotificationTab["ALL"] = "ALL";
+  NotificationTab["UNREAD"] = "UNREAD";
+  NotificationTab["READ"] = "READ";
+})(NotificationTab || (NotificationTab = {}));

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

@@ -0,0 +1,55 @@
+import { _ChainAsset } from '@subwallet/chain-list/types';
+import { _BaseNotificationInfo, NotificationTab } from '@subwallet/extension-base/services/inapp-notification-service/interfaces';
+import { EarningRewardItem, UnstakingInfo, YieldPoolType } from '@subwallet/extension-base/types';
+export declare function getWithdrawDescription(amount: string, symbol: string, stakingType: YieldPoolType): string;
+export declare function getClaimDescription(amount: string, symbol: string): string;
+export declare function getSendDescription(amount: string, symbol: string): string;
+export declare function getReceiveDescription(amount: string, symbol: string): string;
+export declare function getAvailBridgeClaimDescription(amount: string, symbol: string): string;
+export declare function getIsTabRead(notificationTab: NotificationTab): boolean | undefined;
+export declare function createWithdrawNotifications(unstakingInfos: UnstakingInfo[], tokenInfo: _ChainAsset, address: string, stakingSlug: string, stakingType: YieldPoolType): _BaseNotificationInfo[];
+export declare function createClaimNotification(claimItemInfo: EarningRewardItem, tokenInfo: _ChainAsset): _BaseNotificationInfo;
+export declare const AVAIL_BRIDGE_INDEXER: {
+    AVAIL_MAINNET: string;
+    AVAIL_TESTNET: string;
+};
+export declare const AVAIL_BRIDGE_API: {
+    AVAIL_MAINNET: string;
+    AVAIL_TESTNET: string;
+};
+interface AvailBridgeTransactionsResponse {
+    data: {
+        paginationData: {
+            hasNextPage: boolean;
+            page: number;
+            pageSize: number;
+            totalCount: number;
+        };
+        result: AvailBridgeTransaction[];
+    };
+}
+export interface AvailBridgeTransaction {
+    messageId: string;
+    sourceChain: AvailBridgeSourceChain;
+    sourceTransactionHash: string;
+    depositorAddress: string;
+    receiverAddress: string;
+    amount: string;
+    sourceBlockHash: string;
+    sourceTransactionIndex: string;
+    status: AvailBridgeTransactionStatus;
+}
+export declare enum AvailBridgeTransactionStatus {
+    READY_TO_CLAIM = "READY_TO_CLAIM",
+    CLAIMED = "CLAIMED",
+    BRIDGED = "BRIDGED"
+}
+export declare enum AvailBridgeSourceChain {
+    AVAIL = "AVAIL",
+    ETHEREUM = "ETHEREUM"
+}
+export declare function fetchAllAvailBridgeClaimable(address: string, sourceChain: AvailBridgeSourceChain, isTestnet: boolean): Promise<AvailBridgeTransaction[]>;
+export declare function fetchAvailBridgeTransactions(userAddress: string, sourceChain: AvailBridgeSourceChain, status: AvailBridgeTransactionStatus, pageSize: number | undefined, page: number | undefined, isTestnet: boolean): Promise<AvailBridgeTransactionsResponse | undefined>;
+export declare function filterClaimableOfAddress(address: string, transactions: AvailBridgeTransaction[]): AvailBridgeTransaction[];
+export declare function hrsToMillisecond(hours: number): number;
+export {};