import { execSync } from "child_process";

const scripts = [
  "generate-deployments.js",
  "generate-ism-validators.js",
  "generate-latencies.js",
  "generate-domains.js",
];

console.log("🚀 Running all documentation generators...\n");

for (const script of scripts) {
  try {
    console.log(`📝 Running ${script}...`);
    execSync(`node ${script}`, { stdio: "inherit" });
    console.log(`✅ ${script} completed\n`);
  } catch (error) {
    console.error(`❌ ${script} failed:`, error.message);
    process.exit(1);
  }
}

console.log("🎉 All documentation generated successfully!");


import fs from "fs";
import path from "path";
import { fileURLToPath } from "url";
import { chainAddresses, chainMetadata } from "@hyperlane-xyz/registry";
import { getAbacusWorksChainNames } from "./registry.js";

// Setup __dirname for ES modules
const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

// Output folder
const outputBase = path.join(
  __dirname,
  "../docs/reference/addresses/deployments"
);

// Define contract types to generate tables for
const CONTRACT_KEYS = [
  "mailbox",
  "interchainAccountRouter",
  "interchainGasPaymaster",
  "validatorAnnounce",
  "merkleTreeHook",
  "proxyAdmin",
  "storageGasOracle",
  "testRecipient",
];

// Utility
const capitalize = (str) => str.charAt(0).toUpperCase() + str.slice(1);

// Get chains for a specific environment
function getChains(isTestnet) {
  const chainNames = getAbacusWorksChainNames(isTestnet);
  return chainNames.map((name) => chainMetadata[name]);
}

// Generates an MDX table body string
function generateTableRows(chains, contractKey) {
  return chains
    .map((chain) => {
      const address = chainAddresses[chain.name]?.[contractKey];
      if (!address) return null;

      const displayName = chain.displayName || capitalize(chain.name);
      const domainId = chain.domainId ?? "N/A";
      const chainId = chain.chainId ?? "N/A";
      const explorerUrl = chain.blockExplorers?.[0]?.url ?? "";
      const explorer = explorerUrl
        ? `[${new URL(explorerUrl).hostname}](${explorerUrl})`
        : "N/A";

      return `| ${displayName} | ${domainId} | ${chainId} | \`${address}\` | ${explorer} |`;
    })
    .filter(Boolean)
    .join("\n");
}

// Main generator
async function generateDeploymentDocs() {
  // Create the output directory if it doesn't exist
  fs.mkdirSync(outputBase, { recursive: true });

  const mainnetChains = getChains(false);
  const testnetChains = getChains(true);

  for (const key of CONTRACT_KEYS) {
    const mainnetRows = generateTableRows(mainnetChains, key);
    const testnetRows = generateTableRows(testnetChains, key);

    // Skip if no deployments found for either environment
    if (!mainnetRows && !testnetRows) continue;

    const content = `---
title: "${capitalize(key)}"
description: "${capitalize(key)} deployments across Mainnet and Testnet"
---

## Mainnet

| Chain | Domain ID | Chain ID | Address | Explorer |
|-------|-----------|----------|---------|----------|
${mainnetRows}

## Testnet

| Chain | Domain ID | Chain ID | Address | Explorer |
|-------|-----------|----------|---------|----------|
${testnetRows}
`;

    const filePath = path.join(outputBase, `${key}.mdx`);
    fs.writeFileSync(filePath, content.trim() + "\n", "utf-8");
    console.log(`✅ Wrote ${key}.mdx to deployments/`);
  }
}

// Run the generator
generateDeploymentDocs().catch(console.error);


import fs from "fs";
import path from "path";
import { fileURLToPath } from "url";
import { chainMetadata } from "@hyperlane-xyz/registry";
import { defaultMultisigConfigs } from "@hyperlane-xyz/sdk";
import { getAbacusWorksChainNames } from "./registry.js";

// Setup __dirname for ES modules
const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

// Output folder
const validatorsBase = path.join(
  __dirname,
  "../docs/reference/addresses/validators"
);

// Utility
const capitalize = (str) => str.charAt(0).toUpperCase() + str.slice(1);

// Get chains for a specific environment
function getChains(isTestnet) {
  const chainNames = getAbacusWorksChainNames(isTestnet);
  return chainNames.map((name) => chainMetadata[name]);
}

// Generates an MDX table body string for validators
function generateValidatorTable(chain, config) {
  const { name, displayName, domainId } = chain;
  const displayChainName = displayName ?? capitalize(name);

  return `## ${displayChainName} (${domainId})

Threshold: ${config.threshold} of ${config.validators.length}

| Operator | Address |
|----------|---------|
${config.validators
  .map(({ address, alias }) => `| ${alias} | \`${address}\` |`)
  .join("\n")}
`;
}

// Main generator
async function generateDefaultIsmDocs() {
  // Create the output directory if it doesn't exist
  fs.mkdirSync(validatorsBase, { recursive: true });

  const environments = [
    {
      name: "mainnet",
      isTestnet: false,
      filename: "mainnet-default-ism-validators.mdx",
    },
    {
      name: "testnet",
      isTestnet: true,
      filename: "testnet-default-ism-validators.mdx",
    },
  ];

  for (const env of environments) {
    const chains = getChains(env.isTestnet);
    const content = `---
title: "${capitalize(env.name)}"
description: "Default ISM validator configurations for ${env.name} chains"
---

${chains
  .map((chain) => {
    const config = defaultMultisigConfigs[chain.name];
    if (!config || (env.name === "mainnet" && config.validators.length <= 1))
      return null;
    return generateValidatorTable(chain, config);
  })
  .filter(Boolean)
  .join("\n")}
`;

    const filePath = path.join(validatorsBase, env.filename);
    fs.writeFileSync(filePath, content.trim() + "\n", "utf-8");
    console.log(`✅ Wrote ${env.filename} to validators/`);
  }
}

// Run the generator
generateDefaultIsmDocs().catch(console.error);


import fs from "fs";
import path from "path";
import { fileURLToPath } from "url";
import { chainMetadata } from "@hyperlane-xyz/registry";
import { getAbacusWorksChainNames } from "./registry.js";

// Setup __dirname for ES modules
const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

// Output folder
const latenciesBase = path.join(
  __dirname,
  "../docs/reference/addresses/validators"
);

// Utility
const capitalize = (str) => str.charAt(0).toUpperCase() + str.slice(1);

// Get chains for a specific environment
function getChains(isTestnet) {
  const chainNames = getAbacusWorksChainNames(isTestnet);
  return chainNames.map((name) => chainMetadata[name]);
}

// Generates an MDX table body string for reorg periods
function generateTableRows(chains) {
  return chains
    .map((chain) => {
      const displayName = chain.displayName || capitalize(chain.name);
      const domainId = chain.domainId ?? "N/A";
      const reorgPeriod = chain.blocks?.reorgPeriod ?? "N/A";
      const blockTime = chain.blocks?.estimateBlockTime ?? "N/A";

      return `| ${displayName} | ${domainId} | ${reorgPeriod} | ${blockTime} |`;
    })
    .join("\n");
}

// Main generator
async function generateLatencyDocs() {
  // Create the output directory if it doesn't exist
  fs.mkdirSync(latenciesBase, { recursive: true });

  const mainnetChains = getChains(false);
  const testnetChains = getChains(true);

  const mainnetRows = generateTableRows(mainnetChains);
  const testnetRows = generateTableRows(testnetChains);

  const content = `---
title: "Latencies"
---

Validators must wait a certain number of blocks to be mined before they are considered valid and [reorg-safe](https://www.alchemy.com/overviews/what-is-a-reorg). Without this, validators could be slashed since they may have signed a checkpoint that is no longer valid.

Refer to the following sections for block finality configuration used by the Hyperlane validators.

<Tabs>
  <Tab title="Mainnet">
    | Chain | Domain | Reorg Period (blocks) | Estimated Block Time (seconds) |
    |-------|--------|----------------------|-------------------------------|
    ${mainnetRows}
  </Tab>
  
  <Tab title="Testnet">
    | Chain | Domain | Reorg Period (blocks) | Estimated Block Time (seconds) |
    |-------|--------|----------------------|-------------------------------|
    ${testnetRows}
  </Tab>
</Tabs>
`;

  const filePath = path.join(latenciesBase, "latencies.mdx");
  fs.writeFileSync(filePath, content.trim() + "\n", "utf-8");
  console.log(`✅ Wrote latencies.mdx to latencies/`);
}

// Run the generator
generateLatencyDocs().catch(console.error);


import { chainAddresses, chainMetadata } from "@hyperlane-xyz/registry";

const ABACUS_WORKS_DEPLOYER_NAME = "abacus works";

// Pre-mainnet chains
const FILTER_LIST = [];

// Chains that Abacus Works has deployed (formerly known as 'core' chains)
export function getAbacusWorksChains(isTestnet = false, requireMailbox = true) {
  return Object.values(chainMetadata).filter((metadata) => {
    // Filter to chains whose deployer is Abacus Works
    const isRightDeployer =
      metadata.deployer?.name.trim().toLowerCase() ===
      ABACUS_WORKS_DEPLOYER_NAME;
    // Filter to only mainnets or testnets
    const isRightChainType = !!metadata.isTestnet === isTestnet;
    // If required, filter to chains that have a mailbox addresses in the registry
    const hasMailboxAddress =
      !requireMailbox || !!chainAddresses[metadata.name]?.mailbox;
    // Filter out chains in FILTER_LIST
    const isFiltered = FILTER_LIST.includes(metadata.name);
    return (
      isRightDeployer && isRightChainType && hasMailboxAddress && !isFiltered
    );
  });
}

export function getAbacusWorksChainNames(isTestnet = false) {
  return getAbacusWorksChains(isTestnet).map((metadata) => metadata.name);
}


import fs from "fs";
import path from "path";
import { fileURLToPath } from "url";
import { chainMetadata } from "@hyperlane-xyz/registry";
import { getAbacusWorksChainNames } from "./registry.js";

// Setup __dirname for ES modules
const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

// Output folder
const domainsBase = path.join(__dirname, "../snippets/addresses");

// Utility
const capitalize = (str) => str.charAt(0).toUpperCase() + str.slice(1);

// Get chains for a specific environment
function getChains(isTestnet) {
  const chainNames = getAbacusWorksChainNames(isTestnet);
  return chainNames.map((name) => chainMetadata[name]);
}

// Generates an MDX table body string for domain identifiers
function generateTableRows(chains) {
  return chains
    .sort((a, b) => {
      const nameA = a.displayName || capitalize(a.name);
      const nameB = b.displayName || capitalize(b.name);
      return nameA.localeCompare(nameB);
    })
    .map((chain) => {
      const displayName = chain.displayName || capitalize(chain.name);
      const domainId = chain.domainId ?? "N/A";
      return `| ${displayName} | ${domainId} |`;
    })
    .join("\n");
}

// Main generator
async function generateDomainsDocs() {
  // Create the output directory if it doesn't exist
  fs.mkdirSync(domainsBase, { recursive: true });

  const mainnetChains = getChains(false);
  const testnetChains = getChains(true);

  const mainnetRows = generateTableRows(mainnetChains);
  const testnetRows = generateTableRows(testnetChains);

  const content = `
## Mainnet

| Network | Domain Identifier (uint32) |
|---------|---------------------------|
${mainnetRows}

## Testnet

| Network | Domain Identifier (uint32) |
|---------|---------------------------|
${testnetRows}
`;

  const filePath = path.join(domainsBase, "domains.mdx");
  fs.writeFileSync(filePath, content.trim() + "\n", "utf-8");
  console.log(`✅ Wrote domains.mdx to reference/`);
}

// Run the generator
generateDomainsDocs().catch(console.error);


Overview

Available Community ISMs

Community ISMs

Hyperlane Docs

Welcome to the Hyperlane Documentation. Explore our tools, guides and references for building cross-chain applications.

Introduction

Intro to Hyperlane

Get Started Building with Hyperlane

Bridge a Token

This guide walks you through sending interchain messages between two local Anvil nodes using the Hyperlane CLI.

ISM Name	Type	Stage
Axelar ISM	Security	In Development
Celestia ZK ISM	Security	In Development
Noble ISM	Security	In Development
Polygon zkEVM V2 ISM	Security	In Development
Succinct Lightclient ISM	Security	In Development
Timelock ISM	Security	In Development
Wormhole ISM	Security	In Development

Introduction

Protocol

HYPER and Protocol Economics

Reference

Alt-VM Implementations & Guides

Resources

Community ISMs

Overview

Available Community ISMs

Introduction

Protocol

HYPER and Protocol Economics

Reference

Alt-VM Implementations & Guides

Resources

​Overview

​Available Community ISMs

Overview

Available Community ISMs