feat: more output formats

Author: PoolPirate

.editorconfig

@@ -1,6 +1,11 @@
 # Remove the line below if you want to inherit .editorconfig settings from higher directories
 root = true
 
+[*]
+
+# New line preferences
+end_of_line = lf
+
 # C# files
 [*.cs]
 
@@ -12,8 +17,7 @@ indent_style = space
 tab_width = 4
 
 # New line preferences
-end_of_line = crlf
-insert_final_newline = false
+insert_final_newline = true
 
 #### .NET Code Actions ####
 

.gitattributes

@@ -1,7 +1,7 @@
 ###############################################################################
 # Set default behavior to automatically normalize line endings.
 ###############################################################################
-* text=auto
+* text=auto eol=lf
 
 ###############################################################################
 # Set default behavior for command prompt diff.

README.md

@@ -34,27 +34,41 @@ dotnet publish -c Release -r linux-x64 --self-contained true -o artifacts/publis
 ### Derive for a supported chain
 
 ```bash
-keyutils derive-chain \
+keyutils derive solana \
   --mnemonic-file mnemonic.txt \
-  --type Evm \
+  --format base58 \
   --output key.txt
 ```
 
-Supported chain types: `Evm`, `Solana`, `Cosmos`
+Supported chain commands: `solana`, `evm`, `cosmos`
 
 `--account-index` is optional and defaults to `0`.
 
+`derive solana` defaults to `--format base58`.
+
+`derive evm` and `derive cosmos` only support `--format hex`.
+
 ### Derive with custom path
 
 ```bash
-keyutils derive-path \
+keyutils derive-path ed25519 \
   --mnemonic-file mnemonic.txt \
-  --path "m/44'/60'/0'/0/0" \
-  --curve Secp256k1 \
+  --path "m/44'/501'/0'/0'/0'" \
+  --format hex \
   --output key.txt
 ```
 
-Supported curves: `Secp256k1`, `Ed25519`
+Supported path subcommands: `ed25519`, `secp256k1`
+
+`derive-path ed25519` supports `hex`, `base58`, and `json`.
+
+`derive-path secp256k1` only supports `hex`.
+
+Format meanings:
+
+- `hex`: raw 32-byte private key as lowercase hex
+- `base58`: Ed25519 64-byte keypair encoded for Solana/Rust `Keypair::from_base58_string(...)`
+- `json`: Ed25519 64-byte keypair as a JSON byte array
 
 ## How It Works
 

src/Cli/CliRootCommand.cs

@@ -1,13 +1,13 @@
-using KeyUtils.Cli.Derive;
+using KeyUtils.Cli.Derive;
 using System.CommandLine;
 
 namespace KeyUtils.Cli;
 
 public class CliRootCommand : RootCommand
 {
-    public CliRootCommand(DeriveChainCommand deriveChainCommand, DerivePathCommand derivePathCommand) : base()
+    public CliRootCommand(DeriveCommand deriveCommand, DerivePathCommand derivePathCommand) : base()
     {
-        Add(deriveChainCommand);
+        Add(deriveCommand);
         Add(derivePathCommand);
     }
 }

src/Cli/Derive/ChainType.cs

@@ -0,0 +1,104 @@
+using Keysmith.Net.BIP;
+using Keysmith.Net.EC;
+using Keysmith.Net.ED;
+using System.CommandLine;
+
+namespace KeyUtils.Cli.Derive;
+
+public sealed class DeriveCommand : Command
+{
+    public DeriveCommand() : base("derive", "derive a key for a supported chain")
+    {
+        Add(new DeriveChainLeafCommand(
+            "solana",
+            "derive a Solana key",
+            BIP44.Solana,
+            ED25519.Instance,
+            [OutputFormat.Hex, OutputFormat.Base58, OutputFormat.Json],
+            OutputFormat.Base58));
+
+        Add(new DeriveChainLeafCommand(
+            "evm",
+            "derive an EVM key",
+            accountIndex => BIP44.Ethereum((uint) accountIndex),
+            Secp256k1.Instance,
+            [OutputFormat.Hex],
+            OutputFormat.Hex));
+
+        Add(new DeriveChainLeafCommand(
+            "cosmos",
+            "derive a Cosmos key",
+            BIP44.Cosmos,
+            Secp256k1.Instance,
+            [OutputFormat.Hex],
+            OutputFormat.Hex));
+    }
+
+    private sealed class DeriveChainLeafCommand : Command
+    {
+        private readonly Func<int, string> _pathFactory;
+        private readonly ECCurve _curve;
+        private readonly OutputFormat[] _supportedFormats;
+
+        private readonly Option<FileInfo> _mnemonicFileOption = new("--mnemonic-file", "-i")
+        {
+            Description = "Path to the file containing the mnemonic",
+            Required = true
+        };
+
+        private readonly Option<int> _accountIndexOption = new("--account-index")
+        {
+            Description = "The account index to derive",
+            DefaultValueFactory = _ => 0
+        };
+
+        private readonly Option<string> _formatOption;
+
+        private readonly Option<FileInfo?> _outputOption = new("--output", "-o")
+        {
+            Description = "Path to the file where the derived key will be saved"
+        };
+
+        public DeriveChainLeafCommand(
+            string name,
+            string description,
+            Func<int, string> pathFactory,
+            ECCurve curve,
+            OutputFormat[] supportedFormats,
+            OutputFormat defaultFormat) : base(name, description)
+        {
+            _pathFactory = pathFactory;
+            _curve = curve;
+            _supportedFormats = supportedFormats;
+            _formatOption = new Option<string>("--format", "-f")
+            {
+                Description = $"Output format ({OutputFormatExtensions.Describe(supportedFormats)}). Defaults to {defaultFormat.ToCliValue()}",
+                DefaultValueFactory = _ => defaultFormat.ToCliValue()
+            };
+            _formatOption.AcceptOnlyFromAmong([.. supportedFormats.Select(format => format.ToCliValue())]);
+
+            Add(_mnemonicFileOption);
+            Add(_accountIndexOption);
+            Add(_formatOption);
+            Add(_outputOption);
+
+            SetAction(Handle);
+        }
+
+        private Task<int> Handle(ParseResult parseResult)
+        {
+            var mnemonicFile = parseResult.GetValue(_mnemonicFileOption)!;
+            int accountIndex = parseResult.GetValue(_accountIndexOption);
+            string formatText = parseResult.GetValue(_formatOption)!;
+            var outputFile = parseResult.GetValue(_outputOption);
+
+            if(!OutputFormatExtensions.TryParse(formatText, out var format) || !_supportedFormats.Contains(format))
+            {
+                Console.WriteLine($"Error: Unsupported format '{formatText}'. Supported formats: {OutputFormatExtensions.Describe(_supportedFormats)}");
+                return Task.FromResult(1);
+            }
+
+            return DeriveKeySupport.DeriveAsync(mnemonicFile, _pathFactory(accountIndex), _curve, format, outputFile);
+        }
+    }
+}