test: fix broken tests for zk broadcasts

feat: more aliases in justfile
feat: script for printing chains
fix: fix addresses for Sophon
refactor: rename scripts
test: rename functions

Author: PaulRBerg

TODOs.md

@@ -5,6 +5,4 @@
 
 # Priority 2
 
-- [ ] Check why Sophon tests don't work
-- [ ] Add just script for printing available chain names
 - [ ] Add `@unimplemented` tag for `compilerSettings`

justfile

@@ -16,13 +16,15 @@ biome-write:
 
 # Build the project
 build: clean tsc-build
+alias b := build
 
 # Clean the dist directory
 clean:
     bun rimraf dist
 
 # Run all code checks
 full-check: biome-check prettier-check tsc-check
+alias c := full-check
 
 # Run all code fixes
 full-write: biome-write prettier-write
@@ -39,13 +41,18 @@ prettier-check:
 prettier-write:
     bun prettier --cache --write "**/*.{md,yml}"
 
+# Print available chain arguments
+@print thing:
+    bun run scripts/print-{{ thing }}.ts
+
 # Setup Husky
 setup:
     bun husky
 
 # Run tests
 test:
     bun vitest run --silent
+alias t := test
 
 # Run tests with UI
 test-ui:

scripts/check-broadcasts.ts renamed to scripts/check-broadcast.ts

@@ -1,48 +1,45 @@
 import path from "node:path";
 import type { Sablier } from "@src/types";
-import type { Options as GlobbyOptions } from "globby";
-import { globby } from "globby";
+import * as fs from "fs-extra";
 import { logInfo } from "./logger";
 
 const ROOT_DIR = path.join(__dirname, "..");
 
 export async function checkBroadcast(
   release: Sablier.Release,
   chain: Sablier.Chain,
-  contractPath?: string,
+  innerPath?: string,
 ): Promise<string | null> {
-  return chain.isZK
-    ? checkZKBroadcast(release, chain, contractPath)
-    : checkStandardBroadcast(release, chain, contractPath);
+  if (chain.isZK) {
+    return await checkZK(release, chain, innerPath);
+  } else {
+    return await checkStandard(release, chain, innerPath);
+  }
 }
 /**
  * Checks that the broadcast file exists for the specified release and chain.
  * @param release - The release to check
  * @param chain - The chain to check
- * @param contractPath - The inner directory path to the contract to check, e.g. "core" or "periphery"
+ * @param innerPath - The inner directory path to the contract to check, e.g. "core" or "periphery"
  * @returns The path to the broadcast file if it exists, otherwise null
  */
-async function checkStandardBroadcast(
+async function checkStandard(
   release: Sablier.Release,
   chain: Sablier.Chain,
-  contractPath?: string,
+  innerPath?: string,
 ): Promise<string | null> {
-  return checkPath(release, chain, { onlyFiles: true }, contractPath, ".json");
+  return await checkPathExists(release, chain, innerPath, ".json");
 }
 
 /**
  * Checks that the ZK broadcast directory exists for the specified release and chain.
  * @param release - The release to check
  * @param chain - The chain to check
- * @param contractPath - The inner directory path to the contract to check, e.g. "core" or "periphery"
+ * @param innerPath - The inner directory path to the contract to check, e.g. "core" or "periphery"
  * @returns The path to the broadcast directory if it exists, otherwise null
  */
-async function checkZKBroadcast(
-  release: Sablier.Release,
-  chain: Sablier.Chain,
-  contractPath?: string,
-): Promise<string | null> {
-  return checkPath(release, chain, { onlyDirectories: true }, contractPath, "");
+async function checkZK(release: Sablier.Release, chain: Sablier.Chain, innerPath?: string): Promise<string | null> {
+  return await checkPathExists(release, chain, innerPath, "");
 }
 
 /**
@@ -58,30 +55,25 @@ async function checkZKBroadcast(
  *       └── mainnets/
  *         └── ethereum.json
  */
-async function checkPath(
+async function checkPathExists(
   release: Sablier.Release,
   chain: Sablier.Chain,
-  options: GlobbyOptions,
-  contractPath = "",
+  innerPath = "",
   suffix = "",
 ): Promise<string | null> {
   const chainType = chain.isTestnet ? "testnets" : "mainnets";
   const chainPath = path.join(chainType, `${chain.slug}${suffix}`);
   const basePath = path.join(__dirname, "..", "data", release.protocol, release.version);
-  const contractPathWithSlashes = contractPath ? `/${contractPath}/` : "";
+  const contractPathWithSlashes = innerPath ? `/${innerPath}/` : "";
   const pathToCheck = path.join(basePath, contractPathWithSlashes, chainPath);
 
-  const [pathExists] = await globby(pathToCheck, options);
-  const found = pathExists ? pathToCheck : null;
-
-  if (!pathExists) {
+  if (!fs.existsSync(pathToCheck)) {
     const relativePath = path.relative(ROOT_DIR, pathToCheck);
     logInfo({
       msg: `No broadcasts for ${chain.name} at ${relativePath}`,
       release,
     });
-    return null;
   }
 
-  return found;
+  return pathToCheck;
 }

scripts/print-chains.ts

@@ -0,0 +1,18 @@
+import { mainnets, testnets } from "@src/chains";
+import _ from "lodash";
+
+if (require.main === module) {
+  console.log("🌐 Mainnets:");
+  console.log(
+    _.values(mainnets)
+      .map((c) => `- ${c.slug}`)
+      .join("\n"),
+  );
+
+  console.log("\n🧪 Testnets:");
+  console.log(
+    _.values(testnets)
+      .map((c) => `- ${c.slug}`)
+      .join("\n"),
+  );
+}

scripts/print-missing-broadcasts.ts renamed to scripts/print-missing.ts

@@ -12,7 +12,7 @@ import queries from "@src/queries";
 import { releasesByProtocol } from "@src/releases";
 import type { Sablier } from "@src/types";
 import _ from "lodash";
-import { checkBroadcast } from "./check-broadcasts";
+import { checkBroadcast } from "./check-broadcast";
 import logger, { logAndThrow } from "./logger";
 
 const EMOJIS = {

src/chains/config.ts

@@ -28,6 +28,7 @@ export const config = {
     [viem.abstract.id]: true,
     [viem.sophon.id]: true,
     [viem.zksync.id]: true,
+    [viem.zksyncSepoliaTestnet.id]: true,
   } as ConfigBool,
 };
 

src/releases/lockup/v2.0/deployments.ts

@@ -168,9 +168,9 @@ export const mainnets: Sablier.Deployment[] = [
   }),
   get(chains.sophon.id, {
     [manifest.HELPERS]: "0x424B27529B49EF4Bfa0727aFcFE4387Ac2932944",
-    [manifest.LOCKUP_NFT_DESCRIPTOR]: "0xeaFB40669fe3523b073904De76410b46e79a56D7",
-    [manifest.SABLIER_BATCH_LOCKUP]: "0xAc2E42b520364940c90Ce164412Ca9BA212d014B",
-    [manifest.SABLIER_LOCKUP]: ["0x0000000000000000000000000000000000001010", 11_275_708],
+    [manifest.LOCKUP_NFT_DESCRIPTOR]: "0xAc2E42b520364940c90Ce164412Ca9BA212d014B",
+    [manifest.SABLIER_BATCH_LOCKUP]: "0x7282d83E49363f373102d195F66649eBD6C57B9B",
+    [manifest.SABLIER_LOCKUP]: ["0x28fCAE6bda2546C93183EeC8638691B2EB184003", 11_275_708],
     [manifest.VESTING_MATH]: "0x9971914DA16787F6cCfb27bEfB4404e33C8b869D",
   }),
   get(chains.superseed.id, {

tests/chains.test.ts

@@ -17,11 +17,11 @@ import axios from "axios";
 import { globby } from "globby";
 import _ from "lodash";
 import { beforeAll, describe, expect, it } from "vitest";
+import { MISSING_CHAINS } from "./setup/missing";
 
 const MALFUNCTIONING_RPC: number[] = [chains.meld.id];
-const MISSING_BROADCASTS: string[] = ["iotex", "ronin", "tangle", "ultra"];
 const KNOWN_SLUGS = _.values(chains)
-  .filter((chain) => !MISSING_BROADCASTS.includes(chain.slug))
+  .filter((chain) => !MISSING_CHAINS.includes(chain.id))
   .map((chain) => chain.slug);
 
 describe("Package chains are in sync with broadcasts", () => {
@@ -53,7 +53,7 @@ describe("Package chains are in sync with broadcasts", () => {
 
   it("should not have any unknown chain in broadcasts", () => {
     errors.clear();
-    const allowedSlugs = [...KNOWN_SLUGS, ...MISSING_BROADCASTS];
+    const allowedSlugs = [...KNOWN_SLUGS, ...MISSING_CHAINS];
     const extraChains = _.difference(broadcastSlugs, allowedSlugs);
 
     for (const slug of extraChains) {

tests/contracts/deployment-blocks.test.ts

@@ -1,4 +1,3 @@
-
 import { names } from "@src/contracts";
 import { Protocol } from "@src/enums";
 import queries from "@src/queries";

tests/deployments/utils/finders.ts

@@ -1,12 +1,12 @@
 import _ from "lodash";
-import type { BasicContract, BroadcastJSON, ZKBroadcastJSON } from "../../types";
+import type { BasicContract, StandardBroadcast, ZKBroadcast } from "../../types";
 
 const CONTRACT_PREFIX = "contract ";
 
 /**
  * Finds a contract in the broadcast data.
  */
-export function findContract(data: BroadcastJSON, contractName: string): BasicContract | null {
+export function findContract(data: StandardBroadcast, contractName: string): BasicContract | null {
   const contractFromReturns = findInReturns(data, contractName);
   if (contractFromReturns) return contractFromReturns;
 
@@ -17,8 +17,8 @@ export function findContract(data: BroadcastJSON, contractName: string): BasicCo
   return null;
 }
 
-export function findZKContract(zkData: ZKBroadcastJSON[], contractName: string): ZKBroadcastJSON | null {
-  return zkData.find((zk) => zk.contractName === contractName) ?? null;
+export function findZKContract(zkData: ZKBroadcast[], contractName: string): ZKBroadcast | null {
+  return _.find(zkData, { contractName }) ?? null;
 }
 
 /**
@@ -31,8 +31,11 @@ export function findZKContract(zkData: ZKBroadcastJSON[], contractName: string):
  *  }
  * }
  */
-export function findInReturns(data: BroadcastJSON, contractName: string): BasicContract | null {
-  if (!data.returns) return null;
+function findInReturns(data: StandardBroadcast, contractName: string): BasicContract | null {
+  if (!data.returns) {
+    return null;
+  }
+
   for (const contractReturn of _.values(data.returns)) {
     const sanitizedName = contractReturn.internal_type.replace(CONTRACT_PREFIX, "");
     if (contractName === sanitizedName) {
@@ -50,8 +53,10 @@ export function findInReturns(data: BroadcastJSON, contractName: string): BasicC
  *   "src/libraries/Helpers.sol:Helpers:0xf8076E4Fb5cfE8be1C26E61222DC51828Db8C1dc"
  * ]
  */
-export function findInLibraries(data: BroadcastJSON, contractName: string): BasicContract | null {
-  if (!data.libraries) return null;
+function findInLibraries(data: StandardBroadcast, contractName: string): BasicContract | null {
+  if (!data.libraries) {
+    return null;
+  }
 
   for (const library of data.libraries) {
     // Ensure we have the format "path/to/file.sol:ContractName:0xAddress"