[wip] feat: add monitor overflow to develop branch

app/DTO/Slot.php

@@ -23,7 +23,8 @@ public function __construct(
         private array $lastBlock,
         private string $status,
         private Collection $roundBlockCount,
-        private int $roundNumber
+        private int $roundNumber,
+        private int $secondsUntilForge,
     ) {
         $this->currentRoundBlocks = $this->roundBlockCount
             ->get($this->publicKey, 0);
@@ -49,6 +50,11 @@ public function forgingAt(): Carbon
         return $this->forgingAt;
     }
 
+    public function secondsUntilForge(): int
+    {
+        return $this->secondsUntilForge;
+    }
+
     public function lastBlock(): array
     {
         return $this->lastBlock;
@@ -96,6 +102,16 @@ public function missedCount(): int
         return (new WalletCache())->getMissedBlocks($this->publicKey);
     }
 
+    /**
+     * Get how many blocks the forger has forged in the current round.
+     *
+     * @return int
+     */
+    public function currentRoundBlocks(): int
+    {
+        return $this->currentRoundBlocks;
+    }
+
     public function isDone(): bool
     {
         return $this->status === 'done';
@@ -129,6 +145,45 @@ public function isWaiting(): bool
         return false;
     }
 
+    /**
+     * Clone the slot with the given overridden properties.
+     *
+     * @param string|null $publicKey
+     * @param int|null $order
+     * @param WalletViewModel|null $wallet
+     * @param Carbon|null $forgingAt
+     * @param array|null $lastBlock
+     * @param string|null $status
+     * @param Collection|null $roundBlockCount
+     * @param int|null $roundNumber
+     * @param int|null $secondsUntilForge
+     *
+     * @return Slot
+     */
+    public function clone(
+        ?string $publicKey = null,
+        ?int $order = null,
+        ?WalletViewModel $wallet = null,
+        ?Carbon $forgingAt = null,
+        ?array $lastBlock = null,
+        ?string $status = null,
+        ?Collection $roundBlockCount = null,
+        ?int $roundNumber = null,
+        ?int $secondsUntilForge = null,
+    ): self {
+        return new self(
+            publicKey: $publicKey ?? $this->publicKey,
+            order: $order ?? $this->order,
+            wallet: $wallet ?? $this->wallet,
+            forgingAt: $forgingAt ?? $this->forgingAt,
+            lastBlock: $lastBlock ?? $this->lastBlock,
+            status: $status ?? $this->status,
+            roundBlockCount: $roundBlockCount ?? $this->roundBlockCount,
+            roundNumber: $roundNumber ?? $this->roundNumber,
+            secondsUntilForge: $secondsUntilForge ?? $this->secondsUntilForge,
+        );
+    }
+
     private function getLastHeight(): int
     {
         return Arr::get($this->lastBlock, 'height', 0);

app/Http/Livewire/Concerns/DelegateData.php

@@ -17,28 +17,48 @@
 use Illuminate\Support\Arr;
 use Illuminate\Support\Collection;
 use Illuminate\Support\Facades\Cache;
+use Illuminate\Support\Facades\DB;
 
 trait DelegateData
 {
-    private function cacheLastBlocks(array $delegates): void
+    private function cacheTtl(): int
     {
-        $ttl = (int) ceil(Network::blockTime() / 2);
+        return (int) ceil(Network::blockTime() / 2);
+    }
 
-        Cache::remember('monitor:last-blocks', $ttl, function () use ($delegates): void {
+    private function cacheLastBlocks(array $delegates): void
+    {
+        Cache::remember('monitor:last-blocks', $this->cacheTtl(), function () use ($delegates): bool {
             $blocks = Block::query()
                 ->orderBy('height', 'desc')
                 ->limit(Network::delegateCount() * 2)
                 ->get();
 
+            $lastBlockIds = DB::connection('explorer')
+                ->table('wallets')
+                ->whereIn('public_key', $delegates)
+                ->select([
+                    'public_key',
+                    'last_block_id' => function ($query) {
+                        $query->select('id')
+                            ->from('blocks')
+                            ->whereColumn('generator_public_key', 'public_key')
+                            ->orderBy('height', 'desc')
+                            ->limit(1);
+                    },
+                ]);
+
+            /** @var Collection $lastBlocks */
+            $lastBlocks = Block::whereIn('id', $lastBlockIds->pluck('last_block_id'))
+                ->get()
+                ->groupBy('generator_public_key');
+
             foreach ($delegates as $delegate) {
                 $block = $blocks->firstWhere('generator_public_key', $delegate);
 
                 // The delegate hasn't forged in some rounds.
-                if (is_null($block)) {
-                    $block = Block::query()
-                        ->where('generator_public_key', $delegate)
-                        ->orderBy('height', 'desc')
-                        ->limit(1)
+                if (is_null($block) && $lastBlocks->has($delegate)) {
+                    $block = $lastBlocks->get($delegate)
                         ->first();
                 }
 
@@ -50,32 +70,56 @@ private function cacheLastBlocks(array $delegates): void
                 (new WalletCache())->setLastBlock($delegate, [
                     'id'                   => $block->id,
                     'height'               => $block->height->toNumber(),
-                    'timestamp'            => Timestamp::fromGenesis($block->timestamp)->unix(),
+                    'timestamp'            => $block->timestamp,
                     'generator_public_key' => $block->generator_public_key,
                 ]);
             }
+
+            return true;
+
+            // foreach ($delegates as $delegate) {
+            //     $block = $blocks->firstWhere('generator_public_key', $delegate);
+
+            //     // The delegate hasn't forged in some rounds.
+            //     if (is_null($block)) {
+            //         $block = Block::query()
+            //             ->where('generator_public_key', $delegate)
+            //             ->orderBy('height', 'desc')
+            //             ->limit(1)
+            //             ->first();
+            //     }
+
+            //     // The delegate has never forged.
+            //     if (is_null($block)) {
+            //         continue;
+            //     }
+
+            //     (new WalletCache())->setLastBlock($delegate, [
+            //         'id'                   => $block->id,
+            //         'height'               => $block->height->toNumber(),
+            //         'timestamp'            => Timestamp::fromGenesis($block->timestamp)->unix(),
+            //         'generator_public_key' => $block->generator_public_key,
+            //     ]);
+            // }
+
+            // return true;
         });
     }
 
     private function getBlocksByRange(array $publicKeys, array $heightRange): Collection
     {
-        $key = 'monitor:last-blocks:'.md5(implode(',', $publicKeys)).':'.$heightRange[0].'-'.$heightRange[1];
-        $ttl = (int) ceil(Network::blockTime() / 2);
-
-        return Cache::remember($key, $ttl, function () use ($publicKeys, $heightRange) {
-            return Block::query()
-                    ->whereIn('generator_public_key', $publicKeys)
-                    ->whereBetween('height', $heightRange)
-                    ->orderBy('height', 'asc')
-                    ->get();
-        });
+        return Block::query()
+                ->whereIn('generator_public_key', $publicKeys)
+                ->whereBetween('height', $heightRange)
+                ->orderBy('height', 'asc')
+                ->get();
     }
 
     private function hasRoundStarted(int $height): bool
     {
         return Cache::remember(
             'delegate:round:'.$height,
-            Network::blockTime() / 2,
+            $this->cacheTtl(),
             fn () => Block::where('height', $height)->exists()
         );
     }
@@ -121,7 +165,8 @@ private function fetchDelegates(): array
                 lastBlock: (new WalletCache())->getLastBlock($delegate['publicKey']),
                 status: $delegate['status'],
                 roundBlockCount: $roundBlockCount,
-                roundNumber: $roundNumber
+                roundNumber: $roundNumber,
+                secondsUntilForge: $delegate['time'],
             );
         }
 

app/Http/Livewire/DelegateDataBoxes.php → app/Http/Livewire/Delegates/Concerns/HandlesMonitorDataBoxes.php

@@ -2,53 +2,28 @@
 
 declare(strict_types=1);
 
-namespace App\Http\Livewire;
+namespace App\Http\Livewire\Delegates\Concerns;
 
-use App\Actions\CacheNetworkHeight;
 use App\DTO\Slot;
 use App\Enums\DelegateForgingStatus;
 use App\Facades\Network;
-use App\Http\Livewire\Concerns\DeferLoading;
-use App\Http\Livewire\Concerns\DelegateData;
 use App\Models\Block;
 use App\Models\Wallet;
 use App\Services\Cache\MonitorCache;
 use App\Services\Cache\WalletCache;
 use App\Services\Monitor\Monitor;
 use App\ViewModels\ViewModelFactory;
 use App\ViewModels\WalletViewModel;
-use Illuminate\View\View;
-use Livewire\Component;
 
-final class DelegateDataBoxes extends Component
+trait HandlesMonitorDataBoxes
 {
-    use DeferLoading;
-    use DelegateData;
-
-    /** @var mixed */
-    protected $listeners = [
-        'echo:blocks,NewBlock' => 'pollStatistics',
-    ];
-
-    private array $delegates = [];
-
     private array $statistics = [];
 
-    public function render(): View
-    {
-        $this->delegates = $this->fetchDelegates();
-
-        return view('livewire.delegate-data-boxes', [
-            'height'     => CacheNetworkHeight::execute(),
-            'statistics' => $this->statistics,
-        ]);
-    }
-
     public function componentIsReady(): void
     {
         $this->setIsReady();
 
-        $this->pollStatistics();
+        $this->pollData();
     }
 
     public function pollStatistics(): void
@@ -111,9 +86,12 @@ public function getBlockCount(): string
 
     public function getNextDelegate(): ? WalletViewModel
     {
-        $this->delegates = $this->fetchDelegates();
+        $delegates = [
+            ...$this->delegates,
+            ...$this->overflowDelegates,
+        ];
 
-        return (new MonitorCache())->setNextDelegate(fn () => optional($this->getSlotsByStatus($this->delegates, 'pending'))->wallet());
+        return (new MonitorCache())->setNextDelegate(fn () => optional($this->getSlotsByStatus($delegates, 'pending'))->wallet());
     }
 
     private function getSlotsByStatus(array $slots, string $status): ?Slot