cli: add svm deploy-program command

Author: kcsongor

cli/src/__tests__/cli-help.test.ts

@@ -52,6 +52,7 @@ const SOLANA_SUBCOMMANDS = [
   "ata",
   "create-spl-multisig",
   "build",
+  "deploy-program",
 ];
 
 const CONFIG_SUBCOMMANDS = ["set-chain", "unset-chain", "get-chain"];
@@ -150,6 +151,8 @@ describe("Command-specific options", () => {
     expect(stdout).toContain("--token");
     expect(stdout).toContain("--latest");
     expect(stdout).toContain("--skip-verify");
+    expect(stdout).toContain("--deploy-program");
+    expect(stdout).toContain("--instance-of");
   });
 
   it("push shows --yes option", async () => {

cli/src/commands/add-chain.ts

@@ -74,9 +74,15 @@ export function createAddChainCommand(
         })
         .option("instance-of", {
           describe:
-            "(SVM v4 only) Skip program deploy and create a new instance under the existing program at this address. Mutually exclusive with --binary/--program-key.",
+            "(SVM v4 only) Skip program deploy and create a new instance under the existing program at this address. Mutually exclusive with --deploy-program/--binary/--program-key.",
           type: "string" as const,
         })
+        .option("deploy-program", {
+          describe:
+            "(SVM) Deploy a fresh program AND create the first instance under it. One of --deploy-program or --instance-of is required for Solana. For v4+ the recommended flow is to first run `ntt solana deploy-program` and then `add-chain --instance-of <programId>`.",
+          type: "boolean" as const,
+          default: false,
+        })
         .option("instance-key", {
           describe:
             "(SVM v4 only) Path to the keypair file to use as the Instance account. Defaults to a freshly-generated keypair (written to `<chain>-instance.json` in the deployment dir).",
@@ -303,6 +309,38 @@ export function createAddChainCommand(
       // v4 multi-host path: --instance-of <programId> creates a fresh Instance
       // under the existing program rather than deploying a new one.
       const instanceOf = argv["instance-of"] as string | undefined;
+      const deployProgramFlag = Boolean(argv["deploy-program"]);
+
+      if (platform === "Solana") {
+        if (!instanceOf && !deployProgramFlag) {
+          console.error(
+            colors.red(
+              "Solana add-chain now requires one of:\n" +
+                "  --deploy-program           deploy a fresh program AND create the first instance under it.\n" +
+                "  --instance-of <programId>  create an instance under an existing program (v4+).\n" +
+                "\n" +
+                "For v4+ the recommended flow is two steps:\n" +
+                "  1. ntt solana deploy-program <chain> --payer <payer.json> [--ver <version> | --latest]\n" +
+                "  2. ntt add-chain <chain> --instance-of <programId> --token <mint> --mode <locking|burning> --payer <payer.json>"
+            )
+          );
+          process.exit(1);
+        }
+        if (instanceOf && deployProgramFlag) {
+          console.error(
+            colors.red(
+              "--instance-of and --deploy-program are mutually exclusive"
+            )
+          );
+          process.exit(1);
+        }
+      } else if (deployProgramFlag) {
+        console.error(
+          colors.red("--deploy-program is only supported on Solana")
+        );
+        process.exit(1);
+      }
+
       if (instanceOf !== undefined) {
         if (platform !== "Solana") {
           console.error(

cli/src/commands/solana.ts

@@ -37,6 +37,7 @@ import {
   askForConfirmation,
   buildSvm,
   createWorkTree,
+  uploadSolanaProgram,
 } from "../index";
 
 export function createSolanaCommand(
@@ -400,6 +401,114 @@ export function createSolanaCommand(
             console.log(`Keypair: ${buildResult.programKeypairPath}`);
           }
         )
+        .command(
+          "deploy-program <chain>",
+          "build (or reuse) and upload the SVM program binary, without initializing an instance",
+          (yargs: any) =>
+            yargs
+              .positional("chain", options.chain)
+              .option("network", options.network)
+              .option("payer", { ...options.payer, demandOption: true })
+              .option("program-key", {
+                describe: "Path to program key json",
+                type: "string",
+              })
+              .option("binary", {
+                describe:
+                  "Path to pre-built program binary (.so file); skips build if provided",
+                type: "string",
+              })
+              .option("solana-priority-fee", {
+                describe: "Priority fee for SVM deployment (in microlamports)",
+                type: "number",
+                default: 50000,
+              })
+              .option("ver", options.version)
+              .option("latest", options.latest)
+              .option("local", options.local)
+              .example(
+                "$0 svm deploy-program Solana --network Mainnet --latest --payer ./payer.json",
+                "Build and deploy the latest program; no instance is created"
+              )
+              .example(
+                "$0 svm deploy-program Solana --network Mainnet --ver 4.0.0 --payer ./payer.json --program-key ./prog-keypair.json",
+                "Deploy a specific version with a chosen program keypair (run `ntt add-chain Solana --instance-of <programId>` next)"
+              ),
+          async (argv: any) => {
+            const chain: Chain = argv["chain"];
+            const network = argv["network"] as Network;
+
+            const platform = chainToPlatform(chain);
+            if (platform !== "Solana") {
+              console.error(
+                `deploy-program is only supported for Solana chains. Got platform: ${platform}`
+              );
+              process.exit(1);
+            }
+
+            validateChain(network, chain);
+
+            const payerPath = validatePayerOption(
+              argv["payer"],
+              chain,
+              (m) => new Error(m),
+              (m) => console.warn(colors.yellow(m))
+            );
+            if (!payerPath) {
+              console.error("Payer not found. Specify with --payer");
+              process.exit(1);
+            }
+
+            const version = resolveVersion(
+              argv["latest"],
+              argv["ver"],
+              argv["local"],
+              platform
+            );
+
+            const worktree = version ? createWorkTree(platform, version) : ".";
+
+            const wh = new Wormhole(
+              network,
+              [solana.Platform, evm.Platform, sui.Platform],
+              overrides
+            );
+            const ch = wh.getChain(chain);
+            const wormhole = ch.config.contracts.coreBridge;
+            if (!wormhole) {
+              console.error("Core bridge not found");
+              process.exit(1);
+            }
+
+            console.log(`Building SVM program for ${chain} on ${network}...`);
+            const { binary, programId, programKeypairPath } = await buildSvm(
+              worktree,
+              network,
+              chain,
+              wormhole,
+              version,
+              argv["program-key"],
+              argv["binary"],
+              overrides
+            );
+
+            console.log(
+              `Deploying program ${programId} to ${chain} ${network}...`
+            );
+            await uploadSolanaProgram({
+              binary,
+              programKeypairPath,
+              payerPath,
+              rpc: ch.config.rpc,
+              priorityFee: argv["solana-priority-fee"],
+            });
+
+            console.log(`Deployed program: ${colors.green(programId)}`);
+            console.log(
+              `Next: \`ntt add-chain ${chain} --instance-of ${programId} --token <mint> --mode <locking|burning> --payer ${payerPath}\``
+            );
+          }
+        )
         .demandCommand();
     },
     handler: (_argv: any) => {},

cli/src/index.ts

@@ -116,7 +116,7 @@ export { parseCclFlag, confirmCustomFinality } from "./commands/shared";
 export { deploy, upgrade } from "./deploy";
 
 // Re-exports from solana/deploy.ts
-export { buildSvm } from "./solana/deploy";
+export { buildSvm, uploadSolanaProgram } from "./solana/deploy";
 
 // Re-exports from config-mgmt.ts
 export {

cli/src/solana/deploy.ts

@@ -270,6 +270,69 @@ export async function buildSvm(
   };
 }
 
+/**
+ * Upload a built program binary via `solana program deploy`.
+ *
+ * Manages a `buffer.json` keypair in the current directory so an interrupted
+ * deploy can be resumed: the helper creates `buffer.json` if it's missing,
+ * prompts the user when an existing one is found (so they can decide whether
+ * to resume or delete it), and removes it only after a successful upload.
+ *
+ * Calls `process.exit` on non-zero exit from `solana program deploy` so
+ * callers don't have to thread the failure back themselves.
+ */
+export async function uploadSolanaProgram(args: {
+  binary: string;
+  programKeypairPath: string;
+  payerPath: string;
+  rpc: string;
+  priorityFee?: number;
+}): Promise<void> {
+  if (!fs.existsSync(`buffer.json`)) {
+    execSync(`solana-keygen new -o buffer.json --no-bip39-passphrase`);
+  } else {
+    console.info("buffer.json already exists.");
+    await askForConfirmation(
+      "Do you want continue an exiting deployment? If not, delete the buffer.json file and run the command again."
+    );
+  }
+
+  const deployCommand = [
+    "solana",
+    "program",
+    "deploy",
+    "--program-id",
+    args.programKeypairPath,
+    "--buffer",
+    `buffer.json`,
+    args.binary,
+    "--keypair",
+    args.payerPath,
+    "-u",
+    args.rpc,
+    "--commitment",
+    "finalized",
+  ];
+
+  if (args.priorityFee !== undefined) {
+    deployCommand.push(
+      "--with-compute-unit-price",
+      args.priorityFee.toString()
+    );
+  }
+
+  const deployProc = Bun.spawn(deployCommand);
+  const out = await new Response(deployProc.stdout).text();
+  await deployProc.exited;
+
+  if (deployProc.exitCode !== 0) {
+    process.exit(deployProc.exitCode ?? 1);
+  }
+
+  fs.unlinkSync("buffer.json");
+  console.log(out);
+}
+
 export async function deploySvm<N extends Network, C extends SolanaChains>(
   pwd: string,
   version: string | null,
@@ -437,55 +500,13 @@ export async function deploySvm<N extends Network, C extends SolanaChains>(
   }
 
   // Deploy the binary (patching was already done during build for legacy builds on non-Solana chains)
-  const skipDeploy = false;
-
-  if (!skipDeploy) {
-    // if buffer.json doesn't exist, create it
-    if (!fs.existsSync(`buffer.json`)) {
-      execSync(`solana-keygen new -o buffer.json --no-bip39-passphrase`);
-    } else {
-      console.info("buffer.json already exists.");
-      await askForConfirmation(
-        "Do you want continue an exiting deployment? If not, delete the buffer.json file and run the command again."
-      );
-    }
-
-    const deployCommand = [
-      "solana",
-      "program",
-      "deploy",
-      "--program-id",
-      programKeypairPath,
-      "--buffer",
-      `buffer.json`,
-      binary,
-      "--keypair",
-      payer,
-      "-u",
-      ch.config.rpc,
-      "--commitment",
-      "finalized",
-    ];
-
-    if (priorityFee !== undefined) {
-      deployCommand.push("--with-compute-unit-price", priorityFee.toString());
-    }
-
-    const deployProc = Bun.spawn(deployCommand);
-
-    const out = await new Response(deployProc.stdout).text();
-
-    await deployProc.exited;
-
-    if (deployProc.exitCode !== 0) {
-      process.exit(deployProc.exitCode ?? 1);
-    }
-
-    // success. remove buffer.json
-    fs.unlinkSync("buffer.json");
-
-    console.log(out);
-  }
+  await uploadSolanaProgram({
+    binary,
+    programKeypairPath,
+    payerPath: payer,
+    rpc: ch.config.rpc,
+    priorityFee,
+  });
 
   if (initialize) {
     // wait 3 seconds