Master (#1262)

* clear * feat: Add everything * fix: Commenht
2026-08-02 17:31:39 +00:00 · 2025-10-03 14:45:52 -04:00
parent 43b4a11c06
commit 13e6c3e84d
1935 changed files with 655061 additions and 40058 deletions
@@ -0,0 +1,141 @@
+// Package commands contains utility functions for the snrd command
+package commands
+
+import (
+	"crypto/rand"
+	"crypto/sha256"
+	"encoding/json"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+
+	genutilcli "github.com/cosmos/cosmos-sdk/x/genutil/client/cli"
+	genutiltypes "github.com/cosmos/cosmos-sdk/x/genutil/types"
+	"github.com/sonr-io/sonr/app"
+	"github.com/sonr-io/sonr/crypto/vrf"
+	"github.com/spf13/cobra"
+)
+
+func EnhancedInit(chainApp *app.ChainApp) *cobra.Command {
+	baseCmd := genutilcli.InitCmd(chainApp.BasicModuleManager, app.DefaultNodeHome)
+	baseCmd.PostRunE = handleInitPostE
+	return baseCmd
+}
+
+// handleInitPostE generates VRF keypair and stores it securely after chain initialization
+func handleInitPostE(cmd *cobra.Command, args []string) error {
+	// Extract chain-id from genesis file for network-aware key generation
+	chainID, err := getChainIDFromGenesis()
+	if err != nil {
+		return fmt.Errorf("failed to get chain-id: %w", err)
+	}
+
+	// Create deterministic entropy source from chainID
+	entropySource, err := createChainIDEntropySource(chainID)
+	if err != nil {
+		return fmt.Errorf("failed to create entropy source: %w", err)
+	}
+
+	// Generate VRF keypair using chainID-derived entropy
+	privateKey, err := vrf.GenerateKey(entropySource)
+	if err != nil {
+		return fmt.Errorf("failed to generate VRF keypair: %w", err)
+	}
+
+	// Validate the generated keypair
+	if len(privateKey) != vrf.PrivateKeySize {
+		return fmt.Errorf(
+			"invalid VRF private key size: expected %d, got %d",
+			vrf.PrivateKeySize,
+			len(privateKey),
+		)
+	}
+
+	// Get public key to validate keypair
+	_, ok := privateKey.Public()
+	if !ok {
+		return fmt.Errorf("failed to derive public key from VRF private key")
+	}
+
+	// Create secure storage path
+	vrfKeyPath := filepath.Join(app.DefaultNodeHome, "vrf_secret.key")
+
+	// Ensure directory exists with proper permissions
+	if err := os.MkdirAll(app.DefaultNodeHome, 0o750); err != nil {
+		return fmt.Errorf("failed to create node home directory: %w", err)
+	}
+
+	// Store VRF secret key with restrictive permissions (owner read/write only)
+	if err := os.WriteFile(vrfKeyPath, privateKey, 0o600); err != nil {
+		return fmt.Errorf("failed to save VRF secret key: %w", err)
+	}
+
+	fmt.Printf("✓ VRF keypair generated for network: %s\n", chainID)
+	fmt.Printf("✓ VRF secret key stored securely: %s\n", vrfKeyPath)
+	return nil
+}
+
+// getChainIDFromGenesis extracts chain-id from the genesis file
+func getChainIDFromGenesis() (string, error) {
+	genesisPath := filepath.Join(app.DefaultNodeHome, "config", "genesis.json")
+
+	// #nosec G304 - genesisPath is constructed from trusted app.DefaultNodeHome constant
+	genesisData, err := os.ReadFile(genesisPath)
+	if err != nil {
+		return "", fmt.Errorf("failed to read genesis file: %w", err)
+	}
+
+	var genesis genutiltypes.AppGenesis
+	if err := json.Unmarshal(genesisData, &genesis); err != nil {
+		return "", fmt.Errorf("failed to parse genesis file: %w", err)
+	}
+
+	if genesis.ChainID == "" {
+		return "", fmt.Errorf("chain-id not found in genesis file")
+	}
+
+	return genesis.ChainID, nil
+}
+
+// entropyReader implements io.Reader to provide deterministic entropy from chainID
+type entropyReader struct {
+	seed []byte
+	pos  int
+}
+
+func (e *entropyReader) Read(p []byte) (int, error) {
+	n := 0
+	for n < len(p) && e.pos < len(e.seed) {
+		p[n] = e.seed[e.pos]
+		n++
+		e.pos++
+	}
+
+	// If we need more bytes than available in seed, use crypto/rand for additional randomness
+	if n < len(p) {
+		remaining, err := rand.Read(p[n:])
+		if err != nil {
+			return n, err
+		}
+		n += remaining
+	}
+
+	return n, nil
+}
+
+// createChainIDEntropySource creates a deterministic entropy source from chainID
+// This provides network-specific but still secure randomness for VRF key generation
+func createChainIDEntropySource(chainID string) (io.Reader, error) {
+	if chainID == "" {
+		return nil, fmt.Errorf("chainID cannot be empty")
+	}
+
+	// Create deterministic seed from chainID using SHA256
+	hash := sha256.Sum256([]byte(chainID))
+
+	return &entropyReader{
+		seed: hash[:],
+		pos:  0,
+	}, nil
+}
@@ -0,0 +1,202 @@
+package commands
+
+import (
+	"crypto/sha256"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"time"
+
+	"github.com/spf13/cobra"
+
+	"github.com/cosmos/cosmos-sdk/client"
+	"github.com/cosmos/cosmos-sdk/client/flags"
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
+)
+
+func GovCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "gov",
+		Short: "Governance utilities",
+		Long:  `Utilities for governance operations and compliance.`,
+	}
+
+	cmd.AddCommand(DunaAmendmentCmd())
+	return cmd
+}
+
+func DunaAmendmentCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "duna-amendment",
+		Short: "Generate Wyoming DAO compliance filing content",
+		Long: `Extract governance identifiers and generate Wyoming DAO LC amendment filing content
+for compliance with Wyoming Statute 17-31-106(b).`,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			clientCtx, err := client.GetClientQueryContext(cmd)
+			if err != nil {
+				return err
+			}
+
+			// Use the hardcoded ChainID from app.go
+			chainID := "sonrtest_1-1"
+			// Allow override from client context if set
+			if clientCtx.ChainID != "" {
+				chainID = clientCtx.ChainID
+			}
+
+			saveToFile, _ := cmd.Flags().GetBool("output-files")
+
+			fmt.Printf(
+				"🏛️  Wyoming DAO compliance check for Decentralized Identity DAO LC (diDAO)\n\n",
+			)
+
+			// Get governance address
+			govAddress, err := getGovernanceAddress(clientCtx)
+			if err != nil {
+				return fmt.Errorf("failed to get governance address: %w", err)
+			}
+			fmt.Printf("✓ Governance module address: %s\n", govAddress)
+
+			// Get genesis hash
+			genesisHash, err := getGenesisHash(clientCtx.HomeDir)
+			if err != nil {
+				fmt.Printf("⚠️  Warning: Could not calculate genesis hash: %v\n", err)
+				genesisHash = fmt.Sprintf(
+					"Genesis file location: %s/config/genesis.json",
+					clientCtx.HomeDir,
+				)
+			} else {
+				fmt.Printf("✓ Genesis hash: %s\n", genesisHash)
+			}
+
+			// Generate and output filing content
+			filingContent, amendmentText := generateWyomingContent(govAddress, chainID, genesisHash)
+
+			if saveToFile {
+				err = saveWyomingFiles(filingContent, amendmentText)
+				if err != nil {
+					return fmt.Errorf("failed to save Wyoming filing content: %w", err)
+				}
+				fmt.Printf("✓ Wyoming filing content generated: wyoming_amendment_content.txt\n")
+				fmt.Printf("✓ Article VI amendment text: article_vi_amendment.txt\n")
+			} else {
+				fmt.Printf("%s", "\n"+filingContent+"\n")
+			}
+
+			fmt.Printf("\n✅ Wyoming compliance identifiers ready!\n\n")
+			fmt.Printf("Key Information:\n")
+			fmt.Printf("- Governance Address: %s\n", govAddress)
+			fmt.Printf("- Chain ID: %s\n", chainID)
+			fmt.Printf("- Genesis Hash: %s\n", genesisHash)
+
+			if saveToFile {
+				fmt.Printf("\nNext Steps:\n")
+				fmt.Printf("1. Review: wyoming_amendment_content.txt\n")
+				fmt.Printf("2. File online at: https://wyobiz.wy.gov\n")
+				fmt.Printf("3. Pay $60 fee and submit\n")
+			} else {
+				fmt.Printf("\nUse --output-files flag to save content to files.\n")
+			}
+
+			return nil
+		},
+	}
+
+	flags.AddQueryFlagsToCmd(cmd)
+	cmd.Flags().
+		Bool("output-files", false, "Save filing content to files instead of printing to stdout")
+	return cmd
+}
+
+func getGovernanceAddress(clientCtx client.Context) (string, error) {
+	queryClient := authtypes.NewQueryClient(clientCtx)
+
+	res, err := queryClient.ModuleAccounts(
+		clientCtx.CmdContext,
+		&authtypes.QueryModuleAccountsRequest{},
+	)
+	if err != nil {
+		return "", err
+	}
+
+	// Find the governance module account
+	for _, account := range res.Accounts {
+		var acc sdk.AccountI
+		if err := clientCtx.InterfaceRegistry.UnpackAny(account, &acc); err != nil {
+			continue
+		}
+
+		if modAcc, ok := acc.(sdk.ModuleAccountI); ok {
+			if modAcc.GetName() == "gov" {
+				return acc.GetAddress().String(), nil
+			}
+		}
+	}
+
+	return "", fmt.Errorf("governance module account not found")
+}
+
+func getGenesisHash(homeDir string) (string, error) {
+	genesisPath := filepath.Join(homeDir, "config", "genesis.json")
+
+	file, err := os.Open(genesisPath)
+	if err != nil {
+		return "", err
+	}
+	defer file.Close()
+
+	hash := sha256.New()
+	if _, err := io.Copy(hash, file); err != nil {
+		return "", err
+	}
+
+	return fmt.Sprintf("%x", hash.Sum(nil)), nil
+}
+
+func generateWyomingContent(govAddress, chainID, genesisHash string) (string, string) {
+	now := time.Now()
+
+	// Generate full filing content
+	filingContent := fmt.Sprintf(`WYOMING DAO LC AMENDMENT - ARTICLE VI
+
+Entity Name: Decentralized Identity DAO LC
+Amendment Type: Articles of Organization Amendment
+
+ARTICLE VI - DAO PUBLIC IDENTIFIER:
+
+The publicly available identifier for smart contracts used to manage, facilitate, and operate the decentralized autonomous organization is: %s (Cosmos SDK governance module address on chain %s). This identifier provides access to all governance functions including proposal submission, voting, parameter changes, and treasury management as required by Wyoming Statute 17-31-106(b).
+
+VERIFICATION:
+- Governance Address: %s
+- Chain ID: %s
+- Verification Command: snrd query auth module-account gov
+
+Generated on: %s`, govAddress, chainID, govAddress, chainID, now.Format("2006-01-02 15:04:05"))
+
+	// Generate Article VI amendment text only
+	amendmentText := fmt.Sprintf(
+		`The publicly available identifier for smart contracts used to manage, facilitate, and operate the decentralized autonomous organization is: %s (Cosmos SDK governance module address on chain %s). This identifier provides access to all governance functions including proposal submission, voting, parameter changes, and treasury management as required by Wyoming Statute 17-31-106(b).`,
+		govAddress,
+		chainID,
+	)
+
+	return filingContent, amendmentText
+}
+
+func saveWyomingFiles(filingContent, amendmentText string) error {
+	// Write full filing content
+	err := os.WriteFile("wyoming_amendment_content.txt", []byte(filingContent), 0o644)
+	if err != nil {
+		return err
+	}
+
+	// Write Article VI amendment text
+	err = os.WriteFile("article_vi_amendment.txt", []byte(amendmentText), 0o644)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
@@ -0,0 +1,267 @@
+// Package commands contains utility functions for the snrd command
+package commands
+
+import (
+	"crypto/sha256"
+	"encoding/hex"
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"github.com/sonr-io/sonr/app"
+	"github.com/sonr-io/sonr/crypto/vrf"
+	"github.com/spf13/cobra"
+)
+
+// VRFKeysCmd returns the VRF key management command
+func VRFKeysCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "vrf",
+		Short: "Manage VRF (Verifiable Random Function) keys",
+		Long: `Manage VRF keys used for consensus-based encryption in multi-validator networks.
+
+VRF keys are required for:
+  - Multi-validator encryption key derivation
+  - Consensus-based key rotation
+  - Deterministic randomness in distributed systems
+
+VRF keys are automatically generated during 'snrd init', but this command
+allows you to inspect or regenerate them if needed.`,
+	}
+
+	cmd.AddCommand(
+		vrfGenerateCmd(),
+		vrfShowCmd(),
+		vrfVerifyCmd(),
+	)
+
+	return cmd
+}
+
+// vrfGenerateCmd creates a command to generate new VRF keys
+func vrfGenerateCmd() *cobra.Command {
+	var chainID string
+	var force bool
+
+	cmd := &cobra.Command{
+		Use:   "generate",
+		Short: "Generate new VRF keypair",
+		Long: `Generate a new VRF keypair for the node.
+
+The keypair is generated deterministically from the chain-id to ensure
+reproducibility. Keys are stored at ~/.sonr/vrf_secret.key with 0600 permissions.
+
+WARNING: Regenerating VRF keys will invalidate any existing consensus-based
+encryption keys. Only do this if you understand the implications.`,
+		Example: `  # Generate VRF keys for a specific chain
+  snrd keys vrf generate --chain-id sonrtest_1-1
+
+  # Force regenerate (overwrite existing keys)
+  snrd keys vrf generate --chain-id sonrtest_1-1 --force`,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			// Get chain-id
+			if chainID == "" {
+				// Try to read from genesis file
+				var err error
+				chainID, err = getChainIDFromGenesis()
+				if err != nil {
+					return fmt.Errorf("chain-id not provided and could not be read from genesis: %w\n"+
+						"Please provide --chain-id flag", err)
+				}
+			}
+
+			vrfKeyPath := filepath.Join(app.DefaultNodeHome, "vrf_secret.key")
+
+			// Check if keys already exist
+			if _, err := os.Stat(vrfKeyPath); err == nil && !force {
+				return fmt.Errorf("VRF keys already exist at %s\n"+
+					"Use --force flag to overwrite existing keys\n"+
+					"WARNING: Overwriting keys will invalidate existing consensus encryption", vrfKeyPath)
+			}
+
+			// Backup existing keys if they exist
+			if _, err := os.Stat(vrfKeyPath); err == nil && force {
+				backupPath := vrfKeyPath + ".backup"
+				if err := os.Rename(vrfKeyPath, backupPath); err != nil {
+					return fmt.Errorf("failed to backup existing VRF keys: %w", err)
+				}
+				fmt.Printf("Backed up existing keys to: %s\n", backupPath)
+			}
+
+			// Generate VRF keys
+			fmt.Printf("Generating VRF keypair for chain-id: %s\n", chainID)
+
+			entropySource, err := createChainIDEntropySource(chainID)
+			if err != nil {
+				return fmt.Errorf("failed to create entropy source: %w", err)
+			}
+
+			privateKey, err := vrf.GenerateKey(entropySource)
+			if err != nil {
+				return fmt.Errorf("failed to generate VRF keypair: %w", err)
+			}
+
+			// Validate keypair
+			if len(privateKey) != vrf.PrivateKeySize {
+				return fmt.Errorf("invalid VRF private key size: expected %d, got %d",
+					vrf.PrivateKeySize, len(privateKey))
+			}
+
+			publicKey, ok := privateKey.Public()
+			if !ok {
+				return fmt.Errorf("failed to derive public key from VRF private key")
+			}
+
+			// Ensure directory exists
+			if err := os.MkdirAll(app.DefaultNodeHome, 0o750); err != nil {
+				return fmt.Errorf("failed to create node home directory: %w", err)
+			}
+
+			// Store VRF secret key with restrictive permissions
+			if err := os.WriteFile(vrfKeyPath, privateKey, 0o600); err != nil {
+				return fmt.Errorf("failed to save VRF secret key: %w", err)
+			}
+
+			fmt.Printf("✓ VRF keypair generated successfully\n")
+			fmt.Printf("✓ Private key stored at: %s\n", vrfKeyPath)
+			fmt.Printf("✓ Public key (hex): %s\n", hex.EncodeToString(publicKey))
+			fmt.Printf("✓ Key size: %d bytes\n", len(privateKey))
+			fmt.Printf("✓ Permissions: 0600 (owner read/write only)\n")
+
+			return nil
+		},
+	}
+
+	cmd.Flags().StringVar(&chainID, "chain-id", "", "Chain ID for deterministic key generation")
+	cmd.Flags().BoolVar(&force, "force", false, "Force overwrite existing VRF keys (creates backup)")
+
+	return cmd
+}
+
+// vrfShowCmd creates a command to display VRF key information
+func vrfShowCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "show",
+		Short: "Show VRF public key information",
+		Long: `Display information about the node's VRF public key.
+
+This command shows the public key without exposing the private key.
+Useful for verifying that VRF keys are properly installed.`,
+		Example: `  # Show VRF key information
+  snrd keys vrf show`,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			vrfKeyPath := filepath.Join(app.DefaultNodeHome, "vrf_secret.key")
+
+			// Read VRF private key
+			// #nosec G304 - vrfKeyPath is constructed from trusted DefaultNodeHome constant
+			privateKeyData, err := os.ReadFile(vrfKeyPath)
+			if err != nil {
+				return fmt.Errorf("failed to read VRF keys from %s: %w\n"+
+					"VRF keys may not be initialized. Run 'snrd init' or 'snrd keys vrf generate'",
+					vrfKeyPath, err)
+			}
+
+			// Validate key size
+			if len(privateKeyData) != vrf.PrivateKeySize {
+				return fmt.Errorf("invalid VRF private key size: expected %d, got %d",
+					vrf.PrivateKeySize, len(privateKeyData))
+			}
+
+			privateKey := vrf.PrivateKey(privateKeyData)
+			publicKey, ok := privateKey.Public()
+			if !ok {
+				return fmt.Errorf("failed to derive public key from VRF private key")
+			}
+
+			// Get file info
+			fileInfo, err := os.Stat(vrfKeyPath)
+			if err != nil {
+				return fmt.Errorf("failed to stat VRF key file: %w", err)
+			}
+
+			fmt.Println("VRF Key Information:")
+			fmt.Println("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
+			fmt.Printf("Key Path:        %s\n", vrfKeyPath)
+			fmt.Printf("Public Key:      %s\n", hex.EncodeToString(publicKey))
+			fmt.Printf("Key Size:        %d bytes\n", len(privateKeyData))
+			fmt.Printf("Public Key Size: %d bytes\n", len(publicKey))
+			fmt.Printf("Permissions:     %s\n", fileInfo.Mode().Perm())
+			fmt.Printf("Modified:        %s\n", fileInfo.ModTime().Format("2006-01-02 15:04:05"))
+
+			// Verify permissions
+			if fileInfo.Mode().Perm() != 0o600 {
+				fmt.Println("\n⚠️  WARNING: VRF key file has incorrect permissions!")
+				fmt.Printf("   Current: %s, Expected: 0600\n", fileInfo.Mode().Perm())
+				fmt.Println("   Run: chmod 0600 " + vrfKeyPath)
+			} else {
+				fmt.Println("\n✓ VRF keys are properly configured")
+			}
+
+			return nil
+		},
+	}
+
+	return cmd
+}
+
+// vrfVerifyCmd creates a command to verify VRF key functionality
+func vrfVerifyCmd() *cobra.Command {
+	cmd := &cobra.Command{
+		Use:   "verify",
+		Short: "Verify VRF key functionality",
+		Long: `Verify that VRF keys are properly installed and functional.
+
+This command performs a test VRF computation to ensure the keys work correctly.`,
+		Example: `  # Verify VRF keys
+  snrd keys vrf verify`,
+		RunE: func(cmd *cobra.Command, args []string) error {
+			vrfKeyPath := filepath.Join(app.DefaultNodeHome, "vrf_secret.key")
+
+			// Read VRF private key
+			// #nosec G304 - vrfKeyPath is constructed from trusted DefaultNodeHome constant
+			privateKeyData, err := os.ReadFile(vrfKeyPath)
+			if err != nil {
+				return fmt.Errorf("failed to read VRF keys: %w", err)
+			}
+
+			if len(privateKeyData) != vrf.PrivateKeySize {
+				return fmt.Errorf("invalid VRF private key size: expected %d, got %d",
+					vrf.PrivateKeySize, len(privateKeyData))
+			}
+
+			privateKey := vrf.PrivateKey(privateKeyData)
+			publicKey, ok := privateKey.Public()
+			if !ok {
+				return fmt.Errorf("failed to derive public key")
+			}
+
+			// Test VRF computation with proof
+			testInput := []byte("test-input-for-verification")
+			vrfOutput, proof := privateKey.Prove(testInput)
+
+			// Verify the output
+			if !publicKey.Verify(testInput, vrfOutput, proof) {
+				return fmt.Errorf("VRF verification failed - keys may be corrupted")
+			}
+
+			// Compute output hash
+			outputHash := sha256.Sum256(vrfOutput)
+
+			fmt.Println("VRF Key Verification:")
+			fmt.Println("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
+			fmt.Printf("✓ VRF keys loaded successfully\n")
+			fmt.Printf("✓ Public key derived successfully\n")
+			fmt.Printf("✓ VRF proof generated successfully\n")
+			fmt.Printf("✓ VRF verification successful\n")
+			fmt.Printf("\nTest Output (hex): %s\n", hex.EncodeToString(vrfOutput))
+			fmt.Printf("Proof (hex):       %s\n", hex.EncodeToString(proof))
+			fmt.Printf("Output Hash:       %s\n", hex.EncodeToString(outputHash[:]))
+
+			fmt.Println("\n✓ VRF keys are fully functional")
+
+			return nil
+		},
+	}
+
+	return cmd
+}