chore(scripts): refactor scripts (#134)

Author: xenoliss

scripts/src/commands/sol/onchain/base-relayer/initialize.command.ts

@@ -6,43 +6,30 @@ import { logger } from "@internal/logger";
 import { argsSchema, handleInitialize } from "./initialize.handler";
 
 type CommanderOptions = {
-  cluster?: string;
-  release?: string;
+  deployEnv?: string;
   payerKp?: string;
+  guardianKp?: string;
 };
 
 async function collectInteractiveOptions(
   options: CommanderOptions
 ): Promise<CommanderOptions> {
   let opts = { ...options };
 
-  if (!opts.cluster) {
-    const cluster = await select({
-      message: "Select target cluster:",
-      options: [{ value: "devnet", label: "Devnet" }],
-      initialValue: "devnet",
-    });
-    if (isCancel(cluster)) {
-      cancel("Operation cancelled.");
-      process.exit(1);
-    }
-    opts.cluster = cluster;
-  }
-
-  if (!opts.release) {
-    const release = await select({
-      message: "Select release type:",
+  if (!opts.deployEnv) {
+    const deployEnv = await select({
+      message: "Select target deploy environment:",
       options: [
-        { value: "prod", label: "Prod" },
-        { value: "alpha", label: "Alpha" },
+        { value: "development-alpha", label: "Development Alpha" },
+        { value: "development-prod", label: "Development Prod" },
       ],
-      initialValue: "prod",
+      initialValue: "development-alpha",
     });
-    if (isCancel(release)) {
+    if (isCancel(deployEnv)) {
       cancel("Operation cancelled.");
       process.exit(1);
     }
-    opts.release = release;
+    opts.deployEnv = deployEnv;
   }
 
   if (!opts.payerKp) {
@@ -79,17 +66,57 @@ async function collectInteractiveOptions(
     }
   }
 
+  if (!opts.guardianKp) {
+    const usePayerAsGuardian = await confirm({
+      message: "Use payer as guardian keypair?",
+      initialValue: true,
+    });
+    if (isCancel(usePayerAsGuardian)) {
+      cancel("Operation cancelled.");
+      process.exit(1);
+    }
+
+    if (usePayerAsGuardian) {
+      opts.guardianKp = "payer";
+    } else {
+      const keypairPath = await text({
+        message: "Enter path to guardian keypair:",
+        placeholder: "/path/to/guardian.json",
+        validate: (value) => {
+          if (!value || value.trim().length === 0) {
+            return "Keypair path cannot be empty";
+          }
+          const cleanPath = value.trim().replace(/^["']|["']$/g, "");
+          if (!existsSync(cleanPath)) {
+            return "Guardian keypair file does not exist";
+          }
+        },
+      });
+      if (isCancel(keypairPath)) {
+        cancel("Operation cancelled.");
+        process.exit(1);
+      }
+      opts.guardianKp = keypairPath.trim().replace(/^["']|["']$/g, "");
+    }
+  }
+
   return opts;
 }
 
 export const initializeCommand = new Command("initialize")
   .description("Initialize the Base Relayer program")
-  .option("--cluster <cluster>", "Target cluster (devnet)")
-  .option("--release <release>", "Release type (alpha | prod)")
+  .option(
+    "--deploy-env <deployEnv>",
+    "Target deploy environment (development-alpha | development-prod)"
+  )
   .option(
     "--payer-kp <path>",
     "Payer keypair: 'config' or custom payer keypair path"
   )
+  .option(
+    "--guardian-kp <path>",
+    "Guardian keypair: 'payer' or custom guardian keypair path"
+  )
   .action(async (options) => {
     const opts = await collectInteractiveOptions(options);
     const parsed = argsSchema.safeParse(opts);

scripts/src/commands/sol/onchain/base-relayer/initialize.handler.ts

@@ -1,7 +1,5 @@
 import { z } from "zod";
 import {
-  createSignerFromKeyPair,
-  generateKeyPair,
   getProgramDerivedAddress,
   devnet,
   type Address,
@@ -23,49 +21,47 @@ import {
   buildAndSendTransaction,
   getSolanaCliConfigKeypairSigner,
   getKeypairSignerFromPath,
-  CONSTANTS,
+  getRelayerIdlConstant,
 } from "@internal/sol";
-import { getRelayerIdlConstant } from "@internal/sol/base-relayer-idl.constants";
+import { CONFIGS, DEPLOY_ENVS } from "@internal/constants";
 
 export const argsSchema = z.object({
-  cluster: z
-    .enum(["devnet"], {
-      message: "Cluster must be either 'devnet'",
+  deployEnv: z
+    .enum(DEPLOY_ENVS, {
+      message:
+        "Deploy environment must be either 'development-alpha' or 'development-prod'",
     })
-    .default("devnet"),
-  release: z
-    .enum(["alpha", "prod"], {
-      message: "Release must be either 'alpha' or 'prod'",
-    })
-    .default("prod"),
+    .default("development-alpha"),
   payerKp: z
     .union([z.literal("config"), z.string().brand<"payerKp">()])
     .default("config"),
+  guardianKp: z
+    .union([z.literal("payer"), z.string().brand<"guardianKp">()])
+    .default("payer"),
 });
 
-type InitializeArgs = z.infer<typeof argsSchema>;
-type PayerKp = z.infer<typeof argsSchema.shape.payerKp>;
+type Args = z.infer<typeof argsSchema>;
+type PayerKpArg = Args["payerKp"];
+type GuardianKpArg = Args["guardianKp"];
 
-export async function handleInitialize(args: InitializeArgs): Promise<void> {
+export async function handleInitialize(args: Args): Promise<void> {
   try {
     logger.info("--- Initialize base-relayer script ---");
 
-    const config = CONSTANTS[args.cluster][args.release];
-    const rpcUrl = devnet(`https://${config.rpcUrl}`);
-    const rpc = createSolanaRpc(rpcUrl);
+    const config = CONFIGS[args.deployEnv];
+    const rpcUrl = devnet(`https://${config.solana.rpcUrl}`);
     logger.info(`RPC URL: ${rpcUrl}`);
 
     const payer = await resolvePayerKeypair(args.payerKp);
     logger.info(`Payer: ${payer.address}`);
 
     const [cfgAddress] = await getProgramDerivedAddress({
-      programAddress: config.baseRelayer,
+      programAddress: config.solana.baseRelayerProgram,
       seeds: [Buffer.from(getRelayerIdlConstant("CFG_SEED"))],
     });
     logger.info(`Cfg PDA: ${cfgAddress}`);
 
-    // TODO: Use the real guardian.
-    const guardian = await createSignerFromKeyPair(await generateKeyPair());
+    const guardian = await resolveGuardianKeypair(args.guardianKp, payer);
 
     const eip1559Config = {
       target: 5_000_000n,
@@ -92,18 +88,22 @@ export async function handleInitialize(args: InitializeArgs): Promise<void> {
         eip1559Config,
         gasConfig,
       },
-      { programAddress: config.baseRelayer }
+      { programAddress: config.solana.baseRelayerProgram }
     );
 
     logger.info("Sending transaction...");
-    const signature = await buildAndSendTransaction(rpcUrl, [ix], payer);
+    const signature = await buildAndSendTransaction(
+      args.deployEnv,
+      [ix],
+      payer
+    );
     logger.success("Base Relayer initialization completed!");
     logger.info(
       `Transaction: https://explorer.solana.com/tx/${signature}?cluster=devnet`
     );
 
     await assertInitialized(
-      rpc,
+      createSolanaRpc(rpcUrl),
       cfgAddress,
       guardian,
       eip1559Config,
@@ -115,14 +115,14 @@ export async function handleInitialize(args: InitializeArgs): Promise<void> {
   }
 }
 
-async function resolvePayerKeypair(payerKp: PayerKp) {
-  if (payerKp === "config") {
+async function resolvePayerKeypair(payerKpArg: PayerKpArg) {
+  if (payerKpArg === "config") {
     logger.info("Using Solana CLI config for payer keypair");
     return await getSolanaCliConfigKeypairSigner();
   }
 
-  logger.info(`Using custom payer keypair: ${payerKp}`);
-  return await getKeypairSignerFromPath(payerKp);
+  logger.info(`Using custom payer keypair: ${payerKpArg}`);
+  return await getKeypairSignerFromPath(payerKpArg);
 }
 
 async function assertInitialized(
@@ -180,3 +180,16 @@ async function assertInitialized(
 
   console.log("Base Relayer config confirmed!");
 }
+
+async function resolveGuardianKeypair(
+  guardianKpArg: GuardianKpArg,
+  payer: KeyPairSigner
+) {
+  if (guardianKpArg === "payer") {
+    logger.info("Using payer as guardian keypair");
+    return payer;
+  }
+
+  logger.info(`Using custom guardian keypair: ${guardianKpArg}`);
+  return await getKeypairSignerFromPath(guardianKpArg);
+}

scripts/src/commands/sol/onchain/bridge/base-to-solana/prove-message.command.ts

@@ -7,8 +7,7 @@ import { argsSchema, handleProveMessage } from "./prove-message.handler";
 import { handleRelayMessage } from "./relay-message.handler";
 
 type CommanderOptions = {
-  cluster?: string;
-  release?: string;
+  deployEnv?: string;
   transactionHash?: string;
   payerKp?: string;
   skipRelay?: boolean;
@@ -19,33 +18,20 @@ async function collectInteractiveOptions(
 ): Promise<CommanderOptions> {
   let opts = { ...options };
 
-  if (!opts.cluster) {
-    const cluster = await select({
-      message: "Select target cluster:",
-      options: [{ value: "devnet", label: "Devnet" }],
-      initialValue: "devnet",
-    });
-    if (isCancel(cluster)) {
-      cancel("Operation cancelled.");
-      process.exit(1);
-    }
-    opts.cluster = cluster;
-  }
-
-  if (!opts.release) {
-    const release = await select({
-      message: "Select release type:",
+  if (!opts.deployEnv) {
+    const deployEnv = await select({
+      message: "Select target deploy environment:",
       options: [
-        { value: "prod", label: "Prod" },
-        { value: "alpha", label: "Alpha" },
+        { value: "development-alpha", label: "Development Alpha" },
+        { value: "development-prod", label: "Development Prod" },
       ],
-      initialValue: "prod",
+      initialValue: "development-alpha",
     });
-    if (isCancel(release)) {
+    if (isCancel(deployEnv)) {
       cancel("Operation cancelled.");
       process.exit(1);
     }
-    opts.release = release;
+    opts.deployEnv = deployEnv;
   }
 
   if (!opts.transactionHash) {
@@ -123,8 +109,10 @@ async function collectInteractiveOptions(
 
 export const proveMessageCommand = new Command("prove-message")
   .description("Prove a message from Base transaction on Solana")
-  .option("--cluster <cluster>", "Target cluster (devnet)")
-  .option("--release <release>", "Release type (alpha | prod)")
+  .option(
+    "--deploy-env <deployEnv>",
+    "Target deploy environment (development-alpha | development-prod)"
+  )
   .option("--transaction-hash <hash>", "Base transaction hash to prove (0x...)")
   .option(
     "--payer-kp <path>",
@@ -147,8 +135,7 @@ export const proveMessageCommand = new Command("prove-message")
     if (!opts.skipRelay) {
       logger.info("Relaying message...");
       await handleRelayMessage({
-        cluster: parsed.data.cluster,
-        release: parsed.data.release,
+        deployEnv: parsed.data.deployEnv,
         messageHash: messageHash as any,
         payerKp: parsed.data.payerKp,
       });