diff --git a/src/bin/xpkey/keys.rs b/src/bin/xpkey/keys.rs
index 583b0cc..98cb2df 100644
--- a/src/bin/xpkey/keys.rs
+++ b/src/bin/xpkey/keys.rs
@@ -1,6 +1,35 @@
-use std::collections::HashMap;
+use std::{collections::HashMap, fs::File, io::BufReader, path::Path};
 
+use anyhow::Result;
 use serde::{Deserialize, Serialize};
+use serde_json::{from_reader, from_str};
+
+pub fn load_keys<P: AsRef<Path> + std::fmt::Display>(
+    path: Option<P>,
+    verbose: bool,
+) -> Result<Keys> {
+    let keys = {
+        if let Some(path) = path {
+            if verbose {
+                println!("Loading keys file {}", path);
+            }
+
+            let file = File::open(&path)?;
+            let reader = BufReader::new(file);
+            let keys: Keys = from_reader(reader)?;
+
+            if verbose {
+                println!("Loaded keys from {} successfully", path);
+            }
+
+            keys
+        } else {
+            from_str(std::include_str!("../../../keys.json"))?
+        }
+    };
+
+    Ok(keys)
+}
 
 #[derive(Serialize, Deserialize)]
 pub struct Keys {
diff --git a/src/bin/xpkey/main.rs b/src/bin/xpkey/main.rs
index ff1bed6..84d8d0f 100644
--- a/src/bin/xpkey/main.rs
+++ b/src/bin/xpkey/main.rs
@@ -1,98 +1,56 @@
 mod cli;
 mod keys;
 
-use std::{fs::File, io::BufReader, path::Path};
-
-use anyhow::{anyhow, Result};
+use anyhow::{bail, Result};
 use clap::Parser;
-use keys::{Bink, Keys};
-use serde_json::{from_reader, from_str};
+use keys::Bink;
 
 use umskt::{
     bink1998, bink2002, confid,
     crypto::{EllipticCurve, PrivateKey},
 };
 
-use cli::*;
+use crate::{cli::*, keys::load_keys};
 
 fn main() -> Result<()> {
     let args = Cli::parse();
+    let verbose = args.verbose;
 
     match &args.command {
-        Commands::List(list_args) => {
-            let keys = load_keys(list_args.keys_path.as_ref(), args.verbose)?;
-            for (key, value) in keys.products.iter() {
-                println!("{}: {:?}", key, value.bink);
-            }
+        Commands::List(args) => list(args, verbose),
+        Commands::Generate(args) => generate(args, verbose),
+        Commands::Validate(args) => validate(args, verbose),
+        Commands::ConfirmationId(args) => confirmation_id(&args.instid),
+    }
+}
 
-            println!("\n\n** Please note: any BINK ID other than 2E is considered experimental at this time **\n");
-        }
-        Commands::Generate(generate_args) => {
-            if generate_args.channel_id > 999 {
-                return Err(anyhow!("Channel ID must be 3 digits or fewer"));
-            }
-            let keys = load_keys(generate_args.keys_path.as_ref(), args.verbose)?;
-            generate(
-                &keys,
-                &generate_args.binkid,
-                generate_args.channel_id,
-                generate_args.num_keys,
-                args.verbose,
-            )?;
-        }
-        Commands::Validate(validate_args) => {
-            let keys = load_keys(validate_args.keys_path.as_ref(), args.verbose)?;
-            validate(
-                &keys,
-                &validate_args.binkid,
-                &validate_args.key_to_check,
-                args.verbose,
-            )?;
-        }
-        Commands::ConfirmationId(confirmation_id_args) => {
-            confirmation_id(&confirmation_id_args.instid)?;
-        }
+fn list(args: &ListArgs, verbose: bool) -> Result<()> {
+    let keys = load_keys(args.keys_path.as_ref(), verbose)?;
+    for (key, value) in keys.products.iter() {
+        println!("{}: {:?}", key, value.bink);
     }
 
+    println!("\n\n** Please note: any BINK ID other than 2E is considered experimental at this time **\n");
     Ok(())
 }
 
-fn load_keys<P: AsRef<Path> + std::fmt::Display>(path: Option<P>, verbose: bool) -> Result<Keys> {
-    let keys = {
-        if let Some(path) = path {
-            if verbose {
-                println!("Loading keys file {}", path);
-            }
+fn generate(args: &GenerateArgs, verbose: bool) -> Result<()> {
+    if args.channel_id > 999 {
+        bail!("Channel ID must be 3 digits or fewer");
+    }
 
-            let file = File::open(&path)?;
-            let reader = BufReader::new(file);
-            let keys: Keys = from_reader(reader)?;
+    let keys = load_keys(args.keys_path.as_ref(), verbose)?;
 
-            if verbose {
-                println!("Loaded keys from {} successfully", path);
-            }
-
-            keys
-        } else {
-            from_str(std::include_str!("../../../keys.json"))?
-        }
-    };
-
-    Ok(keys)
-}
-
-fn generate(keys: &Keys, bink_id: &str, channel_id: u32, count: u64, verbose: bool) -> Result<()> {
-    let bink_id = bink_id.to_ascii_uppercase();
+    let bink_id = args.bink_id.to_ascii_uppercase();
     let bink = &keys.bink[&bink_id];
 
+    // gen_order is the order of the generator G, a value we have to reverse -> Schoof's Algorithm.
+    let gen_order = &bink.n;
+
     // We cannot produce a valid key without knowing the private key k. The reason for this is that
     // we need the result of the function K(x; y) = kG(x; y).
     let private_key = &bink.private;
 
-    // We can, however, validate any given key using the available public key: {p, a, b, G, K}.
-    // genOrder the order of the generator G, a value we have to reverse -> Schoof's Algorithm.
-    let gen_order = &bink.n;
-
     let curve = initialize_curve(bink, &bink_id, verbose)?;
     if verbose {
         println!(" n: {gen_order}");
@@ -102,23 +60,26 @@ fn generate(keys: &Keys, bink_id: &str, channel_id: u32, count: u64, verbose: bo
     let private_key = PrivateKey::new(gen_order, private_key)?;
 
     if u32::from_str_radix(&bink_id, 16)? < 0x40 {
-        bink1998_generate(&curve, &private_key, channel_id, count, verbose)?;
+        bink1998_generate(&curve, &private_key, args.channel_id, args.count, verbose)?;
     } else {
-        bink2002_generate(&curve, &private_key, channel_id, count, verbose)?;
+        bink2002_generate(&curve, &private_key, args.channel_id, args.count, verbose)?;
     }
 
     Ok(())
 }
 
-fn validate(keys: &Keys, bink_id: &str, key: &str, verbose: bool) -> Result<()> {
-    let bink_id = bink_id.to_ascii_uppercase();
+fn validate(args: &ValidateArgs, verbose: bool) -> Result<()> {
+    // We can validate any given key using the available public key: {p, a, b, G, K}.
+    // No private key or gen_order is required.
+    let keys = load_keys(args.keys_path.as_ref(), verbose)?;
+    let bink_id = args.bink_id.to_ascii_uppercase();
     let bink = &keys.bink[&bink_id];
     let curve = initialize_curve(bink, &bink_id, verbose)?;
 
     if u32::from_str_radix(&bink_id, 16)? < 0x40 {
-        bink1998_validate(&curve, key, verbose)?;
+        bink1998_validate(&curve, &args.key_to_check, verbose)?;
     } else {
-        bink2002_validate(&curve, key, verbose)?;
+        bink2002_validate(&curve, &args.key_to_check, verbose)?;
     }
 
     Ok(())