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

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

@@ -4,7 +4,7 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = exports.bittensorApiKey = exports.BITTENSOR_API_KEY_2 = exports.BITTENSOR_API_KEY_1 = void 0;
+exports.default = exports.bittensorApiKey = exports.BITTENSOR_API_KEY_6 = exports.BITTENSOR_API_KEY_5 = exports.BITTENSOR_API_KEY_4 = exports.BITTENSOR_API_KEY_3 = exports.BITTENSOR_API_KEY_2 = exports.BITTENSOR_API_KEY_1 = void 0;
 exports.fetchDelegates = fetchDelegates;
 exports.fetchTaoDelegateState = fetchTaoDelegateState;
 var _TransactionError = require("@subwallet/extension-base/background/errors/TransactionError");
@@ -24,6 +24,14 @@ const BITTENSOR_API_KEY_1 = process.env.BITTENSOR_API_KEY_1 || '';
 exports.BITTENSOR_API_KEY_1 = BITTENSOR_API_KEY_1;
 const BITTENSOR_API_KEY_2 = process.env.BITTENSOR_API_KEY_2 || '';
 exports.BITTENSOR_API_KEY_2 = BITTENSOR_API_KEY_2;
+const BITTENSOR_API_KEY_3 = process.env.BITTENSOR_API_KEY_3 || '';
+exports.BITTENSOR_API_KEY_3 = BITTENSOR_API_KEY_3;
+const BITTENSOR_API_KEY_4 = process.env.BITTENSOR_API_KEY_4 || '';
+exports.BITTENSOR_API_KEY_4 = BITTENSOR_API_KEY_4;
+const BITTENSOR_API_KEY_5 = process.env.BITTENSOR_API_KEY_5 || '';
+exports.BITTENSOR_API_KEY_5 = BITTENSOR_API_KEY_5;
+const BITTENSOR_API_KEY_6 = process.env.BITTENSOR_API_KEY_6 || '';
+exports.BITTENSOR_API_KEY_6 = BITTENSOR_API_KEY_6;
 function random() {
   for (var _len = arguments.length, keys = new Array(_len), _key = 0; _key < _len; _key++) {
     keys[_key] = arguments[_key];
@@ -33,7 +41,7 @@ function random() {
   return validKeys[randomIndex];
 }
 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/cjs/services/earning-service/handlers/nomination-pool/index.js

@@ -153,7 +153,7 @@ class NominationPoolHandler extends _base.default {
 
   /* 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();
@@ -224,6 +224,7 @@ class NominationPoolHandler extends _base.default {
     if (!bnActiveStake.gt(_util.BN_ZERO)) {
       stakingStatus = _types.EarningStatus.NOT_EARNING;
     }
+    await this.createWithdrawNotifications(unstakings, this.nativeToken, address);
     return {
       status: stakingStatus,
       balanceToken: this.nativeToken.slug,
@@ -255,7 +256,7 @@ class NominationPoolHandler extends _base.default {
           const poolMemberInfo = _poolMemberInfo.toPrimitive();
           const owner = (0, _utils3.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,
@@ -301,13 +302,17 @@ class NominationPoolHandler extends _base.default {
           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: _KoniTypes.APIItemState.READY
-            });
+            };
+            if (_unclaimedReward.toString() !== '0') {
+              await this.createClaimNotification(earningRewardItem, this.nativeToken);
+            }
+            callBack(earningRewardItem);
           }
         }
       }

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

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

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

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ONE_DAY_MILLISECOND = exports.NotificationTitleMap = exports.NotificationDescriptionMap = void 0;
+var _interfaces = require("@subwallet/extension-base/services/inapp-notification-service/interfaces");
+var _utils = require("@subwallet/extension-base/services/inapp-notification-service/utils");
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+const NotificationTitleMap = {
+  [_interfaces.NotificationActionType.WITHDRAW]: '[{{accountName}}] WITHDRAW {{tokenSymbol}}',
+  [_interfaces.NotificationActionType.CLAIM]: '[{{accountName}}] CLAIM {{tokenSymbol}}',
+  [_interfaces.NotificationActionType.SEND]: '[{{accountName}}] SEND {{tokenSymbol}}',
+  [_interfaces.NotificationActionType.RECEIVE]: '[{{accountName}}] RECEIVE {{tokenSymbol}}',
+  [_interfaces.NotificationActionType.CLAIM_AVAIL_BRIDGE_ON_AVAIL]: '[{{accountName}}] CLAIM {{tokenSymbol}}',
+  [_interfaces.NotificationActionType.CLAIM_AVAIL_BRIDGE_ON_ETHEREUM]: '[{{accountName}}] CLAIM {{tokenSymbol}}'
+};
+exports.NotificationTitleMap = NotificationTitleMap;
+const NotificationDescriptionMap = {
+  [_interfaces.NotificationActionType.WITHDRAW]: _utils.getWithdrawDescription,
+  [_interfaces.NotificationActionType.CLAIM]: _utils.getClaimDescription,
+  [_interfaces.NotificationActionType.SEND]: _utils.getSendDescription,
+  [_interfaces.NotificationActionType.RECEIVE]: _utils.getReceiveDescription,
+  [_interfaces.NotificationActionType.CLAIM_AVAIL_BRIDGE_ON_AVAIL]: _utils.getAvailBridgeClaimDescription,
+  [_interfaces.NotificationActionType.CLAIM_AVAIL_BRIDGE_ON_ETHEREUM]: _utils.getAvailBridgeClaimDescription
+};
+exports.NotificationDescriptionMap = NotificationDescriptionMap;
+const ONE_DAY_MILLISECOND = 1000 * 24 * 60 * 60;
+exports.ONE_DAY_MILLISECOND = ONE_DAY_MILLISECOND;

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

@@ -0,0 +1,260 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.InappNotificationService = void 0;
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _constants = require("@subwallet/extension-base/constants");
+var _remindNotificationTime = require("@subwallet/extension-base/constants/remind-notification-time");
+var _types = require("@subwallet/extension-base/services/base/types");
+var _consts = require("@subwallet/extension-base/services/inapp-notification-service/consts");
+var _interfaces = require("@subwallet/extension-base/services/inapp-notification-service/interfaces");
+var _utils = require("@subwallet/extension-base/services/inapp-notification-service/utils");
+var _utils2 = require("@subwallet/extension-base/utils");
+var _keyring = require("@subwallet/keyring");
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class InappNotificationService {
+  constructor(dbService, keyringService, eventService, chainService) {
+    this.dbService = dbService;
+    this.keyringService = keyringService;
+    this.eventService = eventService;
+    this.chainService = chainService;
+    this.status = _types.ServiceStatus.NOT_INITIALIZED;
+  }
+  async init() {
+    this.status = _types.ServiceStatus.INITIALIZING;
+    await this.eventService.waitAccountReady;
+    this.status = _types.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() {
+    let overdueTime = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _consts.ONE_DAY_MILLISECOND * 60;
+    return this.dbService.cleanUpOldNotifications(overdueTime);
+  }
+  passValidateNotification(candidateNotification, comparedNotifications, remindTimeConfigInHrs) {
+    // todo: simplify condition !!
+    if ([_interfaces.NotificationActionType.WITHDRAW, _interfaces.NotificationActionType.CLAIM].includes(candidateNotification.actionType)) {
+      const {
+        actionType,
+        address,
+        metadata,
+        time
+      } = candidateNotification;
+      const candidateMetadata = metadata;
+      const remindTime = (0, _utils.hrsToMillisecond)(remindTimeConfigInHrs[candidateNotification.actionType]);
+      for (const comparedNotification of comparedNotifications) {
+        const specialCase = comparedNotification.actionType === _interfaces.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 ([_interfaces.NotificationActionType.CLAIM_AVAIL_BRIDGE_ON_ETHEREUM, _interfaces.NotificationActionType.CLAIM_AVAIL_BRIDGE_ON_AVAIL].includes(candidateNotification.actionType)) {
+      const {
+        address,
+        metadata,
+        time
+      } = candidateNotification;
+      const candidateMetadata = metadata;
+      const remindTime = (0, _utils.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: _interfaces.NotificationTab.ALL,
+      proxyId
+    }), await (0, _remindNotificationTime.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), _constants.CRON_LISTEN_AVAIL_BRIDGE_CLAIM);
+  }
+  createAvailBridgeClaimNotification() {
+    const addresses = this.keyringService.context.getAllAddresses();
+    const {
+      evm: evmAddresses,
+      substrate: substrateAddresses
+    } = (0, _utils2.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 => {
+      (0, _utils.fetchAllAvailBridgeClaimable)(address, _utils.AvailBridgeSourceChain.ETHEREUM, true).then(async transactions => await this.processWriteAvailBridgeClaim(address, transactions, chainAssetMap[ASSET_TYPE.TEST_SUBSTRATE])).catch(console.error);
+      (0, _utils.fetchAllAvailBridgeClaimable)(address, _utils.AvailBridgeSourceChain.ETHEREUM, false).then(async transactions => await this.processWriteAvailBridgeClaim(address, transactions, chainAssetMap[ASSET_TYPE.MAIN_SUBSTRATE])).catch(console.error);
+    });
+    evmAddresses.forEach(address => {
+      (0, _utils.fetchAllAvailBridgeClaimable)(address, _utils.AvailBridgeSourceChain.AVAIL, true).then(async transactions => await this.processWriteAvailBridgeClaim(address, transactions, chainAssetMap[ASSET_TYPE.TEST_EVM])).catch(console.error);
+      (0, _utils.fetchAllAvailBridgeClaimable)(address, _utils.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 = (0, _keyring.isSubstrateAddress)(address) ? _interfaces.NotificationActionType.CLAIM_AVAIL_BRIDGE_ON_AVAIL : _interfaces.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: _consts.NotificationTitleMap[actionType].replace('{{tokenSymbol}}', symbol),
+        description: _consts.NotificationDescriptionMap[actionType]((0, _utils2.formatNumber)(amount, decimals), symbol),
+        time: timestamp,
+        extrinsicType: _KoniTypes.ExtrinsicType.CLAIM_AVAIL_BRIDGE,
+        isRead: false,
+        actionType,
+        metadata
+      };
+    });
+    await this.validateAndWriteNotificationsToDB(notifications, address);
+  }
+  async start() {
+    if (this.status === _types.ServiceStatus.STARTED) {
+      return;
+    }
+    try {
+      this.status = _types.ServiceStatus.STARTING;
+      await this.startCron();
+      this.status = _types.ServiceStatus.STARTED;
+    } catch (e) {}
+  }
+  async startCron() {
+    this.cleanUpOldNotifications().catch(console.error);
+    this.cronCreateAvailBridgeClaimNotification();
+    return Promise.resolve();
+  }
+  async stop() {
+    try {
+      this.status = _types.ServiceStatus.STOPPING;
+      await this.stopCron();
+      this.status = _types.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);
+  }
+}
+exports.InappNotificationService = InappNotificationService;

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

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.NotificationTimePeriod = exports.NotificationTab = exports.NotificationActionType = void 0;
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+let NotificationTimePeriod;
+exports.NotificationTimePeriod = NotificationTimePeriod;
+(function (NotificationTimePeriod) {
+  NotificationTimePeriod["TODAY"] = "TODAY";
+  NotificationTimePeriod["THIS_WEEK"] = "THIS_WEEK";
+  NotificationTimePeriod["THIS_MONTH"] = "THIS_MONTH";
+})(NotificationTimePeriod || (exports.NotificationTimePeriod = NotificationTimePeriod = {}));
+let NotificationActionType;
+exports.NotificationActionType = 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 || (exports.NotificationActionType = NotificationActionType = {}));
+let NotificationTab;
+exports.NotificationTab = NotificationTab;
+(function (NotificationTab) {
+  NotificationTab["ALL"] = "ALL";
+  NotificationTab["UNREAD"] = "UNREAD";
+  NotificationTab["READ"] = "READ";
+})(NotificationTab || (exports.NotificationTab = NotificationTab = {}));

package/cjs/services/inapp-notification-service/utils.js

@@ -0,0 +1,197 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AvailBridgeTransactionStatus = exports.AvailBridgeSourceChain = exports.AVAIL_BRIDGE_INDEXER = exports.AVAIL_BRIDGE_API = void 0;
+exports.createClaimNotification = createClaimNotification;
+exports.createWithdrawNotifications = createWithdrawNotifications;
+exports.fetchAllAvailBridgeClaimable = fetchAllAvailBridgeClaimable;
+exports.fetchAvailBridgeTransactions = fetchAvailBridgeTransactions;
+exports.filterClaimableOfAddress = filterClaimableOfAddress;
+exports.getAvailBridgeClaimDescription = getAvailBridgeClaimDescription;
+exports.getClaimDescription = getClaimDescription;
+exports.getIsTabRead = getIsTabRead;
+exports.getReceiveDescription = getReceiveDescription;
+exports.getSendDescription = getSendDescription;
+exports.getWithdrawDescription = getWithdrawDescription;
+exports.hrsToMillisecond = hrsToMillisecond;
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+var _consts = require("@subwallet/extension-base/services/inapp-notification-service/consts");
+var _interfaces = require("@subwallet/extension-base/services/inapp-notification-service/interfaces");
+var _types = require("@subwallet/extension-base/types");
+var _utils2 = require("@subwallet/extension-base/utils");
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+/* Description */
+function getWithdrawDescription(amount, symbol, stakingType) {
+  if (stakingType === _types.YieldPoolType.LIQUID_STAKING) {
+    return `${amount} ${symbol} ready to withdraw from ${symbol} liquid staking. Click to withdraw now!`;
+  }
+  return `${amount} ${symbol} ready to withdraw from ${symbol} staking. Click to withdraw now!`;
+}
+function getClaimDescription(amount, symbol) {
+  return `${amount} ${symbol} ready to claim from ${symbol} staking. Click to claim now!`;
+}
+function getSendDescription(amount, symbol) {
+  return `You have just sent ${amount} ${symbol}`;
+}
+function getReceiveDescription(amount, symbol) {
+  return `You have just received ${amount} ${symbol}`;
+}
+function getAvailBridgeClaimDescription(amount, symbol) {
+  return `${amount} ${symbol} ready to claim from ${symbol} cross-chain transfer. Click to claim now!`;
+}
+/* Description */
+
+function getIsTabRead(notificationTab) {
+  if (notificationTab === _interfaces.NotificationTab.UNREAD) {
+    return false;
+  }
+  if (notificationTab === _interfaces.NotificationTab.READ) {
+    return true;
+  }
+  return undefined;
+}
+function createWithdrawNotification(amount, address, symbol, stakingSlug, stakingType) {
+  const actionType = _interfaces.NotificationActionType.WITHDRAW;
+  const extrinsicType = _KoniTypes.ExtrinsicType.STAKING_WITHDRAW;
+  const time = Date.now();
+  return {
+    id: `${actionType}___${stakingSlug}___${time}`,
+    title: _consts.NotificationTitleMap[actionType].replace('{{tokenSymbol}}', symbol),
+    description: _consts.NotificationDescriptionMap[actionType](amount, symbol, stakingType),
+    address,
+    time,
+    extrinsicType,
+    isRead: false,
+    actionType,
+    metadata: {
+      stakingType,
+      stakingSlug
+    }
+  };
+}
+function createWithdrawNotifications(unstakingInfos, tokenInfo, address, stakingSlug, stakingType) {
+  const allWithdrawNotifications = [];
+  for (const unstaking of unstakingInfos) {
+    if (unstaking.status !== _types.UnstakingStatus.CLAIMABLE) {
+      continue;
+    }
+    const rawClaimableAmount = unstaking.claimable;
+    const decimals = (0, _utils._getAssetDecimals)(tokenInfo);
+    const symbol = (0, _utils._getAssetSymbol)(tokenInfo);
+    const amount = (0, _utils2.formatNumber)(rawClaimableAmount, decimals);
+    allWithdrawNotifications.push(createWithdrawNotification(amount, address, symbol, stakingSlug, stakingType));
+  }
+  return allWithdrawNotifications;
+}
+function createClaimNotification(claimItemInfo, tokenInfo) {
+  const {
+    address,
+    slug,
+    type,
+    unclaimedReward = '0'
+  } = claimItemInfo;
+  const decimals = (0, _utils._getAssetDecimals)(tokenInfo);
+  const symbol = (0, _utils._getAssetSymbol)(tokenInfo);
+  const amount = (0, _utils2.formatNumber)(unclaimedReward, decimals);
+  const actionType = _interfaces.NotificationActionType.CLAIM;
+  const extrinsicType = _KoniTypes.ExtrinsicType.STAKING_CLAIM_REWARD;
+  const time = Date.now();
+  return {
+    id: `${actionType}___${slug}___${time}`,
+    title: _consts.NotificationTitleMap[actionType].replace('{{tokenSymbol}}', symbol),
+    description: _consts.NotificationDescriptionMap[actionType](amount, symbol),
+    address,
+    time,
+    extrinsicType,
+    isRead: false,
+    actionType,
+    metadata: {
+      stakingType: type,
+      stakingSlug: slug
+    }
+  };
+}
+
+// todo: can refactor utils and const of avail bridge to a new file. Also check in /transfer/xcm/availBridge.ts file
+
+const AVAIL_BRIDGE_INDEXER = {
+  AVAIL_MAINNET: 'https://bridge-indexer.avail.so',
+  AVAIL_TESTNET: 'https://turing-bridge-indexer.fra.avail.so'
+};
+exports.AVAIL_BRIDGE_INDEXER = AVAIL_BRIDGE_INDEXER;
+const AVAIL_BRIDGE_API = {
+  AVAIL_MAINNET: 'https://bridge-api.avail.so',
+  AVAIL_TESTNET: 'https://turing-bridge-api.fra.avail.so'
+};
+exports.AVAIL_BRIDGE_API = AVAIL_BRIDGE_API;
+let AvailBridgeTransactionStatus;
+exports.AvailBridgeTransactionStatus = AvailBridgeTransactionStatus;
+(function (AvailBridgeTransactionStatus) {
+  AvailBridgeTransactionStatus["READY_TO_CLAIM"] = "READY_TO_CLAIM";
+  AvailBridgeTransactionStatus["CLAIMED"] = "CLAIMED";
+  AvailBridgeTransactionStatus["BRIDGED"] = "BRIDGED";
+})(AvailBridgeTransactionStatus || (exports.AvailBridgeTransactionStatus = AvailBridgeTransactionStatus = {}));
+let AvailBridgeSourceChain;
+exports.AvailBridgeSourceChain = AvailBridgeSourceChain;
+(function (AvailBridgeSourceChain) {
+  AvailBridgeSourceChain["AVAIL"] = "AVAIL";
+  AvailBridgeSourceChain["ETHEREUM"] = "ETHEREUM";
+})(AvailBridgeSourceChain || (exports.AvailBridgeSourceChain = AvailBridgeSourceChain = {}));
+async function fetchAllAvailBridgeClaimable(address, sourceChain, isTestnet) {
+  const transactions = [];
+  let isContinue = true;
+  let page = 0;
+  const pageSize = 100;
+  while (isContinue) {
+    const response = await fetchAvailBridgeTransactions(address, sourceChain, AvailBridgeTransactionStatus.READY_TO_CLAIM, pageSize, page, isTestnet);
+    if (!response) {
+      break;
+    }
+    transactions.push(...filterClaimableOfAddress(address, response.data.result));
+    isContinue = response.data.paginationData.hasNextPage;
+    page = page + 1;
+  }
+  return transactions;
+}
+async function fetchAvailBridgeTransactions(userAddress, sourceChain, status) {
+  let pageSize = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 100;
+  let page = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 0;
+  let isTestnet = arguments.length > 5 ? arguments[5] : undefined;
+  const params = new URLSearchParams({
+    userAddress,
+    sourceChain,
+    status,
+    pageSize: pageSize.toString(),
+    page: page.toString()
+  });
+  try {
+    const api = isTestnet ? AVAIL_BRIDGE_INDEXER.AVAIL_TESTNET : AVAIL_BRIDGE_INDEXER.AVAIL_MAINNET;
+    const rawResponse = await fetch(`${api}/transactions?${params.toString()}`, {
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json',
+        'Access-Control-Allow-Origin': '*'
+      },
+      credentials: 'omit'
+    });
+    if (!rawResponse.ok) {
+      console.error('Error fetching claimable bridge transactions');
+      return undefined;
+    }
+    return await rawResponse.json();
+  } catch (e) {
+    console.error(e);
+    return undefined;
+  }
+}
+function filterClaimableOfAddress(address, transactions) {
+  return transactions.filter(transaction => transaction.receiverAddress.toLowerCase() === address.toLowerCase());
+}
+function hrsToMillisecond(hours) {
+  return hours * 60 * 60 * 1000;
+}

package/cjs/services/keyring-service/context/account-context.js

@@ -61,9 +61,15 @@ class AccountContext {
   isUnifiedAccount(proxyId) {
     return this.state.isUnifiedAccount(proxyId);
   }
+  belongUnifiedAccount(address) {
+    return this.state.belongUnifiedAccount(address);
+  }
   addressesByProxyId(proxyId) {
     return this.state.addressesByProxyId(proxyId);
   }
+  getCurrentAccountProxyName(proxyId) {
+    return this.state.getAccountProxyName(proxyId);
+  }
 
   /* Modify accounts */
 
@@ -104,6 +110,9 @@ class AccountContext {
     let allowGetAllAccount = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
     return this.state.getDecodedAddresses(accountProxy, allowGetAllAccount);
   }
+  getAllAddresses() {
+    return this.state.getAllAddresses();
+  }
 
   /* Get address for another service */
 

package/cjs/services/keyring-service/context/state.js

@@ -274,6 +274,10 @@ class AccountState {
 
   /* Current account */
 
+  getAccountProxyName(proxyId) {
+    return this.accounts[proxyId].name;
+  }
+
   /* Check address exists */
   checkAddressExists(addresses) {
     for (const address of addresses) {

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

@@ -41,9 +41,17 @@ class SettingService {
   }
   getSettings(update) {
     this.settingsStore.get('Settings', value => {
+      var _value$notificationSe, _value$notificationSe2, _value$notificationSe3;
       update({
         ..._constants2.DEFAULT_SETTING,
-        ...(value || {})
+        ...(value || {}),
+        notificationSetup: {
+          isEnabled: (_value$notificationSe = value === null || value === void 0 ? void 0 : (_value$notificationSe2 = value.notificationSetup) === null || _value$notificationSe2 === void 0 ? void 0 : _value$notificationSe2.isEnabled) !== null && _value$notificationSe !== void 0 ? _value$notificationSe : _constants2.DEFAULT_SETTING.notificationSetup.isEnabled,
+          showNotice: {
+            ..._constants2.DEFAULT_SETTING.notificationSetup.showNotice,
+            ...((value === null || value === void 0 ? void 0 : (_value$notificationSe3 = value.notificationSetup) === null || _value$notificationSe3 === void 0 ? void 0 : _value$notificationSe3.showNotice) || {})
+          }
+        }
       });
     });
   }