Comprehensive Configuration

./fractalengine --rpc-server-host localhost --rpc-server-port 8891

--database-url "sqlite://fractal-engine.db"

environment:
  - DATABASE_URL=sqlite:///root/storage/fractal-engine.db

--database-url "postgres://username:password@host:port/database?sslmode=disable"

environment:
  - DATABASE_URL=postgres://fractalstore:fractalstore@fractalstore:5432/fractalstore?sslmode=disable

./fractalengine \
  --doge-scheme http \
  --doge-host localhost \
  --doge-port 22556 \
  --doge-user rpcuser \
  --doge-password rpcpassword

regtest=1
rpcuser=${RPC_USER}
rpcpassword=${RPC_PASSWORD}
rpcport=${RPC_PORT}
server=1
txindex=1
rpcbind=0.0.0.0
rpcallowip=0.0.0.0/0

./fractalengine \
  --doge-net-network tcp \
  --doge-net-address 0.0.0.0:8086 \
  --doge-net-web-address 0.0.0.0:8085

./fractalengine \
  --api-rate-limit-per-second 20 \
  --invoice-limit 50 \
  --buy-offer-limit 5 \
  --sell-offer-limit 5

./fractalengine \
  --rpc-server-host 0.0.0.0 \
  --rpc-server-port 8891 \
  --doge-scheme https \
  --doge-host mainnet-node.example.com \
  --doge-port 22555 \
  --doge-user ${MAINNET_RPC_USER} \
  --doge-password ${MAINNET_RPC_PASS} \
  --database-url "postgres://user:pass@db.example.com:5432/fractal?sslmode=require" \
  --api-rate-limit-per-second 50 \
  --invoice-limit 1000

./fractalengine \
  --rpc-server-host 0.0.0.0 \
  --rpc-server-port 8891 \
  --doge-scheme http \
  --doge-host testnet-node.example.com \
  --doge-port 44555 \
  --doge-user testuser \
  --doge-password testpass \
  --database-url "sqlite://testnet-fractal.db" \
  --api-rate-limit-per-second 20

./fractalengine \
  --rpc-server-host 0.0.0.0 \
  --rpc-server-port 8891 \
  --doge-scheme http \
  --doge-host localhost \
  --doge-port 22556 \
  --doge-user test \
  --doge-password test \
  --database-url "sqlite://fractal-engine.db" \
  --api-rate-limit-per-second 10

# docker-compose.yml
services:
  fractalengine:
    environment:
      - DATABASE_URL=sqlite:///root/storage/fractal-engine.db
      - DOGE_NET_ADDRESS=/tmp/dogenet.sock
      - DOGE_NET_NETWORK=unix
      - DOGE_PORT=22556
      - FRACTAL_PORT=8891

version: "3.8"
services:
  fractalengine:
    build:
      context: .
      dockerfile: Dockerfile.fractalengine
    ports:
      - "${FRACTAL_PORT:-8891}:8891"
    environment:
      - DATABASE_URL=${DATABASE_URL}
      - DOGE_NET_ADDRESS=${DOGE_NET_ADDRESS}
      - DOGE_NET_NETWORK=${DOGE_NET_NETWORK}
      - DOGE_PORT=${DOGE_PORT}
      - FRACTAL_PORT=${FRACTAL_PORT}
    depends_on:
      - dogecoin
      - fractalstore

fractal_engine_host = "localhost"
fractal_engine_port = "8891"
balance_master_host = "localhost"
balance_master_port = "8899"
doge_scheme = "http"
doge_host = "localhost"
doge_port = "22556"
doge_user = "test"
doge_password = "test"
key_labels = ["seller", "buyer"]
active_key = "seller"

--database-url "postgres://user:pass@host:5432/db?sslmode=require&sslcert=client.crt&sslkey=client.key&sslrootcert=ca.crt"

#!/bin/bash
./fractalengine \
  --rpc-server-host 0.0.0.0 \
  --rpc-server-port 8891 \
  --doge-scheme https \
  --doge-host ${DOGE_NODE_HOST} \
  --doge-port 22555 \
  --doge-user ${DOGE_RPC_USER} \
  --doge-password ${DOGE_RPC_PASS} \
  --database-url "${DATABASE_URL}" \
  --api-rate-limit-per-second 100 \
  --invoice-limit 1000 \
  --buy-offer-limit 10 \
  --sell-offer-limit 10 \
  --persist-follower true

#!/bin/bash
./fractalengine \
  --rpc-server-host localhost \
  --rpc-server-port 8891 \
  --doge-scheme http \
  --doge-host localhost \
  --doge-port 22556 \
  --doge-user test \
  --doge-password test \
  --database-url "sqlite://fractal-dev.db" \
  --api-rate-limit-per-second 10 \
  --invoice-limit 10 \
  --buy-offer-limit 3 \
  --sell-offer-limit 3

# Instance Configuration
INSTANCE_ID=1
SUBNET_BASE=100

# Port Configuration
FRACTAL_PORT=8891
DOGE_PORT=22556
POSTGRES_PORT=5432
DOGENET_PORT=8086
DOGENET_WEB_PORT=8085
DOGENET_BIND_PORT=42069
BALANCE_MASTER_PORT=8899

# Network Configuration
DOGE_NET_ADDRESS=0.0.0.0:42069
DOGE_NET_NETWORK=tcp

# Database Configuration
DATABASE_URL=postgres://fractalstore:fractalstore@fractalstore:5432/fractalstore?sslmode=disable

# DogeNet Configuration
DOGE_NET_HANDLER=true

# Test database connection
psql "${DATABASE_URL}" -c "SELECT 1;"

# Test Dogecoin node connection
curl -u "${DOGE_USER}:${DOGE_PASSWORD}" \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"1.0","id":"test","method":"getblockchaininfo","params":[]}' \
  "${DOGE_SCHEME}://${DOGE_HOST}:${DOGE_PORT}/"

# Verify network connectivity
nc -zv ${DOGE_HOST} ${DOGE_PORT}

#!/bin/bash
# validate-config.sh

set -e

echo "Validating Fractal Engine configuration..."

# Check required environment variables
required_vars=(
  "DATABASE_URL"
  "DOGE_HOST"
  "DOGE_PORT"
  "DOGE_USER"
  "DOGE_PASSWORD"
)

for var in "${required_vars[@]}"; do
  if [[ -z "${!var}" ]]; then
    echo "ERROR: Required variable $var is not set"
    exit 1
  fi
done

echo "✓ All required variables are set"

# Test database connectivity
echo "Testing database connection..."
if command -v psql >/dev/null 2>&1; then
  psql "${DATABASE_URL}" -c "SELECT 1;" >/dev/null
  echo "✓ Database connection successful"
fi

# Test Dogecoin node
echo "Testing Dogecoin node connection..."
response=$(curl -s -u "${DOGE_USER}:${DOGE_PASSWORD}" \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"1.0","id":"test","method":"getblockchaininfo","params":[]}' \
  "${DOGE_SCHEME:-http}://${DOGE_HOST}:${DOGE_PORT}/")

if echo "$response" | grep -q "result"; then
  echo "✓ Dogecoin node connection successful"
else
  echo "ERROR: Failed to connect to Dogecoin node"
  echo "Response: $response"
  exit 1
fi

echo "✓ Configuration validation complete"

Solutions:
1. Verify DATABASE_URL format
2. Check database server status
3. Validate credentials
4. Ensure database exists
5. Check network connectivity

# Check file permissions
ls -la fractal-engine.db

# Check disk space
df -h

# Verify SQLite installation
sqlite3 --version

# Test connection
pg_isready -h hostname -p port -U username

# Check server logs
docker logs fractalstore-1

Solutions:
1. Verify node is running
2. Check RPC credentials
3. Validate port configuration
4. Test network connectivity
5. Review node logs

# Test RPC connectivity
curl -u test:test \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"1.0","id":"test","method":"getblockchaininfo","params":[]}' \
  http://localhost:22556/

# Check Docker container
docker logs dogecoin-1

# Verify port binding
netstat -tulpn | grep 22556

Solutions:
1. Check socket permissions (unix sockets)
2. Verify port availability (TCP)
3. Check firewall rules
4. Validate key pair generation

Solutions:
1. Increase rate limit values
2. Implement client-side throttling
3. Review API usage patterns
4. Monitor system resources

# Add debug flags (if available)
./fractalengine --log-level debug [other-flags...]

# Monitor system resources
htop
iostat 1

# Check service health
curl http://localhost:8891/health

# Expected response: 200 OK

#!/bin/bash
# health-check.sh

components=(
  "fractalengine:8891/health"
  "dogenet:8085/health"
  "fractalstore:5432"
)

for component in "${components[@]}"; do
  if curl -sf "http://${component}" >/dev/null 2>&1; then
    echo "✓ ${component} is healthy"
  else
    echo "✗ ${component} is unhealthy"
  fi
done