fix: Changelog

* chore: Add Homebrew Casks for snrd/hway

* fix: Tag bump format for npm packages

* chore: Remove plugin setup

cmd/hway/.goreleaser.yml

@@ -97,8 +97,8 @@ builds:
       - -X main.Commit={{.Commit}}
       - -s -w
 
-aurs:
-  - name: hway-bin
+aur_sources:
+  - name: hway
     disable: true
     homepage: "https://sonr.io"
     description: "Highway service - bridge between the Public Internet and Sonr blockchain"
@@ -106,37 +106,55 @@ aurs:
       - "Sonr <support@sonr.io>"
     license: "Apache-2.0"
     private_key: "{{ .Env.AUR_KEY }}"
-    git_url: "ssh://[email protected]/hway-bin.git"
+    git_url: "ssh://[email protected]/hway.git"
     skip_upload: auto
     provides:
       - hway
     conflicts:
-      - hway
+      - hway-bin
     depends:
+      - glibc
       - redis
     optdepends:
       - "docker: for container-based vault operations"
+    makedepends:
+      - go
+      - git
+      - make
     commit_msg_template: "Update to {{ .Tag }}"
     commit_author:
       name: goreleaserbot
       email: "prad@sonr.io"
+    prepare: |-
+      cd "${pkgname}_${pkgver}"
+      go mod download
+    build: |-
+      cd "${pkgname}_${pkgver}"
+      export CGO_ENABLED=1
+      export CGO_CPPFLAGS="${CPPFLAGS}"
+      export CGO_CFLAGS="${CFLAGS}"
+      export CGO_CXXFLAGS="${CXXFLAGS}"
+      export CGO_LDFLAGS="${LDFLAGS}"
+      export GOFLAGS="-buildmode=pie -trimpath -mod=readonly -modcacherw"
+      go build \
+        -ldflags="-w -s -buildid='' -linkmode=external \
+          -X main.Version=${pkgver}" \
+        -o hway ./cmd/hway
+      chmod +x ./hway
     package: |-
+      cd "${pkgname}_${pkgver}"
+
       # bin
       install -Dm755 "./hway" "${pkgdir}/usr/bin/hway"
 
       # license
       if [ -f "./LICENSE" ]; then
-        install -Dm644 "./LICENSE" "${pkgdir}/usr/share/licenses/hway-bin/LICENSE"
+        install -Dm644 "./LICENSE" "${pkgdir}/usr/share/licenses/hway/LICENSE"
       fi
 
       # readme
       if [ -f "./README.md" ]; then
-        install -Dm644 "./README.md" "${pkgdir}/usr/share/doc/hway-bin/README.md"
-      fi
-
-      # systemd service (if exists)
-      if [ -f "./hway.service" ]; then
-        install -Dm644 "./hway.service" "${pkgdir}/usr/lib/systemd/system/hway.service"
+        install -Dm644 "./README.md" "${pkgdir}/usr/share/doc/hway/README.md"
       fi
 
 nix:
@@ -149,8 +167,10 @@ nix:
     path: pkgs/hway/default.nix
     commit_msg_template: "hway: {{ .Tag }}"
     dependencies:
+      - stdenv
       - glibc
-      - stdenv.cc.cc.lib
+    extra_install: |-
+      wrapProgram $out/bin/hway --prefix PATH : ${lib.makeBinPath [ glibc stdenv.cc.cc.lib ]}
     repository:
       owner: sonr-io
       name: nur
@@ -171,6 +191,29 @@ archives:
       - src: README*
     wrap_in_directory: false
 
+homebrew_casks:
+  - name: hway
+    ids:
+      - hway
+    homepage: "https://sonr.io"
+    description: "Highway service - bridge between the Public Internet and Sonr blockchain"
+    commit_msg_template: "Brew cask update for {{ .ProjectName }} version {{ .Tag }}"
+    directory: Casks
+    repository:
+      owner: sonr-io
+      name: homebrew-tap
+      branch: main
+      token: "{{ .Env.GITHUB_TOKEN }}"
+    commit_author:
+      name: goreleaserbot
+      email: "prad@sonr.io"
+    hooks:
+      post:
+        install: |
+          if OS.mac?
+            system_command "/usr/bin/xattr", args: ["-dr", "com.apple.quarantine", "#{staged_path}/hway"]
+          end
+
 nfpms:
   - id: hway
     package_name: hway
@@ -218,6 +261,25 @@ release:
 checksum:
   name_template: 'hway_checksums.txt'
 
+npms:
+  - name: "@sonr.io/hway"
+    ids:
+      - hway
+    description: "Highway service - bridge between the Public Internet and Sonr blockchain"
+    homepage: "https://sonr.io"
+    license: "Apache-2.0"
+    author: "Sonr <support@sonr.io>"
+    repository: "https://github.com/sonr-io/sonr"
+    bugs: "https://github.com/sonr-io/sonr/issues"
+    keywords:
+      - highway
+      - bridge
+      - blockchain
+      - sonr
+      - service
+    access: public
+    format: tar.gz
+
 snapshot:
   version_template: "{{ incpatch .Version }}-dev"
 

cmd/hway/CHANGELOG.md

@@ -0,0 +1 @@
+## hway/v0.0.1 (2025-10-03)

cmd/hway/etc/process-compose.yaml

@@ -1,33 +0,0 @@
-version: "0.5"
-processes:
-  postgres-sonr:
-    command: |
-      # Generate pgsodium key if not set
-      if [ -z "${PGSODIUM_ROOT_KEY}" ]; then
-        echo "Generating pgsodium root key..."
-        export PGSODIUM_ROOT_KEY=$(openssl rand -hex 32)
-        echo "Generated key: ${PGSODIUM_ROOT_KEY:0:10}..."
-      fi
-
-      # Run the container using the pre-built image
-      docker run --rm \
-        --name ${POSTGRES_CONTAINER_NAME} \
-        -e POSTGRES_USER="${POSTGRES_USER:-postgres}" \
-        -e POSTGRES_DB="${POSTGRES_DB:-sonr}" \
-        -e PGSODIUM_ROOT_KEY="${PGSODIUM_ROOT_KEY}" \
-        -v ${POSTGRES_DATA_DIR}:/var/lib/postgresql/data \
-        -p ${POSTGRES_PORT:-5432}:5432 \
-        ${POSTGRES_DOCKER_IMAGE}
-    availability:
-      restart: "on_failure"
-      backoff_seconds: 5
-      max_restarts: 5
-    readiness_probe:
-      exec:
-        command: "docker exec ${POSTGRES_CONTAINER_NAME} pg_isready -U ${POSTGRES_USER:-postgres} -d ${POSTGRES_DB:-hway}"
-      initial_delay_seconds: 15
-      period_seconds: 10
-    shutdown:
-      command: "docker stop ${POSTGRES_CONTAINER_NAME} || true"
-      timeout_seconds: 30
-    log_location: "{{ .Virtenv }}/logs/postgres-sonr.log"

cmd/hway/plugin.json

@@ -1,22 +0,0 @@
-{
-  "name": "hway",
-  "version": "0.0.3",
-  "description": "Plugin for Sonr Hway Gateway",
-  "packages": [],
-  "env": {},
-  "create_files": {
-    "{{ .Virtenv }}/data": "",
-    "{{ .Virtenv }}/logs": "",
-    "{{ .Virtenv }}/process-compose.yaml": "etc/process-compose.yaml",
-    "{{ .DevboxDir }}/init.sh": "etc/init.sh"
-  },
-  "shell": {
-    "init_hook": ["chmod +x {{ .DevboxDir }}/init.sh", "{{ .DevboxDir }}/init.sh"],
-    "scripts": {
-      "start": "devbox services start postgres-sonr",
-      "stop": "devbox services stop postgres-sonr",
-      "restart": "devbox services restart postgres-sonr",
-      "logs": "docker logs -f ${POSTGRES_CONTAINER_NAME}"
-    }
-  }
-}

cmd/motr/CHANGELOG.md

@@ -0,0 +1 @@
+## motr/v0.0.1 (2025-10-03)

cmd/snrd/.goreleaser.yml

@@ -126,8 +126,8 @@ builds:
       - netgo
       - ledger
 
-aurs:
-  - name: snrd-bin
+aur_sources:
+  - name: snrd
     disable: true
     homepage: "https://sonr.io"
     description: "Sonr blockchain daemon - decentralized identity and data storage network"
@@ -135,33 +135,56 @@ aurs:
       - "Sonr <support@sonr.io>"
     license: "Apache-2.0"
     private_key: "{{ .Env.AUR_KEY }}"
-    git_url: "ssh://[email protected]/snrd-bin.git"
+    git_url: "ssh://[email protected]/snrd.git"
     skip_upload: auto
     provides:
       - snrd
     conflicts:
-      - snrd
+      - snrd-bin
+    depends:
+      - glibc
+    makedepends:
+      - go
+      - git
+      - make
     commit_msg_template: "Update to {{ .Tag }}"
     commit_author:
       name: goreleaserbot
       email: "prad@sonr.io"
+    prepare: |-
+      cd "${pkgname}_${pkgver}"
+      go mod download
+    build: |-
+      cd "${pkgname}_${pkgver}"
+      export CGO_ENABLED=1
+      export CGO_CPPFLAGS="${CPPFLAGS}"
+      export CGO_CFLAGS="${CFLAGS}"
+      export CGO_CXXFLAGS="${CXXFLAGS}"
+      export CGO_LDFLAGS="${LDFLAGS}"
+      export GOFLAGS="-buildmode=pie -trimpath -mod=readonly -modcacherw"
+      go build \
+        -ldflags="-w -s -buildid='' -linkmode=external \
+          -X github.com/cosmos/cosmos-sdk/version.Name=sonr \
+          -X github.com/cosmos/cosmos-sdk/version.AppName=snrd \
+          -X github.com/cosmos/cosmos-sdk/version.Version=${pkgver} \
+          -X 'github.com/cosmos/cosmos-sdk/version.BuildTags=netgo,ledger'" \
+        -tags "netgo,ledger" \
+        -o snrd ./cmd/snrd
+      chmod +x ./snrd
     package: |-
+      cd "${pkgname}_${pkgver}"
+
       # bin
       install -Dm755 "./snrd" "${pkgdir}/usr/bin/snrd"
 
       # license
       if [ -f "./LICENSE" ]; then
-        install -Dm644 "./LICENSE" "${pkgdir}/usr/share/licenses/snrd-bin/LICENSE"
+        install -Dm644 "./LICENSE" "${pkgdir}/usr/share/licenses/snrd/LICENSE"
       fi
 
       # readme
       if [ -f "./README.md" ]; then
-        install -Dm644 "./README.md" "${pkgdir}/usr/share/doc/snrd-bin/README.md"
-      fi
-
-      # systemd service (if exists)
-      if [ -f "./snrd.service" ]; then
-        install -Dm644 "./snrd.service" "${pkgdir}/usr/lib/systemd/system/snrd.service"
+        install -Dm644 "./README.md" "${pkgdir}/usr/share/doc/snrd/README.md"
       fi
 
       # config directory
@@ -181,8 +204,10 @@ nix:
     path: pkgs/snrd/default.nix
     commit_msg_template: "snrd: {{ .Tag }}"
     dependencies:
+      - stdenv
       - glibc
-      - stdenv.cc.cc.lib
+    extra_install: |-
+      wrapProgram $out/bin/snrd --prefix PATH : ${lib.makeBinPath [ glibc stdenv.cc.cc.lib ]}
     repository:
       owner: sonr-io
       name: nur
@@ -203,6 +228,29 @@ archives:
       - src: README*
     wrap_in_directory: false
 
+homebrew_casks:
+  - name: snrd
+    ids:
+      - snrd
+    homepage: "https://sonr.io"
+    description: "Sonr blockchain daemon - decentralized identity and data storage network"
+    commit_msg_template: "Brew cask update for {{ .ProjectName }} version {{ .Tag }}"
+    directory: Casks
+    repository:
+      owner: sonr-io
+      name: homebrew-tap
+      branch: main
+      token: "{{ .Env.GITHUB_TOKEN }}"
+    commit_author:
+      name: goreleaserbot
+      email: "prad@sonr.io"
+    hooks:
+      post:
+        install: |
+          if OS.mac?
+            system_command "/usr/bin/xattr", args: ["-dr", "com.apple.quarantine", "#{staged_path}/snrd"]
+          end
+
 nfpms:
   - id: snrd
     package_name: snrd
@@ -250,6 +298,26 @@ release:
 checksum:
   name_template: "snrd_checksums.txt"
 
+npms:
+  - name: "@sonr.io/snrd"
+    ids:
+      - snrd
+    description: "Sonr blockchain daemon - decentralized identity and data storage network"
+    homepage: "https://sonr.io"
+    license: "Apache-2.0"
+    author: "Sonr <support@sonr.io>"
+    repository: "https://github.com/sonr-io/sonr"
+    bugs: "https://github.com/sonr-io/sonr/issues"
+    keywords:
+      - blockchain
+      - cosmos
+      - did
+      - identity
+      - web3
+      - sonr
+    access: public
+    format: tar.gz
+
 snapshot:
   version_template: "{{ incpatch .Version }}-dev"
 

cmd/snrd/CHANGELOG.md

@@ -0,0 +1 @@
+## snrd/v0.0.1 (2025-10-03)

cmd/snrd/etc/bootstrap.sh

@@ -1,336 +0,0 @@
-#!/bin/bash
-set -e
-
-# ================================
-# SONR TESTNET BOOTSTRAP SCRIPT
-# ================================
-
-# Color output
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-BLUE='\033[0;34m'
-NC='\033[0m'
-
-log_info() { echo -e "${GREEN}[INFO]${NC} $1"; }
-log_warn() { echo -e "${YELLOW}[WARN]${NC} $1"; }
-log_error() { echo -e "${RED}[ERROR]${NC} $1"; }
-log_header() { echo -e "${BLUE}==== $1 ====${NC}"; }
-
-# Script directory and repository root
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-REPO_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
-cd "$REPO_ROOT"
-
-# Load environment variables if .env exists
-if [ -f "$REPO_ROOT/.env" ]; then
-    export $(grep -v '^#' "$REPO_ROOT/.env" | xargs)
-fi
-
-# Default values
-export CHAIN_ID=${CHAIN_ID:-"sonrtest_1-1"}
-export DENOM=${DENOM:-"usnr"}
-export DOCKER_IMAGE=${DOCKER_IMAGE:-"onsonr/snrd:latest"}
-
-# Function to check prerequisites
-check_prerequisites() {
-    log_header "Checking prerequisites"
-    
-    local has_error=false
-    
-    # Check Docker
-    if ! command -v docker &> /dev/null; then
-        log_error "Docker is not installed"
-        has_error=true
-    else
-        log_info "Docker: $(docker --version)"
-    fi
-    
-    # Check Docker Compose
-    if ! docker compose version &> /dev/null; then
-        log_error "Docker Compose is not installed"
-        has_error=true
-    else
-        log_info "Docker Compose: $(docker compose version)"
-    fi
-    
-    # Check jq
-    if ! command -v jq &> /dev/null; then
-        log_warn "jq is not installed - some commands may not work"
-        log_warn "Install with: apt-get install jq (Ubuntu) or brew install jq (macOS)"
-    else
-        log_info "jq: $(jq --version)"
-    fi
-    
-    if [ "$has_error" = true ]; then
-        log_error "Prerequisites check failed"
-        exit 1
-    fi
-    
-    log_info "All prerequisites met"
-    echo ""
-}
-
-# Function to initialize validators
-init_validators() {
-    log_header "Initializing validators and sentries"
-
-    # Check for local snrd binary
-    if ! command -v snrd &> /dev/null; then
-        log_error "snrd binary not found in PATH"
-        log_error "Please install snrd locally or add it to your PATH"
-        log_error "The initialization requires a local snrd binary to avoid permission issues"
-        exit 1
-    fi
-
-    if [ -f "$SCRIPT_DIR/init-testnet.sh" ]; then
-        log_info "Using init-testnet.sh (local snrd binary initialization)"
-        log_info "snrd location: $(which snrd)"
-        "$SCRIPT_DIR/init-testnet.sh"
-    else
-        log_error "init-testnet.sh not found in $SCRIPT_DIR!"
-        exit 1
-    fi
-}
-
-# Function to start testnet
-start_testnet() {
-    log_header "Starting testnet"
-
-    # Check if validators are initialized
-    if [ ! -d "val-alice" ] || [ ! -d "sentry-alice" ]; then
-        log_warn "Validators not initialized, running init first..."
-        init_validators
-    fi
-
-    # Pull latest image
-    log_info "Pulling Docker image: $DOCKER_IMAGE"
-    docker pull "$DOCKER_IMAGE"
-
-    # Start services
-    log_info "Starting services with docker compose..."
-    docker compose up -d
-    
-    # Wait for services to be healthy
-    log_info "Waiting for services to start..."
-    sleep 5
-    
-    # Check status
-    show_status
-    
-    log_info "Testnet started successfully!"
-    echo ""
-    log_info "View logs: docker compose logs -f"
-    log_info "Stop testnet: ./bootstrap.sh stop"
-}
-
-# Function to stop testnet
-stop_testnet() {
-    log_header "Stopping testnet"
-    
-    docker compose down
-    log_info "Testnet stopped"
-}
-
-# Function to restart testnet
-restart_testnet() {
-    log_header "Restarting testnet"
-    
-    stop_testnet
-    sleep 2
-    start_testnet
-}
-
-# Function to clean all data
-clean_all() {
-    log_header "Cleaning testnet data"
-
-    # Stop containers and remove volumes
-    log_info "Stopping containers and removing volumes..."
-    docker compose down -v 2>/dev/null || true
-
-    # Remove data directories using Docker to handle permission issues
-    log_info "Removing validator and sentry directories..."
-    if [ -d "val-alice" ] || [ -d "val-bob" ] || [ -d "val-carol" ] || [ -d "sentry-alice" ] || [ -d "sentry-bob" ] || [ -d "sentry-carol" ]; then
-        docker run --rm -v "$(pwd):/workspace" alpine:latest sh -c \
-            "rm -rf /workspace/val-alice /workspace/val-bob /workspace/val-carol /workspace/sentry-alice /workspace/sentry-bob /workspace/sentry-carol" \
-            2>/dev/null || true
-    fi
-
-    log_info "Clean complete"
-}
-
-# Function to show status
-show_status() {
-    log_header "Testnet Status"
-    
-    echo ""
-    echo "Container Status:"
-    docker ps --filter "name=val-" --filter "name=sentry-" --filter "name=ipfs" --format "table {{.Names}}\t{{.Status}}\t{{.State}}"
-    
-    echo ""
-    echo "Network Endpoints (via Cloudflare Tunnel):"
-    echo "  Alice RPC:  https://alice-rpc.sonr.land"
-    echo "  Alice REST: https://alice-rest.sonr.land"
-    echo "  Alice gRPC: https://alice-grpc.sonr.land"
-    echo "  Alice EVM:  https://alice-evm.sonr.land"
-    echo "  Bob RPC:    https://bob-rpc.sonr.land"
-    echo "  Carol RPC:  https://carol-rpc.sonr.land"
-    echo "  IPFS API:   https://ipfs-api.sonr.land"
-    echo "  IPFS Gateway: https://ipfs-gateway.sonr.land"
-    
-    # Check sync status if services are running
-    if docker ps | grep -q "sentry-alice"; then
-        echo ""
-        echo "Sync Status:"
-        local block_height=$(docker exec sentry-alice sh -c 'curl -s http://localhost:26657/status 2>/dev/null | jq -r ".result.sync_info.latest_block_height" 2>/dev/null' || echo "0")
-        echo "  Block Height: $block_height"
-        for container in sentry-alice sentry-bob sentry-carol; do
-            status=$(docker exec $container sh -c 'curl -s http://localhost:26657/status 2>/dev/null | jq -r ".result.sync_info.catching_up" 2>/dev/null' || echo "unavailable")
-            echo "  $container: catching_up=$status"
-        done
-    fi
-
-    echo ""
-}
-
-# Function to view logs
-view_logs() {
-    local service=$1
-    
-    if [ -z "$service" ]; then
-        docker compose logs -f --tail=100
-    else
-        docker compose logs -f --tail=100 "$service"
-    fi
-}
-
-# Function to execute command in container
-exec_in_container() {
-    local container=$1
-    shift
-    
-    if [ -z "$container" ]; then
-        log_error "Container name required"
-        echo "Usage: ./bootstrap.sh exec <container> <command>"
-        echo "Example: ./bootstrap.sh exec val-alice status"
-        return 1
-    fi
-    
-    docker exec -it "$container" snrd --home /root/.sonr "$@"
-}
-
-# Function to run tests
-run_tests() {
-    log_header "Running testnet tests"
-    
-    # Check if all services are running
-    log_info "Checking service health..."
-    local all_healthy=true
-    
-    for service in val-alice val-bob val-carol sentry-alice sentry-bob sentry-carol; do
-        if ! docker ps | grep -q "$service"; then
-            log_error "$service is not running"
-            all_healthy=false
-        fi
-    done
-    
-    if [ "$all_healthy" = false ]; then
-        log_error "Not all services are running"
-        return 1
-    fi
-    
-    # Test RPC endpoints
-    log_info "Testing RPC endpoints..."
-    for container in sentry-alice sentry-bob sentry-carol; do
-        if docker exec $container sh -c 'curl -s http://localhost:26657/status' > /dev/null 2>&1; then
-            log_info "$container: OK"
-        else
-            log_error "$container: FAILED"
-        fi
-    done
-    
-    # Test validator connectivity
-    log_info "Testing validator connectivity..."
-    local block_height=$(docker exec sentry-alice sh -c 'curl -s http://localhost:26657/status 2>/dev/null | jq -r ".result.sync_info.latest_block_height" 2>/dev/null' || echo "unavailable")
-    if [ "$block_height" != "unavailable" ] && [ "$block_height" != "null" ]; then
-        log_info "Current block height: $block_height"
-    else
-        log_error "Failed to get validator status"
-    fi
-
-    log_info "Tests complete"
-}
-
-# Function to show usage
-show_usage() {
-    echo "Sonr Testnet Bootstrap Script"
-    echo ""
-    echo "Usage: ./bootstrap.sh [command]"
-    echo ""
-    echo "Commands:"
-    echo "  init       Initialize validators and sentries"
-    echo "  start      Start the testnet"
-    echo "  stop       Stop the testnet"
-    echo "  restart    Restart the testnet"
-    echo "  status     Show testnet status"
-    echo "  logs       View logs (optional: service name)"
-    echo "  clean      Clean all data and volumes"
-    echo "  exec       Execute command in container"
-    echo "  test       Run basic tests"
-    echo "  help       Show this help message"
-    echo ""
-    echo "Examples:"
-    echo "  ./bootstrap.sh init"
-    echo "  ./bootstrap.sh start"
-    echo "  ./bootstrap.sh logs sentry-alice"
-    echo "  ./bootstrap.sh exec val-alice status"
-    echo ""
-}
-
-# Main command handler
-main() {
-    case "${1:-help}" in
-        init)
-            check_prerequisites
-            init_validators
-            ;;
-        start)
-            check_prerequisites
-            start_testnet
-            ;;
-        stop)
-            stop_testnet
-            ;;
-        restart)
-            restart_testnet
-            ;;
-        status)
-            show_status
-            ;;
-        logs)
-            view_logs "${2:-}"
-            ;;
-        clean)
-            clean_all
-            ;;
-        exec)
-            shift
-            exec_in_container "$@"
-            ;;
-        test)
-            run_tests
-            ;;
-        help|--help|-h)
-            show_usage
-            ;;
-        *)
-            log_error "Unknown command: $1"
-            show_usage
-            exit 1
-            ;;
-    esac
-}
-
-# Run main function with all arguments
-main "$@"

cmd/snrd/etc/init.sh

@@ -1,418 +0,0 @@
-#!/bin/bash
-# Run this script to quickly install, setup, and run the current version of the network without docker.
-#
-# Examples:
-# CHAIN_ID="localchain_9000-1" HOME_DIR="~/.sonr" BLOCK_TIME="1000ms" CLEAN=true sh scripts/test_node.sh
-# CHAIN_ID="localchain_9000-2" HOME_DIR="~/.sonr" CLEAN=true RPC=36657 REST=2317 PROFF=6061 P2P=36656 GRPC=8090 GRPC_WEB=8091 ROSETTA=8081 BLOCK_TIME="500ms" sh scripts/test_node.sh
-
-set -eu
-
-export KEY="acc0"
-export KEY2="acc1"
-
-export CHAIN_ID=${CHAIN_ID:-"sonrtest_1-1"}
-export MONIKER="localvalidator"
-export KEYALGO="eth_secp256k1"
-export KEYRING=${KEYRING:-"test"}
-export HOME_DIR=$(eval echo "${HOME_DIR:-"~/.sonr"}")
-export BINARY=${BINARY:-snrd}
-export DENOM=${DENOM:-usnr}
-
-export CLEAN=${CLEAN:-"false"}
-export RPC=${RPC:-"26657"}
-export REST=${REST:-"1317"}
-export PROFF=${PROFF:-"6060"}
-export P2P=${P2P:-"26656"}
-export GRPC=${GRPC:-"9090"}
-export GRPC_WEB=${GRPC_WEB:-"9091"}
-export ROSETTA=${ROSETTA:-"8080"}
-export JSON_RPC=${JSON_RPC:-"8545"}
-export JSON_RPC_WS=${JSON_RPC_WS:-"8546"}
-export BLOCK_TIME=${BLOCK_TIME:-"5s"}
-
-# Configurable Mnemomics
-export SONR_MNEMONIC_1=${SONR_MNEMONIC_1:-"decorate bright ozone fork gallery riot bus exhaust worth way bone indoor calm squirrel merry zero scheme cotton until shop any excess stage laundry"}
-export SONR_MNEMONIC_2=${SONR_MNEMONIC_2:-"wealth flavor believe regret funny network recall kiss grape useless pepper cram hint member few certain unveil rather brick bargain curious require crowd raise"}
-
-# Check if binary exists, if not use Docker (or force Docker if requested)
-export FORCE_DOCKER=${FORCE_DOCKER:-"false"}
-export SKIP_INSTALL=${SKIP_INSTALL:-"false"}
-USE_DOCKER=false
-if [[ "${FORCE_DOCKER}" == "true" ]] || [[ -z $(which "${BINARY}") ]]; then
-	# Check if Docker is available and use it
-	if command -v docker >/dev/null 2>&1; then
-		if [[ "${FORCE_DOCKER}" == "true" ]]; then
-			echo "Force Docker mode enabled, using Docker image onsonr/snrd:latest..."
-		else
-			echo "Binary ${BINARY} not found locally, checking for Docker image onsonr/snrd:latest..."
-		fi
-		if docker image inspect onsonr/snrd:latest >/dev/null 2>&1; then
-			echo "Using Docker image onsonr/snrd:latest"
-			USE_DOCKER=true
-		else
-			echo "Docker image onsonr/snrd:latest not found. Pulling image..."
-			docker pull onsonr/snrd:latest || {
-				echo "Failed to pull onsonr/snrd:latest. Please ensure Docker is running and you have internet access."
-				exit 1
-			}
-			USE_DOCKER=true
-		fi
-	else
-		echo "Binary ${BINARY} not found. Please either:"
-		echo "  1. Install ${BINARY} with 'make install'"
-		echo "  2. Install Docker to use the containerized version"
-		exit 1
-	fi
-fi
-
-# Final check if not using Docker
-if [[ "${USE_DOCKER}" == "false" ]]; then
-	command -v "${BINARY}" >/dev/null 2>&1 || {
-		echo >&2 "${BINARY} command not found. Ensure this is setup / properly installed in your GOPATH (make install)."
-		exit 1
-	}
-fi
-command -v jq >/dev/null 2>&1 || {
-	echo >&2 "jq not installed. More info: https://stedolan.github.io/jq/download/"
-	exit 1
-}
-
-# generate_vrf_key generates a VRF keypair and stores it securely
-# Mirrors the Go implementation in app/commands/enhance_init.go
-generate_vrf_key() {
-	local home_dir="$1"
-	local use_docker="${2:-false}"
-
-	# Validate parameters
-	if [[ -z "${home_dir}" ]]; then
-		echo "Error: HOME_DIR parameter is required" >&2
-		return 1
-	fi
-
-	# Path to genesis file
-	local genesis_file="${home_dir}/config/genesis.json"
-
-	# Check if genesis file exists
-	if [[ ! -f "${genesis_file}" ]]; then
-		echo "Error: Genesis file not found at ${genesis_file}" >&2
-		return 1
-	fi
-
-	# Extract chain-id from genesis file
-	local chain_id
-	chain_id=$(jq -r '.chain_id' "${genesis_file}" 2>/dev/null)
-
-	if [[ -z "${chain_id}" || "${chain_id}" == "null" ]]; then
-		echo "Error: Failed to extract chain-id from genesis file" >&2
-		return 1
-	fi
-
-	echo "Generating VRF keypair for network: ${chain_id}"
-
-	# Create deterministic entropy from chain-id using SHA256
-	local entropy_seed
-	entropy_seed=$(echo -n "${chain_id}" | sha256sum | cut -d' ' -f1)
-
-	# Generate 64 bytes of deterministic randomness
-	local seed_part1="${entropy_seed}"
-	local seed_part2
-	seed_part2=$(echo -n "${entropy_seed}" | sha256sum | cut -d' ' -f1)
-
-	# Combine to create 64 bytes of hex data
-	local vrf_key_hex="${seed_part1}${seed_part2}"
-
-	# Ensure we have exactly 128 hex characters (64 bytes)
-	if [[ ${#vrf_key_hex} -ne 128 ]]; then
-		echo "Error: Generated VRF key has incorrect size: ${#vrf_key_hex}" >&2
-		return 1
-	fi
-
-	# Path to store VRF secret key
-	local vrf_key_path="${home_dir}/vrf_secret.key"
-
-	# Ensure directory exists
-	mkdir -p "${home_dir}"
-
-	# Convert hex to binary and write to file
-	echo -n "${vrf_key_hex}" | xxd -r -p > "${vrf_key_path}"
-
-	# Set restrictive permissions (owner read/write only)
-	chmod 0600 "${vrf_key_path}"
-
-	# Validate file was created with correct size (64 bytes)
-	local file_size
-	file_size=$(wc -c < "${vrf_key_path}")
-
-	if [[ ${file_size} -ne 64 ]]; then
-		echo "Error: VRF key file has incorrect size: ${file_size} bytes" >&2
-		rm -f "${vrf_key_path}"
-		return 1
-	fi
-
-	echo "✓ VRF keypair generated for network: ${chain_id}"
-	echo "✓ VRF secret key stored securely: ${vrf_key_path}"
-
-	return 0
-}
-
-# Create wrapper function for binary execution
-run_binary() {
-	if [[ "${USE_DOCKER}" == "true" ]]; then
-		# Ensure the directory exists on the host
-		mkdir -p "${HOME_DIR}"
-		# Determine if we're in a TTY
-		DOCKER_TTY_FLAG=""
-		if [ -t 0 ]; then
-			DOCKER_TTY_FLAG="-it"
-		fi
-		# Mount home directory to container's /root/.sonr
-		docker run --rm ${DOCKER_TTY_FLAG} \
-			-v "${HOME_DIR}:/root/.sonr" \
-			--network host \
-			onsonr/snrd:latest \
-			snrd --home /root/.sonr "$@"
-	else
-		${BINARY} "$@"
-	fi
-}
-
-set_config() {
-	run_binary config set client chain-id "${CHAIN_ID}"
-	run_binary config set client keyring-backend "${KEYRING}"
-}
-set_config
-
-from_scratch() {
-	# Fresh install on current branch (skip if using Docker or SKIP_INSTALL is true)
-	if [[ "${USE_DOCKER}" == "false" ]] && [[ "${SKIP_INSTALL}" == "false" ]]; then
-		make install
-	fi
-
-	# remove existing daemon files.
-	if [[ ${#HOME_DIR} -le 2 ]]; then
-		echo "HOME_DIR must be more than 2 characters long"
-		return
-	fi
-	rm -rf "${HOME_DIR}" && echo "Removed ${HOME_DIR}"
-
-	# reset values if not set already after whipe
-	set_config
-
-	add_key() {
-		key=$1
-		mnemonic=$2
-		if [[ "${USE_DOCKER}" == "true" ]]; then
-			# For Docker, we need to pass the mnemonic differently
-			mkdir -p "${HOME_DIR}"
-			echo "${mnemonic}" | docker run --rm -i \
-				-v "${HOME_DIR}:/root/.sonr" \
-				--network host \
-				onsonr/snrd:latest \
-				snrd --home /root/.sonr keys add "${key}" --keyring-backend "${KEYRING}" --algo "${KEYALGO}" --recover
-		else
-			echo "${mnemonic}" | ${BINARY} keys add "${key}" --keyring-backend "${KEYRING}" --algo "${KEYALGO}" --home "${HOME_DIR}" --recover
-		fi
-	}
-
-	# idx140fehngcrxvhdt84x729p3f0qmkmea8n570lrg
-	add_key "${KEY}" "${SONR_MNEMONIC_1}"
-
-	# idx1r6yue0vuyj9m7xw78npspt9drq2tmtvgcrf7sr
-	add_key "${KEY2}" "${SONR_MNEMONIC_2}"
-
-	if [[ "${USE_DOCKER}" == "true" ]]; then
-		# For Docker init, we need to handle it specially
-		docker run --rm \
-			-v "${HOME_DIR}:/root/.sonr" \
-			--network host \
-			onsonr/snrd:latest \
-			snrd --home /root/.sonr init "${MONIKER}" --chain-id "${CHAIN_ID}" --default-denom "${DENOM}"
-	else
-		${BINARY} init "${MONIKER}" --chain-id "${CHAIN_ID}" --default-denom "${DENOM}" --home "${HOME_DIR}"
-	fi
-
-	update_test_genesis() {
-		cat "${HOME_DIR}"/config/genesis.json | jq "$1" >"${HOME_DIR}"/config/tmp_genesis.json && mv "${HOME_DIR}"/config/tmp_genesis.json "${HOME_DIR}"/config/genesis.json
-	}
-
-	# === CORE MODULES ===
-
-	# Block
-	update_test_genesis '.consensus_params["block"]["max_gas"]="100000000"'
-
-	# Gov
-	update_test_genesis $(printf '.app_state["gov"]["params"]["min_deposit"]=[{"denom":"%s","amount":"1000000"}]' "${DENOM}")
-	update_test_genesis '.app_state["gov"]["params"]["voting_period"]="30s"'
-	update_test_genesis '.app_state["gov"]["params"]["expedited_voting_period"]="15s"'
-
-	# Add CONSTITUTION.md to governance if it exists
-	if [ -f "CONSTITUTION.md" ]; then
-		CONSTITUTION_CONTENT=$(cat CONSTITUTION.md | jq -Rs .)
-		update_test_genesis ".app_state[\"gov\"][\"constitution\"]=$CONSTITUTION_CONTENT"
-	fi
-
-	update_test_genesis $(printf '.app_state["evm"]["params"]["evm_denom"]="%s"' "${DENOM}")
-	update_test_genesis '.app_state["evm"]["params"]["active_static_precompiles"]=["0x0000000000000000000000000000000000000100","0x0000000000000000000000000000000000000400","0x0000000000000000000000000000000000000800","0x0000000000000000000000000000000000000801","0x0000000000000000000000000000000000000802","0x0000000000000000000000000000000000000803","0x0000000000000000000000000000000000000804","0x0000000000000000000000000000000000000805"]'
-	update_test_genesis '.app_state["erc20"]["params"]["native_precompiles"]=["0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE"]' # https://eips.ethereum.org/EIPS/eip-7528
-	update_test_genesis $(printf '.app_state["erc20"]["token_pairs"]=[{contract_owner:1,erc20_address:"0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",denom:"%s",enabled:true}]' "${DENOM}")
-	update_test_genesis '.app_state["feemarket"]["params"]["no_base_fee"]=true'
-	update_test_genesis '.app_state["feemarket"]["params"]["base_fee"]="0.000000000000000000"'
-
-	# staking
-	update_test_genesis $(printf '.app_state["staking"]["params"]["bond_denom"]="%s"' "${DENOM}")
-	update_test_genesis '.app_state["staking"]["params"]["min_commission_rate"]="0.050000000000000000"'
-
-	# mint
-	update_test_genesis $(printf '.app_state["mint"]["params"]["mint_denom"]="%s"' "${DENOM}")
-
-	# crisis
-	update_test_genesis $(printf '.app_state["crisis"]["constant_fee"]={"denom":"%s","amount":"1000"}' "${DENOM}")
-
-	## abci
-	update_test_genesis '.consensus["params"]["abci"]["vote_extensions_enable_height"]="1"'
-
-	# === CUSTOM MODULES ===
-	# tokenfactory
-	update_test_genesis '.app_state["tokenfactory"]["params"]["denom_creation_fee"]=[]'
-	update_test_genesis '.app_state["tokenfactory"]["params"]["denom_creation_gas_consume"]=100000'
-
-	BASE_GENESIS_ALLOCATIONS="100000000000000000000000000${DENOM},100000000test"
-
-	# Allocate genesis accounts
-	if [[ "${USE_DOCKER}" == "true" ]]; then
-		docker run --rm \
-			-v "${HOME_DIR}:/root/.sonr" \
-			--network host \
-			onsonr/snrd:latest \
-			snrd --home /root/.sonr genesis add-genesis-account "${KEY}" "${BASE_GENESIS_ALLOCATIONS}" --keyring-backend "${KEYRING}" --append
-		docker run --rm \
-			-v "${HOME_DIR}:/root/.sonr" \
-			--network host \
-			onsonr/snrd:latest \
-			snrd --home /root/.sonr genesis add-genesis-account "${KEY2}" "${BASE_GENESIS_ALLOCATIONS}" --keyring-backend "${KEYRING}" --append
-		# Sign genesis transaction
-		docker run --rm \
-			-v "${HOME_DIR}:/root/.sonr" \
-			--network host \
-			onsonr/snrd:latest \
-			snrd --home /root/.sonr genesis gentx "${KEY}" 1000000000000000000000"${DENOM}" --gas-prices 0"${DENOM}" --keyring-backend "${KEYRING}" --chain-id "${CHAIN_ID}"
-		docker run --rm \
-			-v "${HOME_DIR}:/root/.sonr" \
-			--network host \
-			onsonr/snrd:latest \
-			snrd --home /root/.sonr genesis collect-gentxs
-		docker run --rm \
-			-v "${HOME_DIR}:/root/.sonr" \
-			--network host \
-			onsonr/snrd:latest \
-			snrd --home /root/.sonr genesis validate-genesis
-	else
-		${BINARY} genesis add-genesis-account "${KEY}" "${BASE_GENESIS_ALLOCATIONS}" --keyring-backend "${KEYRING}" --home "${HOME_DIR}" --append
-		${BINARY} genesis add-genesis-account "${KEY2}" "${BASE_GENESIS_ALLOCATIONS}" --keyring-backend "${KEYRING}" --home "${HOME_DIR}" --append
-		# Sign genesis transaction
-		${BINARY} genesis gentx "${KEY}" 1000000000000000000000"${DENOM}" --gas-prices 0"${DENOM}" --keyring-backend "${KEYRING}" --chain-id "${CHAIN_ID}" --home "${HOME_DIR}"
-		${BINARY} genesis collect-gentxs --home "${HOME_DIR}"
-		${BINARY} genesis validate-genesis --home "${HOME_DIR}"
-	fi
-	err=$?
-	if [[ ${err} -ne 0 ]]; then
-		echo "Failed to validate genesis"
-		return
-	fi
-}
-
-# check if CLEAN is not set to false
-if [[ ${CLEAN} != "false" ]]; then
-	echo "Starting from a clean state"
-	from_scratch
-
-	# Generate VRF keypair (must be done after genesis file is created)
-	echo ""
-	echo "Generating VRF keypair..."
-	if ! generate_vrf_key "${HOME_DIR}" "${USE_DOCKER}"; then
-		echo "Warning: VRF key generation failed, but continuing..."
-		echo "Note: Multi-validator encryption features may not work without VRF keys"
-	fi
-fi
-
-echo "Starting node..."
-
-# Opens the RPC endpoint to outside connections
-sed -i -e 's/laddr = "tcp:\/\/127.0.0.1:26657"/laddr = "tcp:\/\/0.0.0.0:'"${RPC}"'"/g' "${HOME_DIR}"/config/config.toml
-sed -i -e 's/cors_allowed_origins = \[\]/cors_allowed_origins = \["*"\]/g' "${HOME_DIR}"/config/config.toml
-
-# REST endpoint
-sed -i -e 's/address = "tcp:\/\/localhost:1317"/address = "tcp:\/\/0.0.0.0:'"${REST}"'"/g' "${HOME_DIR}"/config/app.toml
-sed -i -e 's/enable = false/enable = true/g' "${HOME_DIR}"/config/app.toml
-sed -i -e 's/enabled-unsafe-cors = false/enabled-unsafe-cors = true/g' "${HOME_DIR}"/config/app.toml
-
-# peer exchange
-sed -i -e 's/pprof_laddr = "localhost:6060"/pprof_laddr = "localhost:'"${PROFF}"'"/g' "${HOME_DIR}"/config/config.toml
-sed -i -e 's/laddr = "tcp:\/\/0.0.0.0:26656"/laddr = "tcp:\/\/0.0.0.0:'"${P2P}"'"/g' "${HOME_DIR}"/config/config.toml
-
-# GRPC
-sed -i -e 's/address = "localhost:9090"/address = "0.0.0.0:'"${GRPC}"'"/g' "${HOME_DIR}"/config/app.toml
-sed -i -e 's/address = "localhost:9091"/address = "0.0.0.0:'"${GRPC_WEB}"'"/g' "${HOME_DIR}"/config/app.toml
-
-# Rosetta Api
-sed -i -e 's/address = ":8080"/address = "0.0.0.0:'"${ROSETTA}"'"/g' "${HOME_DIR}"/config/app.toml
-
-# JSON-RPC
-sed -i -e '/\[json-rpc\]/,/^\[/ s/enable = false/enable = true/' "${HOME_DIR}"/config/app.toml
-sed -i -e '/\[json-rpc\]/,/^\[/ s/address = "127.0.0.1:8545"/address = "0.0.0.0:'"${JSON_RPC}"'"/' "${HOME_DIR}"/config/app.toml
-sed -i -e '/\[json-rpc\]/,/^\[/ s/ws-address = "127.0.0.1:8546"/ws-address = "0.0.0.0:'"${JSON_RPC_WS}"'"/' "${HOME_DIR}"/config/app.toml
-
-# Faster blocks
-sed -i -e 's/timeout_commit = "5s"/timeout_commit = "'"${BLOCK_TIME}"'"/g' "${HOME_DIR}"/config/config.toml
-
-# Start the node (with or without Docker)
-if [[ "${USE_DOCKER}" == "true" ]]; then
-	echo "Starting node using Docker..."
-
-	# Check for detached mode via environment variable or prompt
-	DETACHED_MODE=""
-	if [[ "${DOCKER_DETACHED}" == "true" ]]; then
-		DETACHED_MODE="-d"
-		echo "Running in detached mode. Use 'docker logs -f sonr-testnode' to view logs."
-		echo "Stop with: docker stop sonr-testnode"
-	elif [ -t 0 ]; then
-		echo ""
-		echo "Would you like to run the node in detached mode (background)? [y/N]"
-		read -r -n 1 DETACH_RESPONSE
-		echo ""
-		if [[ "$DETACH_RESPONSE" =~ ^[Yy]$ ]]; then
-			DETACHED_MODE="-d"
-			echo "Running in detached mode. Use 'docker logs -f sonr-testnode' to view logs."
-			echo "Stop with: docker stop sonr-testnode"
-		else
-			echo "Running in foreground mode. Use Ctrl+C to stop."
-		fi
-	fi
-
-	# Determine if we're in a TTY (only for non-detached mode)
-	DOCKER_TTY_FLAG=""
-	if [ -t 0 ] && [ -z "$DETACHED_MODE" ]; then
-		DOCKER_TTY_FLAG="-it"
-	fi
-
-	docker run --rm ${DETACHED_MODE} ${DOCKER_TTY_FLAG} \
-		-v "${HOME_DIR}:/root/.sonr" \
-		--network host \
-		--name sonr-testnode \
-		onsonr/snrd:latest \
-		snrd start --pruning=nothing --minimum-gas-prices=0"${DENOM}" --rpc.laddr="tcp://0.0.0.0:${RPC}" --home /root/.sonr --json-rpc.api=eth,txpool,personal,net,debug,web3 --json-rpc.address="0.0.0.0:${JSON_RPC}" --json-rpc.ws-address="0.0.0.0:${JSON_RPC_WS}" --chain-id="${CHAIN_ID}"
-
-	# If running detached, show status
-	if [ -n "$DETACHED_MODE" ]; then
-		echo ""
-		echo "✅ Node started in background"
-		echo ""
-		echo "Useful commands:"
-		echo "  View logs:    docker logs -f sonr-testnode"
-		echo "  Stop node:    docker stop sonr-testnode"
-		echo "  Node status:  curl http://localhost:${RPC}/status | jq '.result.sync_info'"
-		echo ""
-	fi
-else
-	${BINARY} start --pruning=nothing --minimum-gas-prices=0"${DENOM}" --rpc.laddr="tcp://0.0.0.0:${RPC}" --home "${HOME_DIR}" --json-rpc.api=eth,txpool,personal,net,debug,web3 --json-rpc.address="0.0.0.0:${JSON_RPC}" --json-rpc.ws-address="0.0.0.0:${JSON_RPC_WS}" --chain-id="${CHAIN_ID}"
-fi

cmd/snrd/etc/process-compose.yaml

@@ -1,33 +0,0 @@
-version: "0.5"
-processes:
-  postgres-sonr:
-    command: |
-      # Generate pgsodium key if not set
-      if [ -z "${PGSODIUM_ROOT_KEY}" ]; then
-        echo "Generating pgsodium root key..."
-        export PGSODIUM_ROOT_KEY=$(openssl rand -hex 32)
-        echo "Generated key: ${PGSODIUM_ROOT_KEY:0:10}..."
-      fi
-
-      # Run the container using the pre-built image
-      docker run --rm \
-        --name ${POSTGRES_CONTAINER_NAME} \
-        -e POSTGRES_USER="${POSTGRES_USER:-postgres}" \
-        -e POSTGRES_DB="${POSTGRES_DB:-sonr}" \
-        -e PGSODIUM_ROOT_KEY="${PGSODIUM_ROOT_KEY}" \
-        -v ${POSTGRES_DATA_DIR}:/var/lib/postgresql/data \
-        -p ${POSTGRES_PORT:-5432}:5432 \
-        ${POSTGRES_DOCKER_IMAGE}
-    availability:
-      restart: "on_failure"
-      backoff_seconds: 5
-      max_restarts: 5
-    readiness_probe:
-      exec:
-        command: "docker exec ${POSTGRES_CONTAINER_NAME} pg_isready -U ${POSTGRES_USER:-postgres} -d ${POSTGRES_DB:-hway}"
-      initial_delay_seconds: 15
-      period_seconds: 10
-    shutdown:
-      command: "docker stop ${POSTGRES_CONTAINER_NAME} || true"
-      timeout_seconds: 30
-    log_location: "{{ .Virtenv }}/logs/postgres-sonr.log"

cmd/snrd/etc/testnet.sh

@@ -1,293 +0,0 @@
-#!/bin/bash
-set -eu
-
-# Load .env file if it exists
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-REPO_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
-if [ -f "${REPO_ROOT}/.env" ]; then
-    set -a
-    source "${REPO_ROOT}/.env"
-    set +a
-fi
-
-export CHAIN_ID=${CHAIN_ID:-"sonrtest_1-1"}
-export DENOM=${DENOM:-"usnr"}
-export KEYRING=${KEYRING:-"test"}
-export KEYALGO="eth_secp256k1"
-
-VALIDATORS=("alice" "bob" "carol")
-VAL_HOMES=("./val-alice" "./val-bob" "./val-carol")
-SENTRY_HOMES=("./sentry-alice" "./sentry-bob" "./sentry-carol")
-
-# Get mnemonics from environment
-declare -A MNEMONICS
-MNEMONICS["alice"]="$ALICE_MNEMONIC"
-MNEMONICS["bob"]="$BOB_MNEMONIC"
-MNEMONICS["carol"]="$CAROL_MNEMONIC"
-MNEMONICS["faucet"]="$FAUCET_MNEMONIC"
-
-echo "🚀 Initializing Sonr Testnet with 3 validators..."
-echo "Chain ID: $CHAIN_ID"
-echo "Denom: $DENOM"
-echo ""
-
-# Check if snrd is available locally
-if ! command -v snrd &> /dev/null; then
-    echo "❌ snrd binary not found in PATH"
-    echo "Please install snrd locally or add it to your PATH"
-    exit 1
-fi
-
-echo "✅ Using local snrd: $(which snrd)"
-echo ""
-
-# Function to initialize a validator node
-init_validator() {
-    local name=$1
-    local home_dir=$2
-    local mnemonic=$3
-
-    echo "📋 Initializing validator: $name"
-
-    local abs_home="${REPO_ROOT}/${home_dir#./}"
-    rm -rf "$abs_home" 2>/dev/null || true
-    mkdir -p "$abs_home"
-
-    echo | snrd --home "$abs_home" init "val-$name" --chain-id "$CHAIN_ID" --default-denom "$DENOM" --overwrite >/dev/null 2>&1
-
-    snrd --home "$abs_home" keys delete "$name" --keyring-backend "$KEYRING" -y 2>/dev/null || true
-
-    echo "$mnemonic" | snrd --home "$abs_home" keys add "$name" \
-        --keyring-backend "$KEYRING" \
-        --algo "$KEYALGO" \
-        --recover
-
-    update_config "$abs_home"
-}
-
-# Function to initialize a sentry node
-init_sentry() {
-    local name=$1
-    local home_dir=$2
-
-    echo "🛡️  Initializing sentry: $name"
-
-    local abs_home="${REPO_ROOT}/${home_dir#./}"
-    rm -rf "$abs_home" 2>/dev/null || true
-    mkdir -p "$abs_home"
-
-    echo | snrd --home "$abs_home" init "sentry-$name" --chain-id "$CHAIN_ID" --default-denom "$DENOM" --overwrite >/dev/null 2>&1
-
-    update_config "$abs_home"
-}
-
-# Function to update node config
-update_config() {
-    local abs_home=$1
-
-    sed -i 's/laddr = "tcp:\/\/127.0.0.1:26657"/laddr = "tcp:\/\/0.0.0.0:26657"/g' "${abs_home}/config/config.toml"
-    sed -i 's/cors_allowed_origins = \[\]/cors_allowed_origins = \["*"\]/g' "${abs_home}/config/config.toml"
-    sed -i 's/address = "tcp:\/\/localhost:1317"/address = "tcp:\/\/0.0.0.0:1317"/g' "${abs_home}/config/app.toml"
-    sed -i '/\[api\]/,/\[grpc\]/ s/enable = false/enable = true/' "${abs_home}/config/app.toml"
-    sed -i 's/enabled-unsafe-cors = false/enabled-unsafe-cors = true/g' "${abs_home}/config/app.toml"
-    sed -i 's/address = "localhost:9090"/address = "0.0.0.0:9090"/g' "${abs_home}/config/app.toml"
-    sed -i 's/address = "localhost:9091"/address = "0.0.0.0:9091"/g' "${abs_home}/config/app.toml"
-}
-
-# Function to update genesis
-update_genesis() {
-    local genesis_file="$1"
-
-    cat "$genesis_file" | \
-    jq '.consensus_params.block.max_gas="100000000"' | \
-    jq ".app_state.gov.params.min_deposit=[{\"denom\":\"$DENOM\",\"amount\":\"1000000\"}]" | \
-    jq '.app_state.gov.params.voting_period="30s"' | \
-    jq '.app_state.gov.params.expedited_voting_period="15s"' | \
-    jq ".app_state.evm.params.evm_denom=\"$DENOM\"" | \
-    jq '.app_state.evm.params.active_static_precompiles=["0x0000000000000000000000000000000000000100","0x0000000000000000000000000000000000000400","0x0000000000000000000000000000000000000800","0x0000000000000000000000000000000000000801","0x0000000000000000000000000000000000000802","0x0000000000000000000000000000000000000803","0x0000000000000000000000000000000000000804","0x0000000000000000000000000000000000000805"]' | \
-    jq '.app_state.erc20.params.native_precompiles=["0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE"]' | \
-    jq ".app_state.erc20.token_pairs=[{contract_owner:1,erc20_address:\"0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE\",denom:\"$DENOM\",enabled:true}]" | \
-    jq '.app_state.feemarket.params.no_base_fee=true' | \
-    jq '.app_state.feemarket.params.base_fee="0.000000000000000000"' | \
-    jq ".app_state.staking.params.bond_denom=\"$DENOM\"" | \
-    jq '.app_state.staking.params.min_commission_rate="0.050000000000000000"' | \
-    jq ".app_state.mint.params.mint_denom=\"$DENOM\"" | \
-    jq ".app_state.crisis.constant_fee={\"denom\":\"$DENOM\",\"amount\":\"1000\"}" | \
-    jq '.consensus.params.abci.vote_extensions_enable_height="1"' | \
-    jq '.app_state.tokenfactory.params.denom_creation_fee=[]' | \
-    jq '.app_state.tokenfactory.params.denom_creation_gas_consume=100000' \
-    > "$genesis_file.tmp" && mv "$genesis_file.tmp" "$genesis_file"
-}
-
-# Initialize all validators
-for i in "${!VALIDATORS[@]}"; do
-    name="${VALIDATORS[$i]}"
-    init_validator "$name" "${VAL_HOMES[$i]}" "${MNEMONICS[$name]}"
-done
-
-# Initialize all sentries
-for i in "${!VALIDATORS[@]}"; do
-    init_sentry "${VALIDATORS[$i]}" "${SENTRY_HOMES[$i]}"
-done
-
-echo ""
-echo "💰 Adding genesis accounts and creating genesis transactions..."
-
-BASE_ALLOCATION="100000000000000000000000000${DENOM}"
-STAKE_AMOUNT="30000000000000000000000${DENOM}"
-
-# Use alice's validator for genesis creation
-GENESIS_HOME="./val-alice"
-
-# Add genesis accounts for all validators
-GENESIS_ABS_HOME="${REPO_ROOT}/${GENESIS_HOME#./}"
-for i in "${!VALIDATORS[@]}"; do
-    name="${VALIDATORS[$i]}"
-    abs_home="${REPO_ROOT}/${VAL_HOMES[$i]#./}"
-    # Get address from each validator's keyring
-    addr=$(snrd --home "$abs_home" keys show "$name" --keyring-backend "$KEYRING" -a)
-    # Add to genesis using address
-    snrd --home "$GENESIS_ABS_HOME" genesis add-genesis-account "$addr" "$BASE_ALLOCATION" --append
-done
-
-# Add faucet account to genesis
-echo "💰 Creating faucet account..."
-snrd --home "$GENESIS_ABS_HOME" keys delete faucet --keyring-backend "$KEYRING" -y 2>/dev/null || true
-echo "${MNEMONICS["faucet"]}" | snrd --home "$GENESIS_ABS_HOME" keys add faucet \
-    --keyring-backend "$KEYRING" \
-    --algo "$KEYALGO" \
-    --recover
-FAUCET_ADDR=$(snrd --home "$GENESIS_ABS_HOME" keys show faucet --keyring-backend "$KEYRING" -a)
-FAUCET_ALLOCATION="${FAUCET_ALLOCATION:-500000000000000000000000000${DENOM}}"
-snrd --home "$GENESIS_ABS_HOME" genesis add-genesis-account "$FAUCET_ADDR" "$FAUCET_ALLOCATION" --append
-echo "  Faucet address: $FAUCET_ADDR"
-echo "  Faucet balance: $FAUCET_ALLOCATION"
-
-# Distribute genesis with all accounts to all validators before creating gentx
-for i in "${!VALIDATORS[@]}"; do
-    abs_home="${REPO_ROOT}/${VAL_HOMES[$i]#./}"
-    if [ "$abs_home" != "$GENESIS_ABS_HOME" ]; then
-        cp "$GENESIS_ABS_HOME/config/genesis.json" "$abs_home/config/genesis.json"
-    fi
-done
-
-# Create gentx for each validator
-for i in "${!VALIDATORS[@]}"; do
-    echo "Creating gentx for ${VALIDATORS[$i]}..."
-    abs_home="${REPO_ROOT}/${VAL_HOMES[$i]#./}"
-    snrd --home "$abs_home" genesis gentx "${VALIDATORS[$i]}" "$STAKE_AMOUNT" \
-        --keyring-backend "$KEYRING" \
-        --chain-id "$CHAIN_ID" \
-        --gas-prices "0${DENOM}"
-
-    # Copy gentx to genesis home (skip if same directory)
-    if [ "$abs_home" != "$GENESIS_ABS_HOME" ]; then
-        cp "${abs_home}/config/gentx"/* "$GENESIS_ABS_HOME/config/gentx/"
-    fi
-done
-
-# Collect gentxs
-echo "Collecting genesis transactions..."
-snrd --home "$GENESIS_ABS_HOME" genesis collect-gentxs
-
-# Update genesis parameters
-echo "Updating genesis parameters..."
-update_genesis "$GENESIS_ABS_HOME/config/genesis.json"
-
-# Validate genesis
-echo "Validating genesis..."
-snrd --home "$GENESIS_ABS_HOME" genesis validate-genesis
-
-# Distribute genesis to all nodes
-echo ""
-echo "📤 Distributing genesis to all nodes..."
-for home in "${VAL_HOMES[@]}" "${SENTRY_HOMES[@]}"; do
-    if [ "$home" != "$GENESIS_HOME" ]; then
-        abs_home="${REPO_ROOT}/${home#./}"
-        cp "$GENESIS_ABS_HOME/config/genesis.json" "$abs_home/config/genesis.json"
-    fi
-done
-
-echo ""
-echo "🔗 Setting up peer connections..."
-
-# Get validator node IDs
-declare -A VAL_IDS
-for i in "${!VALIDATORS[@]}"; do
-    abs_home="${REPO_ROOT}/${VAL_HOMES[$i]#./}"
-    VAL_IDS[${VALIDATORS[$i]}]=$(snrd --home "$abs_home" tendermint show-node-id | tr -d '\r\n')
-    echo "  val-${VALIDATORS[$i]}: ${VAL_IDS[${VALIDATORS[$i]}]}"
-done
-
-# Get sentry node IDs
-declare -A SENTRY_IDS
-for i in "${!VALIDATORS[@]}"; do
-    abs_home="${REPO_ROOT}/${SENTRY_HOMES[$i]#./}"
-    SENTRY_IDS[${VALIDATORS[$i]}]=$(snrd --home "$abs_home" tendermint show-node-id | tr -d '\r\n')
-    echo "  sentry-${VALIDATORS[$i]}: ${SENTRY_IDS[${VALIDATORS[$i]}]}"
-done
-
-# Configure validators to connect to their sentries only
-for i in "${!VALIDATORS[@]}"; do
-    name="${VALIDATORS[$i]}"
-    abs_home="${REPO_ROOT}/${VAL_HOMES[$i]#./}"
-    sed -i "s/persistent_peers = \"\"/persistent_peers = \"${SENTRY_IDS[$name]}@sentry-$name:26656\"/g" "${abs_home}/config/config.toml"
-done
-
-# Configure sentries to connect to their validators and other sentries
-for i in "${!VALIDATORS[@]}"; do
-    name="${VALIDATORS[$i]}"
-    abs_home="${REPO_ROOT}/${SENTRY_HOMES[$i]#./}"
-
-    # Build seeds list (all other sentries)
-    seeds=""
-    for j in "${!VALIDATORS[@]}"; do
-        other_name="${VALIDATORS[$j]}"
-        if [ "$name" != "$other_name" ]; then
-            if [ -n "$seeds" ]; then
-                seeds="${seeds},"
-            fi
-            seeds="${seeds}${SENTRY_IDS[$other_name]}@sentry-$other_name:26656"
-        fi
-    done
-
-    # Set persistent peer to own validator and seeds to other sentries
-    sed -i "s/persistent_peers = \"\"/persistent_peers = \"${VAL_IDS[$name]}@val-$name:26656\"/g" "${abs_home}/config/config.toml"
-    sed -i "s/seeds = \"\"/seeds = \"$seeds\"/g" "${abs_home}/config/config.toml"
-    sed -i "s/private_peer_ids = \"\"/private_peer_ids = \"${VAL_IDS[$name]}\"/g" "${abs_home}/config/config.toml"
-done
-
-echo ""
-echo "✅ Testnet initialization complete!"
-echo ""
-echo "🎯 Validator Addresses:"
-for i in "${!VALIDATORS[@]}"; do
-    abs_home="${REPO_ROOT}/${VAL_HOMES[$i]#./}"
-    addr=$(snrd --home "$abs_home" keys show "${VALIDATORS[$i]}" --keyring-backend "$KEYRING" -a | tr -d '\r\n')
-    echo "  ${VALIDATORS[$i]}: $addr"
-done
-
-echo ""
-echo "💰 Faucet Address:"
-echo "  faucet: $FAUCET_ADDR"
-
-echo ""
-echo "📡 Service Endpoints (via Cloudflare Tunnel):"
-echo "  Alice RPC:       https://alice-rpc.sonr.land"
-echo "  Alice REST:      https://alice-rest.sonr.land"
-echo "  Alice gRPC:      https://alice-grpc.sonr.land"
-echo "  Alice EVM:       https://alice-evm.sonr.land"
-echo "  Bob RPC:         https://bob-rpc.sonr.land"
-echo "  Bob REST:        https://bob-rest.sonr.land"
-echo "  Bob gRPC:        https://bob-grpc.sonr.land"
-echo "  Bob EVM:         https://bob-evm.sonr.land"
-echo "  Carol RPC:       https://carol-rpc.sonr.land"
-echo "  Carol REST:      https://carol-rest.sonr.land"
-echo "  Carol gRPC:      https://carol-grpc.sonr.land"
-echo "  Carol EVM:       https://carol-evm.sonr.land"
-echo "  IPFS API:        https://ipfs-api.sonr.land"
-echo "  IPFS Gateway:    https://ipfs-gateway.sonr.land"
-echo ""
-echo "🚀 Start testnet with: docker compose up -d"
-echo "📊 View logs with:     docker compose logs -f"
-echo "🛑 Stop testnet with:  docker compose down"

cmd/vault/CHANGELOG.md

@@ -0,0 +1,4 @@
+## vault/v0.0.1 (2025-10-03)
+
+
+- feat(vault): introduce assembly of the initial vault

context.go

@@ -1 +0,0 @@
-package sonr

packages/com/.cz.toml

@@ -1,6 +1,6 @@
 [tool.commitizen]
 name = "cz_customize"
-tag_format = "pkg-com/v$version"
+tag_format = "@sonr.io/com@v$version"
 ignored_tag_formats = ["*/v${version}", "v${version}"]
 version_scheme = "semver"
 version_provider = "npm"

packages/es/.cz.toml

@@ -1,6 +1,6 @@
 [tool.commitizen]
 name = "cz_customize"
-tag_format = "pkg-es/v$version"
+tag_format = "@sonr.io/es@v$version"
 ignored_tag_formats = ["*/v${version}", "v${version}"]
 version_scheme = "semver"
 version_provider = "npm"

packages/pkl/.cz.toml

@@ -1,6 +1,6 @@
 [tool.commitizen]
 name = "cz_customize"
-tag_format = "pkg-pkl/v$version"
+tag_format = "@sonr.io/pkl@v$version"
 ignored_tag_formats = ["*/v${version}", "v${version}"]
 version_scheme = "semver"
 version_provider = "npm"

packages/sdk/.cz.toml

@@ -1,6 +1,6 @@
 [tool.commitizen]
 name = "cz_customize"
-tag_format = "pkg-sdk/v$version"
+tag_format = "@sonr.io/sdk@v$version"
 ignored_tag_formats = ["*/v${version}", "v${version}"]
 version_scheme = "semver"
 version_provider = "npm"

packages/ui/.cz.toml

@@ -1,6 +1,6 @@
 [tool.commitizen]
 name = "cz_customize"
-tag_format = "pkg-ui/v$version"
+tag_format = "@sonr.io/ui@v$version"
 ignored_tag_formats = ["*/v${version}", "v${version}"]
 version_scheme = "semver"
 version_provider = "npm"

web/auth/.cz.toml

@@ -1,6 +1,6 @@
 [tool.commitizen]
 name = "cz_customize"
-tag_format = "web-auth/v$version"
+tag_format = "@sonr.io/auth@v$version"
 ignored_tag_formats = ["*/v${version}", "v${version}"]
 version_scheme = "semver"
 version_provider = "npm"

web/dash/.cz.toml

@@ -1,6 +1,6 @@
 [tool.commitizen]
 name = "cz_customize"
-tag_format = "web-dash/v$version"
+tag_format = "@sonr.io/dash@v$version"
 ignored_tag_formats = ["*/v${version}", "v${version}"]
 version_scheme = "semver"
 version_provider = "npm"