Add Priority Config to the xcm metrics (#32)

TarikGul · web-flow · commit 8465175dbe52 · 2025-10-05T15:46:43.000-04:00
* Add Priority Config to the xcm metrics

* update event
diff --git a/backend/src/routes/updates.ts b/backend/src/routes/updates.ts
@@ -26,7 +26,9 @@ type EventType =
   | 'dmpMessageCounter'
   | 'umpMessageCounter'
   | 'dmpQueueEvent'
-  | 'umpQueueEvent';
+  | 'umpQueueEvent'
+  | 'dmpQueuePriority'
+  | 'umpQueuePriority';
 
 export const updatesHandler: RequestHandler = async (req: Request, res: Response) => {
   const requestedEvents = ((req.query.events as string) || '')
diff --git a/backend/src/services/BlockProcessor.ts b/backend/src/services/BlockProcessor.ts
@@ -1,4 +1,4 @@
-import type { PalletRcMigratorMigrationStage } from '../types/pjs';
+import type { PalletRcMigratorMigrationStage, PalletRcMigratorQueuePriority } from '../types/pjs';
 import type { ApiDecoration } from '@polkadot/api/types';
 import type { Vec, Bytes } from '@polkadot/types';
 import type { Event } from '@polkadot/types/interfaces';
@@ -51,6 +51,8 @@ export class BlockProcessor {
   private previousDmpQueueSize: number = 0;
   private currentMode: ProcessingMode = ProcessingMode.DETECTION;
   private migrationStartBlockNumber?: number;
+  private rcPriorityConfigQueried: boolean = false;
+  private ahPriorityConfigQueried: boolean = false;
 
   private constructor() {
     // Initialize queues for both chains
@@ -62,6 +64,8 @@ export class BlockProcessor {
     this.lastBlockNumber.set('relay-chain', 0);
     this.lastBlockNumber.set('asset-hub', 0);
     this.currentMode = ProcessingMode.DETECTION;
+    this.rcPriorityConfigQueried = false;
+    this.ahPriorityConfigQueried = false;
   }
 
   /**
@@ -429,6 +433,11 @@ export class BlockProcessor {
         if (event.section === 'parachainSystem' && event.method === 'UpwardMessageSent') {
           await this.handleAssetHubUpwardMessageSent(event, item);
         }
+
+        // Handle ahMigrator.DmpQueuePrioritySet event
+        if (event.section === 'ahMigrator' && event.method === 'DmpQueuePriorityConfigSet') {
+          await this.handleDmpQueuePriorityChangedEvent(event, apiAt, item);
+        }
       }
 
       // Emit pallet migration events after processing all events in this block
@@ -473,6 +482,11 @@ export class BlockProcessor {
         if (event.section === 'messageQueue' && event.method === 'Processed') {
           await this.handleRelayChainMessageQueueProcessed(event, item);
         }
+
+        // Handle rcMigrator.AhUmpQueuePriorityConfigSet event
+        if (event.section === 'rcMigrator' && event.method === 'AhUmpQueuePriorityConfigSet') {
+          await this.handleUmpQueuePriorityChangedEvent(event, apiAt, item);
+        }
       }
     } catch (error) {
       Log.service({
@@ -640,7 +654,7 @@ export class BlockProcessor {
    * Relay Chain event handlers
    */
   private async handleRelayChainMessageQueueProcessed(
-    event: Event,
+    _: Event,
     item: QueueItem
   ): Promise<void> {
     try {
@@ -686,11 +700,23 @@ export class BlockProcessor {
     item: QueueItem
   ): Promise<void> {
     try {
-      const [pendingUpwardMessages] = await Promise.all([
-        apiAt.query.parachainSystem.pendingUpwardMessages<Vec<Bytes>>(),
-      ]);
+      // Query priority config only once on first full mode block
+      if (!this.ahPriorityConfigQueried) {
+        const [pendingUpwardMessages, dmpQueuePriority] = await Promise.all([
+          apiAt.query.parachainSystem.pendingUpwardMessages<Vec<Bytes>>(),
+          apiAt.query.ahMigrator.dmpQueuePriorityConfig<PalletRcMigratorQueuePriority>(),
+        ]);
+
+        await this.handleAhPendingUpwardMessages(pendingUpwardMessages, item);
+        await this.handleDmpQueuePriority(dmpQueuePriority, item);
+        this.ahPriorityConfigQueried = true;
+      } else {
+        const [pendingUpwardMessages] = await Promise.all([
+          apiAt.query.parachainSystem.pendingUpwardMessages<Vec<Bytes>>(),
+        ]);
 
-      await this.handleAhPendingUpwardMessages(pendingUpwardMessages, item);
+        await this.handleAhPendingUpwardMessages(pendingUpwardMessages, item);
+      }
       // TODO: Query Asset Hub specific storage:
       // - ahMigrator.ahMigrationStage (Do we actually need this?)
 
@@ -717,16 +743,32 @@ export class BlockProcessor {
     item: QueueItem
   ): Promise<void> {
     try {
-      const [migrationStage, dmpMessageQueue] = await Promise.all([
-        apiAt.query.rcMigrator.rcMigrationStage<PalletRcMigratorMigrationStage>(),
-        apiAt.query.dmp.downwardMessageQueues<Vec<PolkadotCorePrimitivesInboundDownwardMessage>>(
-          1000
-        ),
-      ]);
-
-      // TODO: Is there specific ordering to this or can we put it in a Promise.all?
-      await this.handleRcMigrationStage(migrationStage, item);
-      await this.handleRcDownwardMessageQueues(dmpMessageQueue, item);
+      // Query priority config only once on first full mode block
+      if (!this.rcPriorityConfigQueried) {
+        const [migrationStage, dmpMessageQueue, umpQueuePriority] = await Promise.all([
+          apiAt.query.rcMigrator.rcMigrationStage<PalletRcMigratorMigrationStage>(),
+          apiAt.query.dmp.downwardMessageQueues<Vec<PolkadotCorePrimitivesInboundDownwardMessage>>(
+            1000
+          ),
+          apiAt.query.rcMigrator.ahUmpQueuePriorityConfig<PalletRcMigratorQueuePriority>(),
+        ]);
+
+        await this.handleRcMigrationStage(migrationStage, item);
+        await this.handleRcDownwardMessageQueues(dmpMessageQueue, item);
+        await this.handleUmpQueuePriority(umpQueuePriority, item);
+
+        this.rcPriorityConfigQueried = true;
+      } else {
+        const [migrationStage, dmpMessageQueue] = await Promise.all([
+          apiAt.query.rcMigrator.rcMigrationStage<PalletRcMigratorMigrationStage>(),
+          apiAt.query.dmp.downwardMessageQueues<Vec<PolkadotCorePrimitivesInboundDownwardMessage>>(
+            1000
+          ),
+        ]);
+
+        await this.handleRcMigrationStage(migrationStage, item);
+        await this.handleRcDownwardMessageQueues(dmpMessageQueue, item);
+      }
 
       Log.service({
         service: 'Block Processor',
@@ -927,6 +969,104 @@ export class BlockProcessor {
     }
   }
 
+  private async handleUmpQueuePriority(
+    queuePriority: PalletRcMigratorQueuePriority,
+    item: QueueItem
+  ): Promise<void> {
+    try {
+      const priorityType = queuePriority.type;
+
+      eventService.emit('umpQueuePriority', {
+        type: priorityType,
+        timestamp: new Date(item.timestamp!).toISOString(),
+      });
+
+      Log.service({
+        service: 'UMP Queue Priority',
+        action: 'UMP queue priority config retrieved',
+        details: { type: priorityType },
+      });
+    } catch (error) {
+      Log.service({
+        service: 'UMP Queue Priority',
+        action: 'Error processing UMP queue priority',
+        error: error as Error,
+      });
+    }
+  }
+
+  private async handleDmpQueuePriority(
+    queuePriority: any,
+    item: QueueItem
+  ): Promise<void> {
+    try {
+      const priorityType = queuePriority.type;
+
+      eventService.emit('dmpQueuePriority', {
+        type: priorityType,
+        timestamp: new Date(item.timestamp!).toISOString(),
+      });
+
+      Log.service({
+        service: 'DMP Queue Priority',
+        action: 'DMP queue priority config retrieved',
+        details: { type: priorityType },
+      });
+    } catch (error) {
+      Log.service({
+        service: 'DMP Queue Priority',
+        action: 'Error processing DMP queue priority',
+        error: error as Error,
+      });
+    }
+  }
+
+  private async handleUmpQueuePriorityChangedEvent(
+    _: Event,
+    apiAt: ApiDecoration<'promise'>,
+    item: QueueItem
+  ): Promise<void> {
+    try {
+      Log.service({
+        service: 'UMP Queue Priority',
+        action: 'AhUmpQueuePrioritySet event detected - re-querying config',
+        details: { blockNumber: item.blockNumber },
+      });
+
+      const umpQueuePriority = await apiAt.query.rcMigrator.ahUmpQueuePriorityConfig<PalletRcMigratorQueuePriority>();
+      await this.handleUmpQueuePriority(umpQueuePriority, item);
+    } catch (error) {
+      Log.service({
+        service: 'UMP Queue Priority',
+        action: 'Error handling UMP priority change event',
+        error: error as Error,
+      });
+    }
+  }
+
+  private async handleDmpQueuePriorityChangedEvent(
+    _: Event,
+    apiAt: ApiDecoration<'promise'>,
+    item: QueueItem
+  ): Promise<void> {
+    try {
+      Log.service({
+        service: 'DMP Queue Priority',
+        action: 'DmpQueuePrioritySet event detected - re-querying config',
+        details: { blockNumber: item.blockNumber },
+      });
+
+      const dmpQueuePriority = await apiAt.query.ahMigrator.dmpQueuePriorityConfig();
+      await this.handleDmpQueuePriority(dmpQueuePriority, item);
+    } catch (error) {
+      Log.service({
+        service: 'DMP Queue Priority',
+        action: 'Error handling DMP priority change event',
+        error: error as Error,
+      });
+    }
+  }
+
   /**
    * Lightweight detection mode - only looks for migration scheduling events on Relay Chain
    */
diff --git a/backend/src/types/pjs.ts b/backend/src/types/pjs.ts
@@ -29,6 +29,15 @@ interface PalletRcMigratorCall extends Enum {
     | 'UpdateAhMsgProcessedCount';
 }
 
+  /** @name PalletRcMigratorQueuePriority (552) */
+  export interface PalletRcMigratorQueuePriority extends Enum {
+    readonly isConfig: boolean;
+    readonly isOverrideConfig: boolean;
+    readonly asOverrideConfig: ITuple<[u32, u32]>;
+    readonly isDisabled: boolean;
+    readonly type: 'Config' | 'OverrideConfig' | 'Disabled';
+  }
+
 /** @name PalletRcMigratorMigrationStage (503) */
  export interface PalletRcMigratorMigrationStage extends Enum {
     readonly isPending: boolean;
diff --git a/frontend/src/components/XcmMessageMetrics.css b/frontend/src/components/XcmMessageMetrics.css
@@ -95,16 +95,28 @@
   font-weight: 600;
 }
 
-.priority-enabled {
-  background: #d4edda;
-  color: #155724;
-  border: 1px solid #c3e6cb;
+.priority-default {
+  background: rgba(52, 211, 153, 0.15);
+  color: #10b981;
+  border: 1px solid rgba(52, 211, 153, 0.3);
+}
+
+.priority-override {
+  background: rgba(251, 191, 36, 0.15);
+  color: #f59e0b;
+  border: 1px solid rgba(251, 191, 36, 0.3);
 }
 
 .priority-disabled {
-  background: #f8d7da;
-  color: #721c24;
-  border: 1px solid #f5c6cb;
+  background: rgba(239, 68, 68, 0.15);
+  color: #ef4444;
+  border: 1px solid rgba(239, 68, 68, 0.3);
+}
+
+.priority-unknown {
+  background: rgba(156, 163, 175, 0.15);
+  color: #9ca3af;
+  border: 1px solid rgba(156, 163, 175, 0.3);
 }
 
 .xcm-divider {
diff --git a/frontend/src/components/XcmMessageMetrics.tsx b/frontend/src/components/XcmMessageMetrics.tsx
@@ -18,11 +18,18 @@ interface QueueEvent {
   timestamp: string;
 }
 
+interface PriorityConfig {
+  type: string;
+  timestamp: string;
+}
+
 const XcmMessageMetrics: React.FC = () => {
   const [dmpCounter, setDmpCounter] = useState<XcmCounter | null>(null);
   const [umpCounter, setUmpCounter] = useState<XcmCounter | null>(null);
   const [dmpQueueEvent, setDmpQueueEvent] = useState<QueueEvent | null>(null);
   const [umpQueueEvent, setUmpQueueEvent] = useState<QueueEvent | null>(null);
+  const [dmpPriority, setDmpPriority] = useState<PriorityConfig | null>(null);
+  const [umpPriority, setUmpPriority] = useState<PriorityConfig | null>(null);
 
   // Subscribe to DMP message counter events (Relay → Asset Hub)
   useEventSource(['dmpMessageCounter'], useCallback((eventType: EventType, data: XcmCounter) => {
@@ -52,6 +59,20 @@ const XcmMessageMetrics: React.FC = () => {
     }
   }, []));
 
+  // Subscribe to DMP queue priority events
+  useEventSource(['dmpQueuePriority'], useCallback((eventType: EventType, data: PriorityConfig) => {
+    if (eventType === 'dmpQueuePriority') {
+      setDmpPriority(data);
+    }
+  }, []));
+
+  // Subscribe to UMP queue priority events
+  useEventSource(['umpQueuePriority'], useCallback((eventType: EventType, data: PriorityConfig) => {
+    if (eventType === 'umpQueuePriority') {
+      setUmpPriority(data);
+    }
+  }, []));
+
   // Format bytes for display
   const formatBytes = (bytes: number): string => {
     if (bytes === 0) return '0 KB';
@@ -66,6 +87,27 @@ const XcmMessageMetrics: React.FC = () => {
     return `${size.toLocaleString()} messages`;
   };
 
+  // Format priority display
+  const formatPriority = (config: PriorityConfig | null) => {
+    if (!config) {
+      return { text: 'Loading...', className: 'priority-unknown' };
+    }
+
+    switch (config.type) {
+      case 'Config':
+        return { text: 'Default Config', className: 'priority-default' };
+      case 'OverrideConfig':
+        return { text: 'Override', className: 'priority-override' };
+      case 'Disabled':
+        return { text: 'Disabled', className: 'priority-disabled' };
+      default:
+        return { text: config.type, className: 'priority-unknown' };
+    }
+  };
+
+  const dmpPriorityDisplay = formatPriority(dmpPriority);
+  const umpPriorityDisplay = formatPriority(umpPriority);
+
   return (
     <section className="card xcm-metrics">
       <div className="card-header">
@@ -105,7 +147,9 @@ const XcmMessageMetrics: React.FC = () => {
             <div className="xcm-metric">
               <div className="xcm-metric-label">Priority</div>
               <div className="xcm-metric-value xcm-metric-priority">
-                <span className="priority-badge priority-enabled">Enabled ✓</span>
+                <span className={`priority-badge ${dmpPriorityDisplay.className}`}>
+                  {dmpPriorityDisplay.text}
+                </span>
               </div>
             </div>
           </div>
@@ -145,7 +189,9 @@ const XcmMessageMetrics: React.FC = () => {
             <div className="xcm-metric">
               <div className="xcm-metric-label">Priority</div>
               <div className="xcm-metric-value xcm-metric-priority">
-                <span className="priority-badge priority-enabled">Enabled ✓</span>
+                <span className={`priority-badge ${umpPriorityDisplay.className}`}>
+                  {umpPriorityDisplay.text}
+                </span>
               </div>
             </div>
           </div>
diff --git a/frontend/src/hooks/useEventSource.tsx b/frontend/src/hooks/useEventSource.tsx
