Fix links and add script to look for them

.gitignore

@@ -35,3 +35,6 @@ witness.wtns
 *.zkey
 circuit_cpp/
 circuit_js
+
+# Link checker results
+docs/dead_links_report.txt

docs/3_guides/0_submitting_proofs.md

@@ -61,7 +61,7 @@ This will create the ECDSA keystore file in `~/.aligned_keystore/keystore0`
 
 ### Alternative 2: With EigenLayer CLI
 
-- If you have the EigenLayer CLI installed, the keystore can be generated following [these](https://docs.eigenlayer.xyz/eigenlayer/operator-guides/operator-installation#import-keys) instructions. The key will be stored into `~/.eigenlayer/operator_keys`.
+- If you have the EigenLayer CLI installed, the keystore can be generated following [these](https://docs.eigencloud.xyz/products/eigenlayer/operators/howto/operator-installation) instructions. The key will be stored into `~/.eigenlayer/operator_keys`.
 
 ## 2. Send funds to Aligned
 

docs/3_guides/2.2_modify_zkquiz_questions.md

@@ -74,7 +74,7 @@ if output
 ## 3. Compile the Program
 
 Now we need to compile the updated Program, generating the binary file that will be run by the zkVM (ELF).
-For this, ensure that the [SP1 Rust toolchain](https://docs.succinct.xyz/introduction.html) is installed. Run:
+For this, ensure that the [SP1 Rust toolchain](https://docs.succinct.xyz/docs/sp1/introduction) is installed. Run:
 
 ```
 make compile_elf

docs/3_guides/2_build_your_first_aligned_application.md

@@ -96,7 +96,7 @@ ZkQuiz has three main components:
 The user interacts with ZkQuiz App to solve a trivia challenge answering questions. Then, the App generates a Zk Proof with the Program generated using SP1.
 
 {% hint style="info" %}
-The ZkQuiz Program is built using SP1 following the [quickstart guide](https://docs.succinct.xyz/getting-started/quickstart.html#project-overview). For your projects, you can user any of the [prooving systems supported by Aligned](../2_architecture/0_supported_verifiers.md).
+The ZkQuiz Program is built using SP1 following the [quickstart guide](https://docs.succinct.xyz/docs/sp1/getting-started/quickstart). For your projects, you can user any of the [prooving systems supported by Aligned](../2_architecture/0_supported_verifiers.md).
 {% endhint %}
 
 Once the proof is generated, the App sends the proof to Aligned, and once it is verified, the App calls to the ZkQuiz Verifier Contract to check the proof verification and send an NFT to the user is the proof was verified in Aligned.

docs/3_guides/3_validating_public_input.md

@@ -7,7 +7,7 @@ This guide demonstrates how to validate Risc0 and SP1 proofs using the Aligned S
 In this case, the Fibonacci number to be calculated is **500** and the last two numbers of the sequence modulo 7919 are **1268** and **1926**.
 
 ## Requirements
-- [SP1](https://docs.succinct.xyz/getting-started/install.html)
+- [SP1](https://docs.succinct.xyz/docs/sp1/getting-started/install)
 - [Risc0](https://dev.risczero.com/api/zkvm/install)
 - [Foundry](https://book.getfoundry.sh/getting-started/installation)
 
@@ -29,7 +29,7 @@ For `SP1`, the Fibonacci program is located in `examples/validating-public-input
 
 > [!IMPORTANT]
 > To generate the proof ensure you have [docker](https://www.docker.com/get-started/) installed and the docker daemon running.
-> This is necessary to ensure deterministic builds of the binary we want to generate a proof of. If not used, builds may differ depending on the system you are running on. To know more about this, check [this link](https://dev.risczero.com/terminology#deterministic-builds) from RiscZero docs or [this](https://docs.succinct.xyz/writing-programs/compiling.html#advanced-build-options-1) from SP1.
+> This is necessary to ensure deterministic builds of the binary we want to generate a proof of. If not used, builds may differ depending on the system you are running on. To know more about this, check [this link](https://dev.risczero.com/terminology#deterministic-builds) from RiscZero docs or [this](https://docs.succinct.xyz/docs/sp1/writing-programs/compiling) from SP1.
 
 To submit proofs to **Aligned** and get them verified, you first need to generate those proofs. Every proving system has its own method for generating proofs.
 

docs/3_guides/4_generating_proofs.md

@@ -6,9 +6,9 @@
 
 This guide assumes that:
 
-- sp1 prover installed (instructions [here](https://succinctlabs.github.io/sp1/getting-started/install.html))
+- sp1 prover installed (instructions [here](https://docs.succinct.xyz/docs/sp1/getting-started/install))
 - sp1 project to generate the proofs
-  (instructions [here](https://succinctlabs.github.io/sp1/generating-proofs/setup.html))
+  (instructions [here](https://docs.succinct.xyz/docs/sp1/getting-started/quickstart))
 - aligned installed (instructions [here](../1_introduction/1_try_aligned.md#quickstart))
 
 ### How to generate a proof

docs/3_guides/7_contract_addresses.md

@@ -32,7 +32,7 @@ Below is the list of supported strategies available on Aligned Mainnet:
 | [lsETH](https://app.eigenlayer.xyz/restake/lsETH)          | [0xAe60d8180437b5C34bB956822ac2710972584473](https://etherscan.io/address/0xAe60d8180437b5C34bB956822ac2710972584473) |
 | [mETH](https://app.eigenlayer.xyz/restake/mETH)            | [0x298aFB19A105D59E74658C4C334Ff360BadE6dd2](https://etherscan.io/address/0x298aFB19A105D59E74658C4C334Ff360BadE6dd2) |
 
-For additional details, refer to the [official EigenLayer documentation](https://github.com/Layr-Labs/eigenlayer-contracts/tree/mainnet?tab=readme-ov-file#strategies).
+For additional details, refer to the [official EigenLayer documentation](https://github.com/Layr-Labs/eigenlayer-contracts).
 
 
 ## Holesky Deployments

docs/3_guides/setup_holesky.md

@@ -4,8 +4,8 @@
 
 These contracts are not deployed by Aligned. Current EigenLayer contracts:
 
-- [Holesky Contracts](https://github.com/Layr-Labs/eigenlayer-contracts/blob/testnet-holesky/script/configs/holesky/Holesky_current_deployment.config.json)
-- [Mainnet Contracts](https://github.com/Layr-Labs/eigenlayer-contracts/blob/mainnet/script/configs/mainnet/Mainnet_current_deployment.config.json)
+- [Holesky Contracts](https://github.com/Layr-Labs/eigenlayer-contracts/blob/main/script/configs/holesky.json)
+- [Mainnet Contracts](https://github.com/Layr-Labs/eigenlayer-contracts/blob/main/script/configs/mainnet.json)
 
 ## Aligned Contracts: Holesky/Mainnet
 

docs/README.md

@@ -0,0 +1,5 @@
+# Aligned Docs
+
+To check for broken links run:
+
+```python3 check_markdown_links.py```

docs/about_aligned/learning_resources.md

@@ -2,7 +2,7 @@
 
 ## Aligned blog post:
 
-* [Aligned](https://blog.alignedlayer.com/aligned-layer/)
+* [Aligned Blog](https://blog.alignedlayer.com)
 
 ## Aligned repo:
 

docs/check_markdown_links.py

@@ -0,0 +1,208 @@
+#!/usr/bin/env python3
+
+import os
+import re
+import urllib.request
+import urllib.error
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from datetime import datetime
+import threading
+import time
+import random
+
+# Thread-safe counters
+alive_count = 0
+dead_count = 0
+count_lock = threading.Lock()
+
+def find_markdown_files():
+    """Find all markdown files in the current directory"""
+    md_files = []
+    docs_path = "."
+
+    if not os.path.exists(docs_path):
+        print(f"Current folder not found")
+        return md_files
+
+    for root, dirs, files in os.walk(docs_path):
+        for file in files:
+            if file.endswith('.md'):
+                md_files.append(os.path.join(root, file))
+
+    return md_files
+
+def extract_links_from_file(file_path):
+    """Extract HTTP/HTTPS links from a markdown file"""
+    links = []
+
+    try:
+        with open(file_path, 'r', encoding='utf-8') as f:
+            for line_num, line in enumerate(f, 1):
+                # Find markdown links [text](url)
+                markdown_links = re.findall(r'\[([^\]]*)\]\(([^)]+)\)', line)
+                for text, url in markdown_links:
+                    if url.startswith(('http://', 'https://')):
+                        links.append((file_path, line_num, url.strip()))
+
+                # Find direct links <url>
+                direct_links = re.findall(r'<(https?://[^>]+)>', line)
+                for url in direct_links:
+                    links.append((file_path, line_num, url.strip()))
+
+    except Exception as e:
+        print(f"Error reading {file_path}: {e}")
+
+    return links
+
+def check_link_with_retry(file_path, line_num, url, max_retries=3):
+    """Check if a link is alive or dead with retry logic for rate limiting"""
+    global alive_count, dead_count
+
+    for attempt in range(max_retries):
+        try:
+            # Create request with a user agent to avoid 403 errors
+            req = urllib.request.Request(
+                url,
+                headers={'User-Agent': 'Mozilla/5.0 (compatible; LinkChecker/1.0)'}
+            )
+
+            # Set timeout for the request
+            with urllib.request.urlopen(req, timeout=15) as response:
+                status_code = response.getcode()
+                if 200 <= status_code < 400:
+                    with count_lock:
+                        alive_count += 1
+                    return 'ALIVE', file_path, line_num, url, None
+                else:
+                    with count_lock:
+                        dead_count += 1
+                    return 'DEAD', file_path, line_num, url, f"HTTP {status_code}"
+
+        except urllib.error.HTTPError as e:
+            if e.code == 429:  # Too Many Requests
+                if attempt < max_retries - 1:  # Don't wait on last attempt
+                    # Exponential backoff with jitter
+                    wait_time = (2 ** attempt) + random.uniform(0, 1)
+                    print(f"⏳ Rate limited for {url}, waiting {wait_time:.1f}s before retry {attempt + 2}/{max_retries}")
+                    time.sleep(wait_time)
+                    continue
+                else:
+                    # Final attempt failed with rate limiting
+                    with count_lock:
+                        alive_count += 1  # Assume it's alive if we're just rate limited
+                    return 'ALIVE', file_path, line_num, url, "Rate limited (assumed alive)"
+            else:
+                # Other HTTP errors (404, 403, etc.) - don't retry
+                with count_lock:
+                    dead_count += 1
+                return 'DEAD', file_path, line_num, url, f"HTTP {e.code}: {e.reason}"
+
+        except (urllib.error.URLError, Exception) as e:
+            if attempt < max_retries - 1:
+                # Retry on network errors
+                wait_time = (2 ** attempt) + random.uniform(0, 1)
+                print(f"⏳ Network error for {url}, waiting {wait_time:.1f}s before retry {attempt + 2}/{max_retries}")
+                time.sleep(wait_time)
+                continue
+            else:
+                # Final attempt failed
+                with count_lock:
+                    dead_count += 1
+                return 'DEAD', file_path, line_num, url, str(e)
+
+def main():
+    global alive_count, dead_count
+
+    print("Starting markdown link checking...")
+    print("==================================")
+
+    # Find all markdown files
+    print("Finding markdown files in current folder and extracting links...")
+    md_files = find_markdown_files()
+
+    if not md_files:
+        print("No markdown files found in current folder.")
+        return
+
+    # Extract all links
+    all_links = []
+    for file_path in md_files:
+        links = extract_links_from_file(file_path)
+        all_links.extend(links)
+
+    print(f"Found {len(all_links)} HTTP/HTTPS links to check in current folder")
+
+    if not all_links:
+        print("No HTTP/HTTPS links found in markdown files.")
+        return
+
+    # Check links in parallel
+    print("Checking links...")
+    dead_links = []
+    results = []
+
+    # Use ThreadPoolExecutor for parallel processing
+    with ThreadPoolExecutor(max_workers=20) as executor:
+        # Submit all link checking tasks
+        future_to_link = {
+            executor.submit(check_link_with_retry, file_path, line_num, url): (file_path, line_num, url)
+            for file_path, line_num, url in all_links
+        }
+
+        # Process results as they complete
+        for future in as_completed(future_to_link):
+            status, file_path, line_num, url, error = future.result()
+
+            if status == 'ALIVE':
+                if error:
+                    print(f"✓ ALIVE: {url} ({error})")
+                else:
+                    print(f"✓ ALIVE: {url}")
+            else:
+                print(f"✗ DEAD: {url} ({error})")
+                dead_links.append((file_path, line_num, url, error))
+
+            results.append((status, file_path, line_num, url, error))
+
+    # Calculate statistics
+    total_checked = alive_count + dead_count
+    alive_percentage = (alive_count * 100) // total_checked if total_checked > 0 else 0
+    dead_percentage = (dead_count * 100) // total_checked if total_checked > 0 else 0
+
+    # Display summary
+    print("\n===============================")
+    print("LINK CHECK SUMMARY")
+    print("===============================")
+    print(f"Total links found: {len(all_links)}")
+    print(f"Total links checked: {total_checked}")
+    print(f"Alive links: {alive_count} ({alive_percentage}%)")
+    print(f"Dead links: {dead_count} ({dead_percentage}%)")
+    print()
+
+    # Save dead links to file and display them
+    if dead_links:
+        output_file = "dead_links_report.txt"
+        with open(output_file, 'w') as f:
+            f.write(f"Dead Links Report - {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
+            f.write("================================\n\n")
+
+            for file_path, line_num, url, error in dead_links:
+                f.write(f"File: {file_path}\n")
+                f.write(f"Line: {line_num}\n")
+                f.write(f"URL: {url}\n")
+                f.write(f"Error: {error}\n")
+                f.write("---\n")
+
+        print(f"Dead links details saved to: {output_file}")
+        print("\nDEAD LINKS:")
+        print("----------")
+        for file_path, line_num, url, error in dead_links:
+            print(f"{file_path}:{line_num} - {url}")
+    else:
+        print("🎉 All links are alive!")
+
+    print("\nLink checking complete!")
+
+if __name__ == "__main__":
+    main()
+

docs/operator_guides/0_running_an_operator.md

@@ -8,7 +8,7 @@
 
 ## Requirements
 
-This guide assumes you are already [registered as an operator with EigenLayer](https://docs.eigenlayer.xyz/eigenlayer/operator-guides/operator-installation).
+This guide assumes you are already [registered as an operator with EigenLayer](https://docs.eigencloud.xyz/products/eigenlayer/operators/howto/operator-installation).
 
 ## Hardware Requirements
 
@@ -289,7 +289,7 @@ You will need to stake a minimum of 1000 WEI in WETH. We recommend to stake a ma
 
 ### Option 1
 
-EigenLayer's guide can be found [here](https://docs.eigenlayer.xyz/eigenlayer/restaking-guides/restaking-user-guide/liquid-restaking/restake-lsts).
+EigenLayer's restaking documentation can be found [here](https://docs.eigencloud.xyz/products/eigenlayer/restakers/concepts/overview) (general restaking overview).
 
 ### Option 2
 

docs/operator_guides/1_operator_FAQ.md

@@ -1,6 +1,6 @@
 # Operator FAQ
 
-The EigenLayer Operator FAQ is available [here](https://docs.eigenlayer.xyz/eigenlayer/operator-guides/operator-faq).
+The EigenLayer Operator installation guide is available [here](https://docs.eigencloud.xyz/products/eigenlayer/operators/howto/operator-installation).
 
 ### How do I get whitelisted to run an operator?