feat: staking commands

packages/commands/src/index.ts

@@ -4,6 +4,7 @@ export * from "./evm";
 export * from "./faucet";
 export * from "./query";
 export * from "./solana";
+export * from "./staking";
 export * from "./sui";
 export * from "./ton";
 export * from "./zetachain";

packages/commands/src/program.ts

@@ -8,6 +8,7 @@ import { evmCommand } from "./evm";
 import { faucetCommand } from "./faucet";
 import { queryCommand } from "./query";
 import { solanaCommand } from "./solana";
+import { stakingCommand } from "./staking";
 import { suiCommand } from "./sui";
 import { tonCommand } from "./ton";
 import { zetachainCommand } from "./zetachain";
@@ -25,7 +26,7 @@ toolkitCommand.addCommand(solanaCommand);
 toolkitCommand.addCommand(suiCommand);
 toolkitCommand.addCommand(tonCommand);
 toolkitCommand.addCommand(zetachainCommand);
-
+toolkitCommand.addCommand(stakingCommand);
 showRequiredOptions(toolkitCommand);
 
 toolkitCommand.parse(process.argv);

packages/commands/src/staking/delegate.ts

@@ -0,0 +1,118 @@
+import { Command, Option } from "commander";
+import { ethers } from "ethers";
+import { z } from "zod";
+
+import { STAKING_PRECOMPILE } from "../../../../src/constants/addresses";
+import { namePkRefineRule } from "../../../../types/shared.schema";
+import { handleError, validateAndParseSchema } from "../../../../utils";
+import type {
+  ConfirmTxOptionsSubset,
+  SetupTxOptionsSubset,
+} from "../../../../utils/zetachain.command.helpers";
+import {
+  confirmZetachainTransaction,
+  setupZetachainTransaction,
+} from "../../../../utils/zetachain.command.helpers";
+import stakingArtifact from "./staking.json";
+
+const STAKING_ABI = (stakingArtifact as { abi: unknown })
+  .abi as ethers.InterfaceAbi;
+
+const delegateOptionsSchema = z
+  .object({
+    amount: z.string(),
+    chainId: z.string().optional(),
+    name: z.string().default("default"),
+    privateKey: z.string().optional(),
+    rpc: z.string().optional(),
+    validator: z.string(),
+    yes: z.boolean().default(false),
+  })
+  .refine(namePkRefineRule);
+
+type DelegateOptions = z.infer<typeof delegateOptionsSchema>;
+
+const main = async (options: DelegateOptions) => {
+  try {
+    const { signer } = setupZetachainTransaction({
+      chainId: options.chainId,
+      name: options.name,
+      privateKey: options.privateKey,
+      rpc: options.rpc,
+    } satisfies SetupTxOptionsSubset);
+
+    const delegatorAddress = await signer.getAddress();
+    const amountWei = ethers.parseEther(options.amount);
+
+    console.log(`Staking delegation details:
+Delegator: ${delegatorAddress}
+Validator: ${options.validator}
+Amount:    ${options.amount} ZETA
+`);
+
+    const isConfirmed = await confirmZetachainTransaction({
+      yes: options.yes,
+    } satisfies ConfirmTxOptionsSubset);
+    if (!isConfirmed) return;
+
+    const iface = new ethers.Interface(STAKING_ABI);
+    const data = iface.encodeFunctionData("delegate", [
+      delegatorAddress,
+      options.validator,
+      amountWei,
+    ]);
+
+    const tx = await signer.sendTransaction({
+      data,
+      to: STAKING_PRECOMPILE,
+      value: amountWei,
+    });
+
+    const receipt = await tx.wait();
+    console.log("Transaction hash:", tx.hash ?? receipt?.hash);
+  } catch (error) {
+    handleError({
+      context: "Error during staking delegation",
+      error,
+      shouldThrow: false,
+    });
+    process.exit(1);
+  }
+};
+
+export const delegateCommand = new Command("delegate").summary(
+  "Delegate ZETA to a validator via the staking precompile"
+);
+
+delegateCommand
+  .addOption(
+    new Option(
+      "--validator <valoper>",
+      "Validator operator address (zetavaloper...)"
+    ).makeOptionMandatory()
+  )
+  .addOption(
+    new Option(
+      "--amount <amount>",
+      "Amount of ZETA to delegate"
+    ).makeOptionMandatory()
+  )
+  .addOption(
+    new Option("--name <name>", "Account name")
+      .default("default")
+      .conflicts(["private-key"])
+  )
+  .addOption(
+    new Option("--private-key <key>", "Private key for signing").conflicts([
+      "name",
+    ])
+  )
+  .addOption(new Option("--rpc <url>", "ZetaChain RPC URL"))
+  .addOption(new Option("--chain-id <id>", "ZetaChain chain ID"))
+  .addOption(new Option("--yes", "Skip confirmation").default(false))
+  .action(async (rawOptions) => {
+    const options = validateAndParseSchema(rawOptions, delegateOptionsSchema, {
+      exitOnError: true,
+    });
+    await main(options);
+  });

packages/commands/src/staking/delegations/index.ts

@@ -0,0 +1,10 @@
+import { Command } from "commander";
+
+import { listCommand } from "./list";
+import { showCommand } from "./show";
+
+export const delegationsCommand = new Command("delegations")
+  .summary("Delegations-related queries")
+  .addCommand(listCommand)
+  .addCommand(showCommand)
+  .helpCommand(false);