refactor: use deployments package

Author: PaulRBerg

.eslintignore

@@ -1,8 +1,12 @@
 # directories
 .docusaurus
+build
 node_modules
 repos
+src/autogen/**/*.mdx
+static
 
 # files
 babel.config.js
 docusaurus.config.ts
+sidebars.js

.gitignore

@@ -3,14 +3,12 @@
 .docusaurus
 build
 node_modules
+src/autogen/**/*.mdx
 
 # files
 *.env
 *.log
 *.tsbuildinfo
 .DS_Store
 .eslintcache
-.pnp.*
 package-lock.json
-pnpm-lock.yaml
-yarn.lock

.lintstagedrc.yml

@@ -1 +1,2 @@
-"*.{json,md,mdx,ts,tsx,yml}": "bun run fix"
+"*.{md,mdx,ts,tsx}": "bun run fix"
+"*.{json,yml}": "bun run prettier:write"

.prettierignore

@@ -1,11 +1,10 @@
 # directories
-.cache-loader
 .docusaurus
 build
 node_modules
 repos
+src/autogen/**/*.mdx
+static
 
 # files
-.pnp.*
 package-lock.json
-pnpm-lock.yaml

.vscode/settings.json

@@ -3,9 +3,13 @@
   "eslint.validate": ["markdown", "mdx", "javascript", "javascriptreact", "typescript", "typescriptreact"],
   "prettier.documentSelectors": ["**/*.tsx"],
   "search.exclude": {
-    "**/.docusaurus": true,
-    "**/node_modules": true,
-    "**/repos": true
+    ".docusaurus": true,
+    "build": true,
+    "node_modules": true,
+    "repos": true
   },
-  "typescript.tsdk": "node_modules/typescript/lib"
+  "typescript.tsdk": "node_modules/typescript/lib",
+  "[javascript][javascriptreact][typescript][typescriptreact]": {
+    "editor.defaultFormatter": "esbenp.prettier-vscode"
+  }
 }

bun.lock

@@ -0,0 +1,81 @@
+import { Command } from "commander";
+import { Protocol, type Sablier, sablier } from "sablier";
+import type { CliOptions } from "../types";
+import { Links } from "../../src/constants";
+import * as helpers from "../helpers";
+
+export function createDeploymentsCommand(): Command {
+  return new Command("deployments")
+    .description("Generate deployment tables for all Sablier releases")
+    .action(async (_options, command) => {
+      const globalOptions = command.parent?.opts() || {};
+      await generateDeployments(globalOptions);
+    });
+}
+
+export async function generateDeployments(options: CliOptions = {}): Promise<void> {
+  for (const release of sablier.releases.getAll()) {
+    if (release.protocol === Protocol.Legacy) {
+      continue;
+    }
+
+    const tables = generateTables(release);
+    if (!tables) {
+      continue;
+    }
+
+    const fileName = helpers.autogenFileNames.deployments(release.version);
+    const filePath = helpers.getAutogenFilePath(release.protocol, fileName);
+
+    if (helpers.writeFileWithOverride({ filePath, content: tables, options })) {
+      helpers.log(`✅ Generated table with deployments for ${release.protocol} ${release.version}`, options);
+    }
+  }
+}
+
+function generateTables(release: Sablier.Release) {
+  const mainnetDeployments = release.deployments.filter((d) => {
+    const chain = sablier.chains.get(d.chainId);
+    return !chain.isTestnet;
+  });
+  const testnetDeployments = release.deployments.filter((d) => {
+    const chain = sablier.chains.get(d.chainId);
+    return chain.isTestnet;
+  });
+
+  let content = "## Mainnets\n\n";
+  for (const deployment of mainnetDeployments) {
+    const chain = sablier.chains.get(deployment.chainId);
+    content += `### ${chain.name}\n\n`;
+    content += generateDeploymentTable(deployment, release.protocol, release.version);
+    content += "\n";
+  }
+
+  content += "## Testnets\n\n";
+  for (const deployment of testnetDeployments) {
+    const chain = sablier.chains.get(deployment.chainId);
+    content += `### ${chain.name}\n\n`;
+    content += generateDeploymentTable(deployment, release.protocol, release.version);
+    content += "\n";
+  }
+
+  return content;
+}
+
+function generateDeploymentTable(deployment: Sablier.Deployment, protocol: Sablier.Protocol, version: string): string {
+  let table = `| Contract | Address | Deployment |\n`;
+  table += `| :-------- | :-------- | :--------- |\n`;
+
+  for (const contract of deployment.contracts) {
+    let address: string;
+    if (contract.explorerURL) {
+      address = `[\`${contract.address}\`](${contract.explorerURL})`;
+    } else {
+      address = `\`${contract.address}\``;
+    }
+    const link = `[\`${protocol}-${version}\`](${Links.GitHub.SDK}/blob/main/deployments/${protocol}/${version})`;
+    table += `| ${contract.name} | ${address} | ${link} |\n`;
+  }
+
+  return table;
+}

scripts/autogen.sh renamed to cli/autogen-reference.sh

@@ -0,0 +1,71 @@
+import { type Indexer, indexers } from "@sablier/indexers";
+import { Command } from "commander";
+import { sablier } from "sablier";
+import type { CliOptions } from "../types";
+import * as helpers from "../helpers";
+
+export function createIndexersCommand(): Command {
+  return new Command("indexers")
+    .description("Generate indexer endpoint tables for all Sablier protocols")
+    .action(async (_options, command) => {
+      const globalOptions = command.parent?.opts() || {};
+      await generateIndexers(globalOptions);
+    });
+}
+
+export async function generateIndexers(options: CliOptions = {}): Promise<void> {
+  generateTables("airdrops", options);
+  generateTables("flow", options);
+  generateTables("lockup", options);
+}
+
+function generateTables(protocol: Indexer.Protocol, options: CliOptions): void {
+  const graphTable = generateGraphTable(indexers.graph[protocol]);
+  const envioTable = generateEnvioTable(indexers.envio[protocol]);
+
+  const graphFilePath = helpers.getAutogenFilePath(protocol, helpers.autogenFileNames.theGraph);
+  if (helpers.writeFileWithOverride({ filePath: graphFilePath, content: graphTable, options })) {
+    helpers.log(`✅ Generated table with The Graph subgraphs for ${protocol}`, options);
+  }
+
+  const envioFilePath = helpers.getAutogenFilePath(protocol, helpers.autogenFileNames.envio);
+  if (helpers.writeFileWithOverride({ filePath: envioFilePath, content: envioTable, options })) {
+    helpers.log(`✅ Generated table with Envio endpoints for ${protocol}`, options);
+  }
+}
+
+function generateGraphTable(indexers: Indexer[]): string {
+  let markdown = `| Chain | Production URL | Studio URL | Playground URL |\n`;
+  markdown += `| -------- | -------------- | ---------- | -------------- |\n`;
+
+  for (const indexer of indexers) {
+    const chain = sablier.chains.getOrThrow(indexer.chainId);
+
+    const productionURL = indexer.endpoint.url;
+    const studioURL = indexer.explorerURL;
+    const playgroundURL = indexer.playgroundURL;
+
+    const productionCell = `[${indexer.name}](${productionURL})`;
+    const studioCell = studioURL ? `[Studio](${studioURL})` : "N/A";
+    const playgroundCell = playgroundURL ? `[GraphiQL Playground](${playgroundURL})` : "N/A";
+
+    markdown += `| ${chain.name} | ${productionCell} | ${studioCell} | ${playgroundCell} |\n`;
+  }
+
+  return markdown;
+}
+
+function generateEnvioTable(indexers: Indexer[]): string {
+  let markdown = `| Chain | Endpoint |\n`;
+  markdown += `| -------- | -------- |\n`;
+
+  for (const indexer of indexers) {
+    const chain = sablier.chains.get(indexer.chainId);
+    if (!chain || !chain.name) {
+      continue;
+    }
+    markdown += `| ${chain.name} | ${indexer.endpoint.url} |\n`;
+  }
+
+  return markdown;
+}

cli/commands/deployments.ts

@@ -0,0 +1,45 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { CliOptions } from "./types";
+import type { Sablier } from "sablier";
+
+const ROOT_DIR = path.join(__dirname, "..");
+if (!fs.existsSync(path.join(ROOT_DIR, "package.json"))) {
+  throw new Error("ROOT_DIR is not set correctly");
+}
+
+export const autogenFileNames = {
+  deployments: (version: Sablier.Version) =>
+    `TableDeployments${version.charAt(0).toUpperCase() + version.slice(1)}.mdx`,
+  envio: "TableEnvio.mdx",
+  theGraph: "TableTheGraph.mdx",
+};
+
+export function getAutogenFilePath(protocol: string, fileName: string): string {
+  return path.join(ROOT_DIR, "src", "autogen", protocol, fileName);
+}
+export function log(message: string, options: CliOptions): void {
+  if (options.verbose) {
+    console.log(message);
+  }
+}
+
+type FileWriteParams = {
+  filePath: string;
+  content: string;
+  encoding?: BufferEncoding;
+  options: CliOptions;
+};
+
+export function writeFileWithOverride(params: FileWriteParams): boolean {
+  const { filePath, content, encoding = "utf8", options } = params;
+
+  if (fs.existsSync(filePath) && !options.override) {
+    const relativePath = path.relative(process.cwd(), filePath);
+    log(`❌ File already exists: ${relativePath}. Use --override flag to override.`, options);
+    return false;
+  }
+
+  fs.writeFileSync(filePath, content, encoding);
+  return true;
+}