feat: legacy deployments

build: fix "include" paths in tsconfig.json
build: update tsconfig
ci: cron job for JSON-RPC tests
feat: add Ronin chain
feat: functions to retrieve all contracts
fix: latest version for Flow
refactor: move indexers logic
refactor: split helpers into separate getters
refactor: import from specific subfolders
refactor: use @internal to skip some logic from the dist bundle
test: run chains tests only when env var is set

Author: PaulRBerg

.github/workflows/cron-test-chains.yml

@@ -0,0 +1,35 @@
+name: "Cron: Test Chains"
+
+on:
+  schedule:
+    # Runs at 02:00 UTC every day
+    - cron: "0 2 * * *"
+  workflow_dispatch:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - name: "Check out the repo"
+        uses: "actions/checkout@v4"
+
+      - name: "Install Bun"
+        uses: "oven-sh/setup-bun@v2"
+        with:
+          bun-version: "latest"
+
+      - name: "Install the Node.js dependencies"
+        run: "bun install --frozen-lockfile"
+
+      - name: "Check the code"
+        run: "bun run check"
+
+      - name: "Run the tests"
+        env:
+          TEST_JSON_RPC: true
+        run: "bun run test --retry 5 --testTimeout 60000" # run tests with 5 retries and 60 seconds of timeout
+
+      - name: "Add summary"
+        run: | # shell
+          echo "## Test Chains result" >> $GITHUB_STEP_SUMMARY
+          echo "✅ Passed" >> $GITHUB_STEP_SUMMARY

package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sablier/deployments",
   "description": "Keeping track of Sablier deployments",
-  "version": "1.0.0-alpha.15",
+  "version": "1.0.0-alpha.16",
   "author": {
     "name": "Sablier Labs Ltd",
     "url": "https://sablier.com"
@@ -62,7 +62,7 @@
     "test:ui": "vitest --silent --ui",
     "test:watch": "vitest --silent",
     "tsc:build": "tsc -p tsconfig.build.json && bun tsc-alias -p tsconfig.build.json",
-    "tsc:check": "tsc -p tsconfig.build.json --noEmit"
+    "tsc:check": "tsc -p tsconfig.json --noEmit"
   },
   "types": "./dist/index.d.ts"
 }

scripts/print-aliases.ts

@@ -1,5 +1,4 @@
 import { releases } from "@src/releases";
-import { isLockupV1Release } from "@src/types";
 import _ from "lodash";
 import logger from "./logger";
 
@@ -21,7 +20,7 @@ async function main() {
       let contractName: string;
 
       // Lockup v1.x has core/periphery structure, others are flat
-      if (isLockupV1Release(release)) {
+      if (release.kind === "lockupV1") {
         // Type cast the manifest to ManifestLockupV1
         const manifest = release.manifest;
         contractName = _.get(manifest.core, key) || _.get(manifest.periphery, key) || key;

scripts/print-missing-broadcasts.ts

@@ -8,9 +8,9 @@
  *   bun run scripts/missing-broadcasts.ts flow
  *   bun run scripts/missing-broadcasts.ts lockup
  */
-import { getChain, releasesByProtocol } from "@src";
+import { getChain } from "@src/chains";
+import { releasesByProtocol } from "@src/releases";
 import type { Sablier } from "@src/types";
-import { isLockupV1Release } from "@src/types";
 import _ from "lodash";
 import { checkBroadcast, checkZKBroadcast } from "./check-broadcast";
 import logger from "./logger";
@@ -30,9 +30,9 @@ type BroadcastType = Sablier.Protocol;
 
 function parseArgs(): BroadcastType {
   const protocol = process.argv[2] as BroadcastType;
-  const validProtocols: BroadcastType[] = ["flow", "airdrops", "lockup"];
+  const validProtocols: BroadcastType[] = ["airdrops", "flow", "legacy", "lockup"];
   if (!protocol || !validProtocols.includes(protocol)) {
-    logger.error("Error: Please provide one of these protocols: flow, airdrops, or lockup");
+    logger.error("Error: Please provide one of these protocols: airdrops, flow, legacy, lockup");
     process.exit(1);
   }
 
@@ -65,20 +65,28 @@ async function checkMissingBroadcasts(): Promise<void> {
     for (const deployment of release.deployments) {
       const chain = getChain(deployment.chainId);
 
-      // TODO
-      if (isLockupV1Release(release)) {
+      let hasValidBroadcasts = false;
+
+      if (release.kind === "lockupV1") {
+        const components = ["core", "periphery"];
+        hasValidBroadcasts = await Promise.all(
+          components.map((component) =>
+            chain.isZK ? checkZKBroadcast(release, chain, component) : checkBroadcast(release, chain, component),
+          ),
+        ).then((results) => results.every(Boolean));
       } else {
         const paths = chain.isZK
           ? await checkZKBroadcast(release, chain, "")
           : await checkBroadcast(release, chain, "");
+        hasValidBroadcasts = !!paths;
+      }
 
-        // Note: for LockupV1, we expect both core and periphery paths to exist.
-        if (!paths) {
-          if (!missing[release.version]) {
-            missing[release.version] = [];
-          }
-          missing[release.version].push(chain);
+      // Add to missing list if broadcasts aren't valid
+      if (!hasValidBroadcasts) {
+        if (!missing[release.version]) {
+          missing[release.version] = [];
         }
+        missing[release.version].push(chain);
       }
     }
   }

src/chains/ids.ts

@@ -20,6 +20,7 @@ export const ChainId = {
   MORPH: 2818,
   OP_MAINNET: 10,
   POLYGON: 137,
+  RONIN: 2020,
   SCROLL: 534352,
   SEI: 1329,
   SUPERSEED: 5330,

src/chains/index.ts

@@ -14,5 +14,21 @@ import { mainnets, mainnetsById } from "./mainnets";
 import { testnets, testnetsById } from "./testnets";
 
 export { mainnets, mainnetsById, testnets, testnetsById };
-export const all: Sablier.Chain[] = [...mainnets, ...testnets];
-export const allById: Record<number, Sablier.Chain> = { ...mainnetsById, ...testnetsById };
+export const chains: Sablier.Chain[] = [...mainnets, ...testnets];
+export const chainsById: Record<number, Sablier.Chain> = { ...mainnetsById, ...testnetsById };
+
+export function getChain(chainId: number | string): Sablier.Chain {
+  const chain = chainsById[Number(chainId)];
+  if (!chain) {
+    throw new Error(`Chain with ID ${chainId} not found`);
+  }
+  return chain;
+}
+
+export function getChainName(chainId: number | string): string {
+  const chainName = chainsById[Number(chainId)].name;
+  if (!chainName) {
+    throw new Error(`Chain with ID ${chainId} not found`);
+  }
+  return chainName;
+}

src/chains/mainnets.ts

@@ -281,6 +281,19 @@ export const mainnetsById: Record<number, Sablier.Chain> = {
       public: "https://polygon-bor.publicnode.com",
     },
   },
+  [ChainId.RONIN]: {
+    explorerURL: "https://app.roninchain.com/",
+    id: ChainId.RONIN,
+    isSupportedByUI: false,
+    isTestnet: false,
+    isZK: false,
+    key: "ronin",
+    name: "Ronin",
+    nativeToken: ETH,
+    rpc: {
+      public: "https://api.roninchain.com/rpc",
+    },
+  },
   [ChainId.SCROLL]: {
     explorerURL: "https://scrollscan.com",
     id: ChainId.SCROLL,

src/chains/testnets.ts

@@ -42,7 +42,7 @@ export const testnetsById: Record<number, Sablier.Chain> = {
     name: "Blast Sepolia",
     nativeToken: ETH,
     rpc: {
-      public: "https://sepolia.blast.io",
+      public: "https://rpc.ankr.com/blast_testnet_sepolia",
     },
   },
   [ChainId.ETHEREUM_SEPOLIA]: {

src/constants.ts

@@ -1,25 +1,8 @@
-import _ from "lodash";
-import { allById } from "./chains";
-import { BaseURL, THEGRAPH_ORG_ID } from "./constants";
-import { envio, subgraphs } from "./indexers";
-import type { Sablier } from "./types";
+import { getChain } from "@src/chains";
 import versions from "./versions";
 
-export function getChain(chainId: number | string): Sablier.Chain {
-  const chain = allById[Number(chainId)];
-  if (!chain) {
-    throw new Error(`Chain with ID ${chainId} not found`);
-  }
-  return chain;
-}
-
-export function getChainName(chainId: number | string): string {
-  const chainName = allById[Number(chainId)].name;
-  if (!chainName) {
-    throw new Error(`Chain with ID ${chainId} not found`);
-  }
-  return chainName;
-}
+import _ from "lodash";
+import type { Sablier } from "./types";
 
 /**
  * Get the explorer URL for a contract. Compatible with Etherscan, Blockscout, etc.
@@ -31,70 +14,18 @@ export function getContractExplorerURL(explorerURL: string, contractAddress: Sab
   return `${explorerURL}/address/${contractAddress}`;
 }
 
-export function getDeployment(
-  protocol: Sablier.Protocol,
-  chainId: number,
-  contractMap: Sablier.ContractMap,
-  aliases: Sablier.AliasMap,
-): Sablier.Deployment {
-  const chain = getChain(chainId);
-  const contracts: Sablier.Contract[] = [];
-  for (const [contractName, address] of _.entries(contractMap)) {
-    const alias = aliases[contractName];
-    const explorerURL = getContractExplorerURL(chain.explorerURL, address);
-    contracts.push({ address, alias, explorerURL, name: contractName });
-  }
-
-  const envioEndpoint = getEnvioEndpoint(protocol, chainId);
-  const thegraph = getTheGraph(protocol, chainId);
-
-  return {
-    chainId,
-    contracts,
-    indexers: {
-      envio: envioEndpoint,
-      thegraph,
-    },
-  };
-}
-
-export function getDeploymentLockupV1(
-  chainId: number,
-  contractMap: {
-    core: Sablier.ContractMap;
-    periphery: Sablier.ContractMap;
-  },
-  aliases: Sablier.AliasMap,
-): Sablier.DeploymentLockupV1 {
-  const mergedContracts = { ...contractMap.core, ...contractMap.periphery };
-  const deployment = getDeployment("lockup", chainId, mergedContracts, aliases) as Sablier.DeploymentLockupV1;
-  deployment.core = _.entries(contractMap.core).map(([name, address]) => ({ name, address }));
-  deployment.periphery = _.entries(contractMap.periphery).map(([name, address]) => ({ name, address }));
-  return deployment;
-}
-
 /**
  * Extract all string values from a nested object
  * @param obj The object to extract string values from
  * @returns Array of all string values from the object
  */
-export const getNestedValues = <T extends Record<string, unknown>>(obj: T): string[] => {
+export function getNestedValues<T extends Record<string, unknown>>(obj: T): string[] {
   return _.flatMap(obj, (value) => {
     if (_.isObject(value) && !_.isArray(value)) {
       return getNestedValues(value as Record<string, unknown>);
     }
     return _.isString(value) ? value : [];
   });
-};
-
-/** Type guard to check if a manifest is a Lockup v1.x manifest. */
-export function isLockupV1Manifest(manifest: Sablier.Manifest): manifest is Sablier.ManifestLockupV1 {
-  return "core" in manifest && "periphery" in manifest;
-}
-
-/** Type guard to check if a release is a Lockup v1.x release. */
-export function isLockupV1Release(release: Sablier.Release): release is Sablier.ReleaseLockupV1 {
-  return release.protocol === "lockup" && release.version.startsWith("v1.");
 }
 
 export function isValidAirdropsVersion(version: Sablier.Version): boolean {
@@ -105,6 +36,10 @@ export function isValidFlowVersion(version: Sablier.Version): boolean {
   return version === versions.flow.v1_0 || version === versions.flow.v1_1;
 }
 
+export function isValidLegacyVersion(version: Sablier.Version): boolean {
+  return version === versions.legacy.v1_0 || version === versions.legacy.v1_1;
+}
+
 export function isValidLockupVersion(version: Sablier.Version): boolean {
   return (
     version === versions.lockup.v1_0 ||
@@ -125,30 +60,3 @@ export function sortDeployments<T extends { chainId: number }>(deployments: T[])
     return aChain.name.localeCompare(bChain.name);
   });
 }
-
-/*//////////////////////////////////////////////////////////////////////////
-                              PRIVATE FUNCTIONS
-//////////////////////////////////////////////////////////////////////////*/
-
-function getEnvioEndpoint(protocol: Sablier.Protocol, chainId: number): string | undefined {
-  if (chainId in envio.unsupportedChains) {
-    return undefined;
-  }
-  return envio.endpoints[protocol];
-}
-
-function getTheGraph(protocol: Sablier.Protocol, chainId: number): Sablier.TheGraph | undefined {
-  const subgraph = subgraphs[protocol][chainId];
-  if (!subgraph) {
-    return undefined;
-  }
-
-  return {
-    explorer: `${BaseURL.TheGraph.EXPLORER}/${subgraph.id}`,
-    studio: `${BaseURL.TheGraph.STUDIO}/${THEGRAPH_ORG_ID}/${subgraph.name}/version/latest`,
-    subgraph: {
-      id: subgraph.id,
-      url: (apiKey: string) => `${BaseURL.TheGraph.GATEWAY}/${apiKey}/subgraphs/id/${subgraph.id}`,
-    },
-  };
-}