more features

Author: sungoki

src/cli.rs

@@ -34,14 +34,21 @@ pub enum SubCommand {
         #[clap(default_value = "1")]
         amount: String,
     },
-    /// Requests an airdrop of SOL from the Solana network.
+    /// Transfers SOL from a wallet.
     Transfer {
         /// Cluster to transfer tokens on.
         #[clap(short, long)]
         #[clap(default_value = "devnet")]
         cluster: Cluster,
 
+        /// Who to transfer from. Defaults to the upgrade authority ("upgrader").
+        #[clap(short, long)]
+        #[clap(default_value = "upgrader")]
+        #[clap(possible_value("upgrader"), possible_value("deployer"))]
+        from: String,
+
         /// Who to transfer to. Defaults to the deployer of the network.
+        #[clap(short, long)]
         #[clap(default_value = "deployer")]
         to: String,
 
@@ -150,10 +157,11 @@ impl Opts {
             }
             SubCommand::Transfer {
                 cluster,
+                from,
                 to,
                 amount,
             } => {
-                subcommands::transfer::process(&workspace, cluster, &to, &amount)?;
+                subcommands::transfer::process(&workspace, &cluster, &from, &to, &amount)?;
             }
             SubCommand::UploadProgramBuffer {
                 cluster,

src/subcommands/transfer.rs

@@ -2,12 +2,18 @@ use crate::workspace::Workspace;
 use anchor_client::Cluster;
 use anyhow::Result;
 
-pub fn process(workspace: &Workspace, cluster: Cluster, to_raw: &str, amount: &str) -> Result<()> {
-    let ctx = workspace.new_upgrader_context(&cluster);
-    let to = match to_raw {
-        "deployer" => ctx.get_deployer_kp_path().display().to_string(),
-        _ => to_raw.to_string(),
-    };
-    ctx.exec_args(&["transfer", &to, amount])?;
+pub fn process(
+    workspace: &Workspace,
+    cluster: &Cluster,
+    from_raw: &str,
+    to_raw: &str,
+    amount: &str,
+) -> Result<()> {
+    let ctx = workspace.new_cluster_context(cluster)?;
+    let to = ctx.parse_wallet_alias(to_raw)?;
+    ctx.exec_args(
+        &["transfer", &to, amount],
+        &ctx.parse_wallet_alias(from_raw)?,
+    )?;
     Ok(())
 }

src/workspace.rs

@@ -85,53 +85,61 @@ impl Workspace {
         })
     }
 
-    /// New [CommandContext] using the configured upgrade authority keypair.
-    pub fn new_upgrader_context<'a, 'b>(&'a self, cluster: &'b Cluster) -> CommandContext<'a, 'b> {
-        let keypair_path = self.cfg.upgrade_authority_keypair.clone().unwrap();
-        CommandContext {
+    /// The upgrader.
+    pub fn get_upgrader_wallet(&self) -> Result<String> {
+        self.cfg
+            .upgrade_authority_keypair
+            .clone()
+            .ok_or_else(|| format_err!("upgrade_authority_keypair not found in Goki.toml"))
+    }
+
+    /// New [CommandContext] using the specified cluster.
+    pub fn new_cluster_context<'a, 'b>(
+        &'a self,
+        cluster: &'b Cluster,
+    ) -> Result<CommandContext<'a, 'b>> {
+        Ok(CommandContext {
             workspace: self,
             cluster,
-            keypair_path,
-        }
+        })
     }
 }
 
 pub struct CommandContext<'a, 'b> {
     pub workspace: &'a Workspace,
     pub cluster: &'b Cluster,
-    pub keypair_path: String,
 }
 
 impl<'a, 'b> CommandContext<'a, 'b> {
-    fn add_cluster_args(&self, command: &mut Command) -> Result<()> {
+    fn add_cluster_args(&self, command: &mut Command, wallet: &str) -> Result<()> {
         command
             .args([
                 "--url",
                 self.workspace.get_cluster_url(self.cluster)?,
                 "--keypair",
             ])
-            .arg(&self.keypair_path);
+            .arg(wallet);
         Ok(())
     }
 
     /// Executes a command.
-    pub fn exec_command<F>(&self, mut builder: F) -> Result<Output>
+    pub fn exec_command<F>(&self, mut builder: F, wallet: &str) -> Result<Output>
     where
         F: FnMut(&mut Command) -> Result<()>,
     {
         let cmd = &mut new_solana_cmd();
-        self.add_cluster_args(cmd)?;
+        self.add_cluster_args(cmd, wallet)?;
         builder(cmd)?;
         exec_command(cmd)
     }
 
     /// Executes a command.
-    pub fn exec_args<S>(&self, args: &[S]) -> Result<Output>
+    pub fn exec_args<S>(&self, args: &[S], wallet: &str) -> Result<Output>
     where
         S: AsRef<OsStr>,
     {
         let cmd = &mut new_solana_cmd();
-        self.add_cluster_args(cmd)?;
+        self.add_cluster_args(cmd, wallet)?;
         args.iter().for_each(|arg| {
             cmd.arg(arg.as_ref());
         });
@@ -141,4 +149,13 @@ impl<'a, 'b> CommandContext<'a, 'b> {
     pub fn get_deployer_kp_path(&self) -> PathBuf {
         self.workspace.get_deployer_kp_path(self.cluster)
     }
+
+    pub fn parse_wallet_alias(&self, alias: &str) -> Result<String> {
+        let result = match alias {
+            "deployer" => Ok(self.get_deployer_kp_path().display().to_string()),
+            "upgrader" => self.workspace.get_upgrader_wallet(),
+            _ => Ok(alias.to_string()),
+        };
+        result.map_err(|err| format_err!("could not parse alias {}: {}", alias, err))
+    }
 }