Deployment script: fix the addresses output

The script now separates the protocol addresses from the each group of
collateral addresses.

This commit also updates the deployment-artifacts-to-app-env script to
generate env vars separated in a similar way.

contracts/utils/deploy-cli.ts

@@ -40,6 +40,14 @@ e.g. --chain-id can be set via CHAIN_ID instead. Parameters take precedence over
 
 const ANVIL_FIRST_ACCOUNT = "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80";
 
+const PROTOCOL_CONTRACTS_VALID_NAMES = [
+  "WETHTester",
+  "BoldToken",
+  "CollateralRegistry",
+  "HintHelpers",
+  "MultiTroveGetter",
+];
+
 const argv = minimist(process.argv.slice(2), {
   alias: {
     h: "help",
@@ -185,27 +193,43 @@ Deploying Liquity contracts with the following settings:
     `broadcast/DeployLiquity2.s.sol/${options.chainId}/run-latest.json`,
   );
 
+  const collateralContracts = await getAllCollateralsContracts(deployedContracts, options);
+
   // XXX hotfix: we were leaking Github secrets in "deployer"
   // TODO: check if "deployer" is a private key, and calculate its address and use it instead?
   const { deployer, ...safeOptions } = options;
 
+  const protocolContracts = Object.fromEntries(
+    filterProtocolContracts(deployedContracts),
+  );
+
   // write env file
   await fs.writeJson("deployment-context-latest.json", {
     options: safeOptions,
-    deployedContracts: Object.fromEntries(deployedContracts),
+    deployedContracts,
+    collateralContracts,
+    protocolContracts,
   });
 
   // format deployed contracts
   const longestContractName = Math.max(
     ...deployedContracts.map(([name]) => name.length),
   );
-  const deployedContractsFormatted = deployedContracts
-    .map(([name, address]) => `${name.padEnd(longestContractName)}  ${address}`)
-    .join("\n");
 
-  echo("Contract deployment complete.");
+  const formatContracts = (contracts: Array<string[]>) =>
+    contracts.map(([name, address]) => `  ${name.padEnd(longestContractName)}  ${address}`).join("\n");
+
+  echo("Protocol contracts:");
+  echo("");
+  echo(formatContracts(filterProtocolContracts(deployedContracts)));
   echo("");
-  echo(deployedContractsFormatted);
+  echo(
+    collateralContracts.map((collateral, index) => (
+      `Collateral ${index + 1} contracts:\n\n${formatContracts(Object.entries(collateral))}`
+    )).join("\n\n"),
+  );
+  echo("");
+  echo("Deployment complete.");
   echo("");
 }
 
@@ -255,6 +279,10 @@ async function getDeployedContracts(jsonPath: string) {
   throw new Error("Invalid deployment log: " + JSON.stringify(latestRun));
 }
 
+function filterProtocolContracts(contracts: Awaited<ReturnType<typeof getDeployedContracts>>) {
+  return contracts.filter(([name]) => PROTOCOL_CONTRACTS_VALID_NAMES.includes(name));
+}
+
 function safeParseInt(value: string) {
   const parsed = parseInt(value, 10);
   return isNaN(parsed) ? undefined : parsed;
@@ -296,3 +324,79 @@ async function parseArgs() {
 
   return { options, networkPreset };
 }
+
+async function castCall(
+  rpcUrl: string,
+  contract: string,
+  method: string,
+  ...args: string[]
+) {
+  try {
+    const result = await $`cast call ${contract} ${method} ${args.join(" ")} --rpc-url '${rpcUrl}'`;
+    return result.stdout.trim();
+  } catch (error) {
+    console.error(`Error calling ${contract} ${method} ${args.join(" ")}: ${error}`);
+    throw error;
+  }
+}
+
+async function getCollateralContracts(
+  collateralIndex: number,
+  collateralRegistry: string,
+  rpcUrl: string,
+) {
+  const [token, troveManager] = await Promise.all([
+    castCall(rpcUrl, collateralRegistry, "getToken(uint256)(address)", String(collateralIndex)),
+    castCall(rpcUrl, collateralRegistry, "getTroveManager(uint256)(address)", String(collateralIndex)),
+  ]);
+
+  const [
+    activePool,
+    borrowerOperations,
+    sortedTroves,
+    stabilityPool,
+  ] = await Promise.all([
+    castCall(rpcUrl, troveManager, "activePool()(address)"),
+    castCall(rpcUrl, troveManager, "borrowerOperations()(address)"),
+    castCall(rpcUrl, troveManager, "sortedTroves()(address)"),
+    castCall(rpcUrl, troveManager, "stabilityPool()(address)"),
+  ]);
+
+  return {
+    activePool,
+    borrowerOperations,
+    sortedTroves,
+    stabilityPool,
+    token,
+    troveManager,
+  };
+}
+
+async function getAllCollateralsContracts(
+  deployedContracts: Array<string[]>,
+  options: Awaited<ReturnType<typeof parseArgs>>["options"],
+) {
+  const deployedContractsRecord = Object.fromEntries(deployedContracts);
+
+  const ccall = async (contract: string, method: string, ...args: string[]) => {
+    const result = await $`cast call ${contract} ${method} ${args.join(" ")} --rpc-url '${options.rpcUrl}'`;
+    return result.stdout.trim();
+  };
+
+  const totalCollaterals = Number(
+    await ccall(
+      deployedContractsRecord.CollateralRegistry,
+      "totalCollaterals()",
+    ),
+  );
+
+  return Promise.all(
+    Array.from({ length: totalCollaterals }, (_, index) => (
+      getCollateralContracts(
+        index,
+        deployedContractsRecord.CollateralRegistry,
+        options.rpcUrl,
+      )
+    )),
+  );
+}

contracts/utils/deployment-artifacts-to-app-env.ts

@@ -33,14 +33,31 @@ const argv = minimist(process.argv.slice(2), {
 
 const ZAddress = z.string().regex(/^0x[0-9a-fA-F]{40}$/);
 const ZDeploymentContext = z.object({
-  deployedContracts: z.record(ZAddress),
+  deployedContracts: z.array(z.tuple([z.string(), ZAddress])),
+  collateralContracts: z.array(
+    z.object({
+      activePool: ZAddress,
+      borrowerOperations: ZAddress,
+      sortedTroves: ZAddress,
+      stabilityPool: ZAddress,
+      token: ZAddress,
+      troveManager: ZAddress,
+    }),
+  ),
+  protocolContracts: z.object({
+    BoldToken: ZAddress,
+    CollateralRegistry: ZAddress,
+    HintHelpers: ZAddress,
+    MultiTroveGetter: ZAddress,
+    WETHTester: ZAddress,
+  }),
 });
 
 type DeploymentContext = z.infer<typeof ZDeploymentContext>;
 
 const NULL_ADDRESS = `0x${"0".repeat(40)}`;
 
-export async function main() {
+export function main() {
   const options = {
     help: argv["help"],
     append: argv["append"],
@@ -58,24 +75,24 @@ export async function main() {
     process.exit(1);
   }
 
-  const { deployedContracts } = parseDeploymentContext(
-    await fs.readFile(options.inputJsonPath, "utf-8"),
+  const deploymentContext = parseDeploymentContext(
+    fs.readFileSync(options.inputJsonPath, "utf-8"),
   );
 
   const outputEnv = objectToEnvironmentVariables(
-    deployedContractsToAppEnvVariables(deployedContracts),
+    deployedContractsToAppEnvVariables(deploymentContext),
   );
 
   if (!options.outputEnvPath) {
     console.log(outputEnv);
     process.exit(0);
   }
 
-  await fs.ensureFile(options.outputEnvPath);
+  fs.ensureFileSync(options.outputEnvPath);
   if (options.append) {
-    await fs.appendFile(options.outputEnvPath, `\n${outputEnv}\n`);
+    fs.appendFileSync(options.outputEnvPath, `\n${outputEnv}\n`);
   } else {
-    await fs.writeFile(options.outputEnvPath, `${outputEnv}\n`);
+    fs.writeFileSync(options.outputEnvPath, `${outputEnv}\n`);
   }
 
   console.log(`\nEnvironment variables written to ${options.outputEnvPath}.\n`);
@@ -85,14 +102,24 @@ function objectToEnvironmentVariables(object: Record<string, unknown>) {
   return Object.entries(object)
     .map(([key, value]) => `${key}=${value}`)
     .sort()
+    .sort((a, b) => {
+      if (a.includes("_COLL_") && !b.includes("_COLL_")) {
+        return -1;
+      }
+      if (!a.includes("_COLL_") && b.includes("_COLL_")) {
+        return 1;
+      }
+      return 0;
+    })
     .join("\n");
 }
 
-function deployedContractsToAppEnvVariables(deployedContracts: DeploymentContext["deployedContracts"]) {
+function deployedContractsToAppEnvVariables(deployedContext: DeploymentContext) {
   const appEnvVariables: Record<string, string> = {};
 
-  for (const [contractName, address] of Object.entries(deployedContracts)) {
-    const envVarName = contractNameToAppEnvVariable(contractName);
+  // protocol contracts
+  for (const [contractName, address] of Object.entries(deployedContext.protocolContracts)) {
+    const envVarName = contractNameToAppEnvVariable(contractName, "CONTRACT");
     if (envVarName) {
       appEnvVariables[envVarName] = address;
     }
@@ -101,36 +128,48 @@ function deployedContractsToAppEnvVariables(deployedContracts: DeploymentContext
   appEnvVariables.NEXT_PUBLIC_CONTRACT_FUNCTION_CALLER = NULL_ADDRESS;
   appEnvVariables.NEXT_PUBLIC_CONTRACT_HINT_HELPERS = NULL_ADDRESS;
 
+  // collateral contracts
+  for (const [index, contract] of Object.entries(deployedContext.collateralContracts)) {
+    for (const [contractName, address] of Object.entries(contract)) {
+      const envVarName = contractNameToAppEnvVariable(contractName, `COLL_${index}_CONTRACT`);
+      if (envVarName) {
+        appEnvVariables[envVarName] = address;
+      }
+    }
+  }
+
   return appEnvVariables;
 }
 
-function contractNameToAppEnvVariable(contractName: string) {
+function contractNameToAppEnvVariable(contractName: string, prefix: string = "") {
+  prefix = `NEXT_PUBLIC_${prefix}`;
   switch (contractName) {
-    case "ActivePool":
-      return "NEXT_PUBLIC_CONTRACT_ACTIVE_POOL";
+    // protocol contracts
     case "BoldToken":
-      return "NEXT_PUBLIC_CONTRACT_BOLD_TOKEN";
-    case "BorrowerOperations":
-      return "NEXT_PUBLIC_CONTRACT_BORROWER_OPERATIONS";
-    case "CollSurplusPool":
-      return "NEXT_PUBLIC_CONTRACT_COLL_SURPLUS_POOL";
-    case "DefaultPool":
-      return "NEXT_PUBLIC_CONTRACT_DEFAULT_POOL";
-    case "ERC20Faucet":
-      return "NEXT_PUBLIC_CONTRACT_COLL_TOKEN";
-    case "GasPool":
-      return "NEXT_PUBLIC_CONTRACT_GAS_POOL";
-    case "MockInterestRouter":
-      return "NEXT_PUBLIC_CONTRACT_INTEREST_ROUTER";
-    case "PriceFeedTestnet":
-      return "NEXT_PUBLIC_CONTRACT_PRICE_FEED";
-    case "SortedTroves":
-      return "NEXT_PUBLIC_CONTRACT_SORTED_TROVES";
-    case "StabilityPool":
-      return "NEXT_PUBLIC_CONTRACT_STABILITY_POOL";
-    case "TroveManager":
-    case "TroveManagerTester":
-      return "NEXT_PUBLIC_CONTRACT_TROVE_MANAGER";
+      return `${prefix}_BOLD_TOKEN`;
+    case "CollateralRegistry":
+      return `${prefix}_COLLATERAL_REGISTRY`;
+    case "HintHelpers":
+      return `${prefix}_HINT_HELPERS`;
+    case "MultiTroveGetter":
+      return `${prefix}_MULTI_TROVE_GETTER`;
+    case "WETH":
+    case "WETHTester":
+      return `${prefix}_WETH`;
+
+    // collateral contracts
+    case "activePool":
+      return `${prefix}_ACTIVE_POOL`;
+    case "borrowerOperations":
+      return `${prefix}_BORROWER_OPERATIONS`;
+    case "sortedTroves":
+      return `${prefix}_SORTED_TROVES`;
+    case "stabilityPool":
+      return `${prefix}_STABILITY_POOL`;
+    case "token":
+      return `${prefix}_TOKEN`;
+    case "troveManager":
+      return `${prefix}_TROVE_MANAGER`;
   }
   return null;
 }
@@ -158,6 +197,9 @@ function parseDeploymentContext(content: string) {
       }).join("\n"),
     );
     console.error("");
+    console.error("Received:");
+    console.error(JSON.stringify(json, null, 2));
+
     process.exit(1);
   }