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);


TypeCasts library

Typecasts Library

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.

Overview

Quickstart

Applications

Guides

Developer Tools

Resources