@subwallet/extension-base 1.3.6-1 → 1.3.8-0

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

@@ -1,13 +1,14 @@
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+import { COMMON_ASSETS, COMMON_CHAIN_SLUGS } from '@subwallet/chain-list';
 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 { AvailBridgeSourceChain, fetchAllAvailBridgeClaimable, fetchPolygonBridgeTransactions, 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 {
@@ -103,6 +104,28 @@ export class InappNotificationService {
         }
       }
     }
+    if ([NotificationActionType.CLAIM_POLYGON_BRIDGE].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._id === comparedMetadata._id && candidateMetadata.transactionHash === comparedMetadata.transactionHash && candidateMetadata.counter === comparedMetadata.counter;
+        if (sameNotification) {
+          return false;
+        }
+      }
+    }
     return true;
   }
   async validateAndWriteNotificationsToDB(notifications, address) {
@@ -124,17 +147,23 @@ export class InappNotificationService {
     }
     await this.dbService.upsertNotifications(passNotifications);
   }
-  cronCreateAvailBridgeClaimNotification() {
+  cronCreateBridgeClaimNotification() {
     clearTimeout(this.refeshAvailBridgeClaimTimeOut);
     this.createAvailBridgeClaimNotification();
-    this.refeshAvailBridgeClaimTimeOut = setTimeout(this.cronCreateAvailBridgeClaimNotification.bind(this), CRON_LISTEN_AVAIL_BRIDGE_CLAIM);
+    this.createPolygonClaimableTransactions().catch(err => {
+      console.error('Error:', err);
+    });
+    this.refeshAvailBridgeClaimTimeOut = setTimeout(this.cronCreateBridgeClaimNotification.bind(this), CRON_LISTEN_AVAIL_BRIDGE_CLAIM);
   }
-  createAvailBridgeClaimNotification() {
+  getCategorizedAddresses() {
     const addresses = this.keyringService.context.getAllAddresses();
+    return categoryAddresses(addresses);
+  }
+  createAvailBridgeClaimNotification() {
     const {
       evm: evmAddresses,
       substrate: substrateAddresses
-    } = categoryAddresses(addresses);
+    } = this.getCategorizedAddresses();
     const chainAssets = this.chainService.getAssetRegistry();
     let ASSET_TYPE;
     (function (ASSET_TYPE) {
@@ -208,7 +237,7 @@ export class InappNotificationService {
         title: NotificationTitleMap[actionType].replace('{{tokenSymbol}}', symbol),
         description: NotificationDescriptionMap[actionType](formatNumber(amount, decimals), symbol),
         time: timestamp,
-        extrinsicType: ExtrinsicType.CLAIM_AVAIL_BRIDGE,
+        extrinsicType: ExtrinsicType.CLAIM_BRIDGE,
         isRead: false,
         actionType,
         metadata
@@ -216,6 +245,81 @@ export class InappNotificationService {
     });
     await this.validateAndWriteNotificationsToDB(notifications, address);
   }
+
+  // Polygon Claimable Handle
+  async createPolygonClaimableTransactions() {
+    const {
+      evm: evmAddresses
+    } = this.getCategorizedAddresses();
+    const etherChains = [COMMON_ASSETS.ETH, COMMON_ASSETS.ETH_SEPOLIA];
+    const polygonAssets = Object.values(this.chainService.getAssetRegistry()).filter(asset => etherChains.includes(asset.slug));
+    for (const polygonAsset of polygonAssets) {
+      const isTestnet = (polygonAsset === null || polygonAsset === void 0 ? void 0 : polygonAsset.originChain) === COMMON_CHAIN_SLUGS.ETHEREUM_SEPOLIA;
+      if (evmAddresses.length === 0) {
+        return;
+      }
+      for (const address of evmAddresses) {
+        const response = await fetchPolygonBridgeTransactions(address, isTestnet);
+        if (response && response.success) {
+          await this.processPolygonClaimNotification(address, response.result, polygonAsset);
+        }
+      }
+    }
+  }
+  async processPolygonClaimNotification(address, transactions, token) {
+    var _token$decimals2;
+    const actionType = NotificationActionType.CLAIM_POLYGON_BRIDGE;
+    const timestamp = Date.now();
+    const symbol = token.symbol;
+    const decimals = (_token$decimals2 = token.decimals) !== null && _token$decimals2 !== void 0 ? _token$decimals2 : 0;
+    const notifications = transactions.map(transaction => {
+      const {
+        _id,
+        amounts,
+        counter,
+        destinationNetwork,
+        originTokenAddress,
+        originTokenNetwork,
+        receiver,
+        sourceNetwork,
+        status,
+        transactionHash,
+        transactionInitiator,
+        userAddress
+      } = transaction;
+      const metadata = {
+        chainSlug: token.originChain,
+        tokenSlug: token.slug,
+        _id,
+        amounts,
+        counter,
+        destinationNetwork,
+        originTokenAddress,
+        originTokenNetwork,
+        receiver,
+        sourceNetwork,
+        status,
+        transactionHash,
+        transactionInitiator,
+        userAddress
+      };
+      return {
+        id: `${actionType}___${_id}___${timestamp}`,
+        address: address,
+        title: NotificationTitleMap[actionType].replace('{{tokenSymbol}}', symbol),
+        description: NotificationDescriptionMap[actionType](formatNumber(amounts[0], decimals), symbol),
+        time: timestamp,
+        extrinsicType: ExtrinsicType.CLAIM_BRIDGE,
+        isRead: false,
+        actionType,
+        metadata
+      };
+    });
+    await this.validateAndWriteNotificationsToDB(notifications, address);
+  }
+
+  // Polygon Claimable Handle
+
   async start() {
     if (this.status === ServiceStatus.STARTED) {
       return;
@@ -228,7 +332,7 @@ export class InappNotificationService {
   }
   async startCron() {
     this.cleanUpOldNotifications().catch(console.error);
-    this.cronCreateAvailBridgeClaimNotification();
+    this.cronCreateBridgeClaimNotification();
     return Promise.resolve();
   }
   async stop() {

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

@@ -1,5 +1,5 @@
 import { ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
-import { AvailBridgeSourceChain, AvailBridgeTransactionStatus } from '@subwallet/extension-base/services/inapp-notification-service/utils';
+import { AvailBridgeSourceChain } from '@subwallet/extension-base/services/inapp-notification-service/utils';
 import { YieldPoolType } from '@subwallet/extension-base/types';
 export interface _BaseNotificationInfo {
     id: string;
@@ -15,6 +15,11 @@ export interface _BaseNotificationInfo {
 export interface _NotificationInfo extends _BaseNotificationInfo {
     proxyId: string;
 }
+export declare enum BridgeTransactionStatus {
+    READY_TO_CLAIM = "READY_TO_CLAIM",
+    CLAIMED = "CLAIMED",
+    BRIDGED = "BRIDGED"
+}
 export interface ActionTypeToMetadataMap {
     [NotificationActionType.SEND]: SendReceiveNotificationMetadata;
     [NotificationActionType.RECEIVE]: SendReceiveNotificationMetadata;
@@ -22,6 +27,7 @@ export interface ActionTypeToMetadataMap {
     [NotificationActionType.CLAIM]: WithdrawClaimNotificationMetadata;
     [NotificationActionType.CLAIM_AVAIL_BRIDGE_ON_AVAIL]: ClaimAvailBridgeNotificationMetadata;
     [NotificationActionType.CLAIM_AVAIL_BRIDGE_ON_ETHEREUM]: ClaimAvailBridgeNotificationMetadata;
+    [NotificationActionType.CLAIM_POLYGON_BRIDGE]: ClaimPolygonBridgeNotificationMetadata;
 }
 export interface SendReceiveNotificationMetadata {
     chain: string;
@@ -46,7 +52,23 @@ export interface ClaimAvailBridgeNotificationMetadata {
     amount: string;
     sourceBlockHash: string;
     sourceTransactionIndex: string;
-    status: AvailBridgeTransactionStatus;
+    status: BridgeTransactionStatus;
+}
+export interface ClaimPolygonBridgeNotificationMetadata {
+    chainSlug: string;
+    tokenSlug: string;
+    _id: string;
+    amounts: string[];
+    counter: number;
+    destinationNetwork: number;
+    originTokenAddress: string;
+    originTokenNetwork: number;
+    receiver: string;
+    sourceNetwork: number;
+    status: BridgeTransactionStatus;
+    transactionHash: string;
+    transactionInitiator: string;
+    userAddress: string;
 }
 export declare enum NotificationTimePeriod {
     TODAY = "TODAY",
@@ -59,7 +81,8 @@ export declare enum NotificationActionType {
     WITHDRAW = "WITHDRAW",
     CLAIM = "CLAIM",
     CLAIM_AVAIL_BRIDGE_ON_AVAIL = "CLAIM_AVAIL_BRIDGE_ON_AVAIL",
-    CLAIM_AVAIL_BRIDGE_ON_ETHEREUM = "CLAIM_AVAIL_BRIDGE_ON_ETHEREUM"
+    CLAIM_AVAIL_BRIDGE_ON_ETHEREUM = "CLAIM_AVAIL_BRIDGE_ON_ETHEREUM",
+    CLAIM_POLYGON_BRIDGE = "CLAIM_POLYGON_BRIDGE"
 }
 export declare enum NotificationTab {
     ALL = "ALL",
@@ -70,6 +93,7 @@ export interface ShowNotificationPayload {
     earningClaim: boolean;
     earningWithdraw: boolean;
     availBridgeClaim: boolean;
+    polygonBridgeClaim: boolean;
 }
 export interface NotificationSetup {
     isEnabled: boolean;

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

@@ -1,6 +1,12 @@
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+export let BridgeTransactionStatus;
+(function (BridgeTransactionStatus) {
+  BridgeTransactionStatus["READY_TO_CLAIM"] = "READY_TO_CLAIM";
+  BridgeTransactionStatus["CLAIMED"] = "CLAIMED";
+  BridgeTransactionStatus["BRIDGED"] = "BRIDGED";
+})(BridgeTransactionStatus || (BridgeTransactionStatus = {}));
 export let NotificationTimePeriod;
 (function (NotificationTimePeriod) {
   NotificationTimePeriod["TODAY"] = "TODAY";
@@ -15,6 +21,7 @@ export let NotificationActionType;
   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["CLAIM_POLYGON_BRIDGE"] = "CLAIM_POLYGON_BRIDGE";
 })(NotificationActionType || (NotificationActionType = {}));
 export let NotificationTab;
 (function (NotificationTab) {

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

@@ -0,0 +1,40 @@
+import { BridgeTransactionStatus } from '../interfaces';
+export declare function getAvailBridgeClaimDescription(amount: string, symbol: string): string;
+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: BridgeTransactionStatus;
+}
+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: BridgeTransactionStatus, pageSize: number | undefined, page: number | undefined, isTestnet: boolean): Promise<AvailBridgeTransactionsResponse | undefined>;
+export declare function filterClaimableOfAddress(address: string, transactions: AvailBridgeTransaction[]): AvailBridgeTransaction[];
+export {};

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

@@ -0,0 +1,73 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { BridgeTransactionStatus } from "../interfaces.js";
+
+/* Description */
+export function getAvailBridgeClaimDescription(amount, symbol) {
+  return `${amount} ${symbol} ready to claim from ${symbol} cross-chain transfer. Click to claim now!`;
+}
+/* Description */
+
+// todo: can refactor utils and const of avail bridge to a new file. Also check in /transfer/xcm/availBridge.ts file
+
+export const AVAIL_BRIDGE_INDEXER = {
+  AVAIL_MAINNET: 'https://bridge-indexer.avail.so',
+  AVAIL_TESTNET: 'https://turing-bridge-indexer.fra.avail.so'
+};
+export const AVAIL_BRIDGE_API = {
+  AVAIL_MAINNET: 'https://bridge-api.avail.so',
+  AVAIL_TESTNET: 'https://turing-bridge-api.fra.avail.so'
+};
+export let AvailBridgeSourceChain;
+(function (AvailBridgeSourceChain) {
+  AvailBridgeSourceChain["AVAIL"] = "AVAIL";
+  AvailBridgeSourceChain["ETHEREUM"] = "ETHEREUM";
+})(AvailBridgeSourceChain || (AvailBridgeSourceChain = {}));
+export 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, BridgeTransactionStatus.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;
+}
+export async function fetchAvailBridgeTransactions(userAddress, sourceChain, status, pageSize = 100, page = 0, isTestnet) {
+  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;
+  }
+}
+export function filterClaimableOfAddress(address, transactions) {
+  return transactions.filter(transaction => transaction.receiverAddress.toLowerCase() === address.toLowerCase());
+}

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

@@ -0,0 +1,11 @@
+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 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 function hrsToMillisecond(hours: number): number;

package/services/inapp-notification-service/{utils.js → utils/common.js}

@@ -24,9 +24,7 @@ export function getSendDescription(amount, symbol) {
 export function getReceiveDescription(amount, symbol) {
   return `You have just received ${amount} ${symbol}`;
 }
-export function getAvailBridgeClaimDescription(amount, symbol) {
-  return `${amount} ${symbol} ready to claim from ${symbol} cross-chain transfer. Click to claim now!`;
-}
+
 /* Description */
 
 export function getIsTabRead(notificationTab) {
@@ -99,75 +97,6 @@ export function createClaimNotification(claimItemInfo, tokenInfo) {
     }
   };
 }
-
-// todo: can refactor utils and const of avail bridge to a new file. Also check in /transfer/xcm/availBridge.ts file
-
-export const AVAIL_BRIDGE_INDEXER = {
-  AVAIL_MAINNET: 'https://bridge-indexer.avail.so',
-  AVAIL_TESTNET: 'https://turing-bridge-indexer.fra.avail.so'
-};
-export const AVAIL_BRIDGE_API = {
-  AVAIL_MAINNET: 'https://bridge-api.avail.so',
-  AVAIL_TESTNET: 'https://turing-bridge-api.fra.avail.so'
-};
-export let AvailBridgeTransactionStatus;
-(function (AvailBridgeTransactionStatus) {
-  AvailBridgeTransactionStatus["READY_TO_CLAIM"] = "READY_TO_CLAIM";
-  AvailBridgeTransactionStatus["CLAIMED"] = "CLAIMED";
-  AvailBridgeTransactionStatus["BRIDGED"] = "BRIDGED";
-})(AvailBridgeTransactionStatus || (AvailBridgeTransactionStatus = {}));
-export let AvailBridgeSourceChain;
-(function (AvailBridgeSourceChain) {
-  AvailBridgeSourceChain["AVAIL"] = "AVAIL";
-  AvailBridgeSourceChain["ETHEREUM"] = "ETHEREUM";
-})(AvailBridgeSourceChain || (AvailBridgeSourceChain = {}));
-export 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;
-}
-export async function fetchAvailBridgeTransactions(userAddress, sourceChain, status, pageSize = 100, page = 0, isTestnet) {
-  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;
-  }
-}
-export function filterClaimableOfAddress(address, transactions) {
-  return transactions.filter(transaction => transaction.receiverAddress.toLowerCase() === address.toLowerCase());
-}
 export function hrsToMillisecond(hours) {
   return hours * 60 * 60 * 1000;
 }

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

@@ -0,0 +1,3 @@
+export * from './avail';
+export * from './common';
+export * from './polygon';

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

@@ -0,0 +1,6 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export * from "./avail.js";
+export * from "./common.js";
+export * from "./polygon.js";

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

@@ -0,0 +1,71 @@
+import { BridgeTransactionStatus } from '../interfaces';
+export declare const POLYGON_BRIDGE_INDEXER: {
+    MAINNET: string;
+    TESTNET: string;
+};
+export interface PolygonTransaction {
+    _id: string;
+    transactionIndex?: number;
+    sourceNetwork: number;
+    destinationNetwork: number;
+    blockNumber: number;
+    amounts: string[];
+    bridgeType: string;
+    dataType: string;
+    isDecoded?: boolean;
+    status: BridgeTransactionStatus;
+    timestamp: string;
+    tokenIds: any[];
+    transactionHash: string;
+    userAddress: string;
+    wrappedTokenAddress?: string;
+    wrappedTokenNetwork?: number;
+    counter: number;
+    bridgeContractAddress?: string;
+    eventInitiatorAddress?: string;
+    globalExitRootManager?: string;
+    leaf?: string;
+    mainnetExitRoot?: string;
+    metadata?: string;
+    originTokenAddress: string;
+    originTokenNetwork: number;
+    receiver: string;
+    refuel: boolean;
+    rollUpExitRoot?: string;
+    nonce?: any;
+    rootTunnelAddress?: string;
+    claimContractAddress?: string;
+    claimTransactionBlockNumber?: number;
+    claimTransactionHash?: string;
+    claimTransactionTimestamp?: string;
+    transactionInitiator: string;
+}
+interface PaginationData {
+    hasNextPage: boolean;
+    page: number;
+    pageSize: number;
+    totalCount: number;
+}
+interface LastCheckpoint {
+    _id: string;
+    proposer: string;
+    checkpointNumber: number;
+    reward: number;
+    start: number;
+    end: number;
+    root: string;
+    transactionHash: string;
+    timestamp: number;
+    __v: number;
+}
+interface PolygonTransactionResponse {
+    success: boolean;
+    result: PolygonTransaction[];
+    paginationData: PaginationData;
+    posWithdrawInterval: number;
+    lastCheckpoint: LastCheckpoint;
+}
+export declare function getPolygonBridgeClaimDescription(amount: string, symbol: string): string;
+export declare function fetchPolygonBridgeTransactions(userAddress: string, isTestnet: boolean, pageSize?: number, page?: number): Promise<PolygonTransactionResponse | undefined>;
+export declare function fetchAndFilterPolygonTransactionById(transactionId: string, userAddress: string, isTestnet: boolean): Promise<PolygonTransaction | undefined>;
+export {};

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

@@ -0,0 +1,54 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { BridgeTransactionStatus } from "../interfaces.js";
+export const POLYGON_BRIDGE_INDEXER = {
+  MAINNET: 'https://api-gateway.polygon.technology/api/v3/transactions/mainnet',
+  TESTNET: 'https://api-gateway.polygon.technology/api/v3/transactions/testnet'
+};
+/* Description */
+export function getPolygonBridgeClaimDescription(amount, symbol) {
+  return `${amount} ${symbol} ready to claim from ${symbol} cross-chain transfer. Click to claim now!`;
+}
+/* Description */
+
+export async function fetchPolygonBridgeTransactions(userAddress, isTestnet, pageSize = 500, page = 0) {
+  const params = new URLSearchParams({
+    userAddress,
+    pageSize: pageSize.toString(),
+    page: page.toString()
+  });
+  const networkIds = [0, 1];
+  networkIds.forEach(networkId => {
+    params.append('destinationNetworkIds', networkId.toString());
+    params.append('sourceNetworkIds', networkId.toString());
+    params.append('status', BridgeTransactionStatus.READY_TO_CLAIM);
+  });
+  try {
+    const domain = isTestnet ? POLYGON_BRIDGE_INDEXER.TESTNET : POLYGON_BRIDGE_INDEXER.MAINNET;
+    const rawResponse = await fetch(`${domain}?${params.toString()}`, {
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json',
+        'Access-Control-Allow-Origin': '*',
+        'x-api-key': 'polygonag_4RFN-g_wt2o12GmK9WWOWrGf-4Hamhtd'
+      },
+      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;
+  }
+}
+export async function fetchAndFilterPolygonTransactionById(transactionId, userAddress, isTestnet) {
+  const response = await fetchPolygonBridgeTransactions(userAddress, isTestnet);
+  if (!response || !response.success) {
+    return undefined;
+  }
+  return response.result.find(tx => tx._id === transactionId);
+}

package/services/migration-service/scripts/MigrateTransactionHistoryBridge.d.ts

@@ -0,0 +1,4 @@
+import BaseMigrationJob from '@subwallet/extension-base/services/migration-service/Base';
+export default class MigrateTransactionHistoryBridge extends BaseMigrationJob {
+    run(): Promise<void>;
+}

package/services/migration-service/scripts/MigrateTransactionHistoryBridge.js

@@ -0,0 +1,29 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import BaseMigrationJob from '@subwallet/extension-base/services/migration-service/Base';
+import Dexie from 'dexie';
+export default class MigrateTransactionHistoryBridge extends BaseMigrationJob {
+  async run() {
+    const state = this.state;
+    const newTransactionItems = [];
+    try {
+      const db = new Dexie('SubWalletDB_v2');
+      const dexieDB = await db.open();
+      const transactionTable = dexieDB.table('transactions');
+      const oldTransactionData = await transactionTable.toArray();
+      const claimAvailBridgeTransactions = oldTransactionData.filter(item => item.type === 'claim.claim_avail_bridge');
+      claimAvailBridgeTransactions.forEach(item => {
+        const newItem = {
+          ...item,
+          type: ExtrinsicType.CLAIM_BRIDGE
+        };
+        newTransactionItems.push(newItem);
+      });
+      await state.dbService.upsertHistory(newTransactionItems);
+    } catch (e) {
+      this.logger.error(e);
+    }
+  }
+}

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

@@ -27,6 +27,7 @@ import MigrateNetworkSettings from "./MigrateNetworkSettings.js";
 import MigrateSettings from "./MigrateSettings.js";
 import MigrateTokenDecimals from "./MigrateTokenDecimals.js";
 import MigrateTransactionHistory from "./MigrateTransactionHistory.js";
+import MigrateTransactionHistoryBridge from "./MigrateTransactionHistoryBridge.js";
 import MigrateTransactionHistoryBySymbol from "./MigrateTransactionHistoryBySymbol.js";
 import MigrateWalletReference from "./MigrateWalletReference.js";
 export const EVERYTIME = '__everytime__';
@@ -59,7 +60,8 @@ export default {
   '1.2.69-01': MigrateRemoveGenesisHash,
   '1.2.13-01': ReloadMetadata,
   '1.2.14-01': ClearMetadataDatabase,
-  '1.2.32-01': MigratePairData
+  '1.2.32-01': MigratePairData,
+  '1.3.6-01': MigrateTransactionHistoryBridge
   // [`${EVERYTIME}-1.1.42-02`]: MigrateTransactionHistoryBySymbol
   // [`${EVERYTIME}-1`]: AutoEnableChainsTokens
 };