Samourai

#!/usr/bin/env python3
import os
import wget
import tarfile
import subprocess
import requests
import shutil
import time
import random 
import string

def download_file(url, filename):
    """Downloads a file from the specified URL to the specified filename."""
    downloads_directory = os.path.join(os.path.expanduser('~'), 'Downloads')
    filepath = os.path.join(downloads_directory, filename)

    print('Downloading file...')
    wget.download(url, filepath)

def extract_file(filename):
    """Extracts a file from a tar archive."""
    filepath = os.path.join(os.path.expanduser('~'), 'Downloads', filename)
    if not os.path.exists(filepath):
        print('File does not exist.')
        return

    with open(filepath, 'rb') as f:
        tar = tarfile.open(fileobj=f)
        tar.extractall(os.path.join(os.path.expanduser('~'), 'Downloads'))

def create_directories():
    """Creates the necessary directories."""
    dojo_app_directory = os.path.join(os.path.expanduser('~'), 'dojo-app')
    os.makedirs(dojo_app_directory, exist_ok=True)

if __name__ == '__main__':
    create_directories()

    url = 'https://code.samourai.io/dojo/samourai-dojo/-/archive/v1.20.0/samourai-dojo-v1.20.0.tar.gz'
    filename = 'samourai-dojo-v1.20.0.tar.gz'

    download_file(url, filename)
    extract_file(filename)

    # Perform the mv command with sudo privileges
    source_directory = os.path.join(os.path.expanduser('~'), 'Downloads', 'samourai-dojo-v1.20.0')
    destination_directory = os.path.join(os.path.expanduser('~'), 'dojo-app')
    subprocess.run(['sudo', 'mv', source_directory, destination_directory])

    print('The file has been downloaded, extracted, and moved to the dojo-app directory.')

def delete_directory(directory):
    """Deletes a directory with sudo privileges."""
    subprocess.run(['sudo', 'rm', '-r', directory])

if __name__ == '__main__':
    dojo_app_directory = os.path.join(os.path.expanduser('~'), 'dojo-app')
    conf_directory = os.path.join(dojo_app_directory, 'samourai-dojo-v1.20.0/docker/my-dojo/conf')

    delete_directory(conf_directory)

    print('The conf directory has been deleted with sudo privileges.')

def create_directory(directory):
    """Creates a directory with sudo privileges."""
    subprocess.run(['sudo', 'mkdir', '-p', directory])

if __name__ == '__main__':
    dojo_app_directory = os.path.join(os.path.expanduser('~'), 'dojo-app')
    conf_directory = os.path.join(dojo_app_directory, 'samourai-dojo-v1.20.0/docker/my-dojo/conf')

    create_directory(conf_directory)

    print('The conf directory has been created with sudo privileges.')

ipaddress = "ip_address"
rpcusername = "rpc_username"
rpcpassword = "rpc_password"

def create_docker_bitcoind_conf():
    conf_directory = os.path.expanduser('~/dojo-app/samourai-dojo-v1.20.0/docker/my-dojo/conf')
    filename = 'docker-bitcoind.conf.tpl'
    filepath = os.path.join(conf_directory, filename)

    bitcoind_content = '''\
#########################################
# CONFIGURATION OF BITCOIND CONTAINER
#########################################

# User account used for rpc access to bitcoind
# Type: alphanumeric
BITCOIND_RPC_USER={rpcusername}

# Password of user account used for rpc access to bitcoind
# Type: alphanumeric
BITCOIND_RPC_PASSWORD={rpcpassword}

# Max number of connections to network peers
# Type: integer
BITCOIND_MAX_CONNECTIONS=16

# Mempool maximum size in MB
# Type: integer
BITCOIND_MAX_MEMPOOL=1024

# Db cache size in MB
# Type: integer
BITCOIND_DB_CACHE=1024

# Number of threads to service RPC calls
# Type: integer
BITCOIND_RPC_THREADS=6

# RPC Work queue size
# Type: integer
BITCOIND_RPC_WORK_QUEUE=128

# Mempool expiry in hours
# Defines how long transactions stay in your local mempool before expiring
# Type: integer
BITCOIND_MEMPOOL_EXPIRY=72

# Min relay tx fee in BTC
# Type: numeric
BITCOIND_MIN_RELAY_TX_FEE=0.00001

# Allow incoming connections
# This parameter is inactive if BITCOIND_INSTALL is set to 'off'
# Values: on | off
BITCOIND_LISTEN_MODE=on

#
# EXPERT SETTINGS
#
#
# EPHEMERAL ONION ADDRESS AND BLOOM FILTERS FOR BITCOIND
# THESE PARAMETERS HAVE NO EFFECT IF BITCOIND_INSTALL IS SET TO OFF
#

# Generate a new onion address for bitcoind when Dojo is launched
# Activation of this option is recommended for improved privacy.
# Values: on | off
BITCOIND_EPHEMERAL_HS=on

# Enable bloom filters for other apps to leverage light client mode
# BITCOIND_EPHEMERAL_HS should be set to "off" otherwise new connection will need to be setup after restart
# Values: on | off
BITCOIND_BLOOM_FILTERS=off

#
# EXPOSE BITCOIND RPC API AND ZMQ NOTIFICATIONS TO EXTERNAL APPS
# THESE PARAMETERS HAVE NO EFFECT IF BITCOIND_INSTALL IS SET TO OFF
#
# Expose the RPC API to external apps
# Warning: Do not expose your RPC API to the internet!
# See BITCOIND_RPC_EXTERNAL_IP
# Value: on | off
BITCOIND_RPC_EXTERNAL=off

# IP address used to expose the RPC API to external apps
# This parameter is inactive if BITCOIND_RPC_EXTERNAL isn't set to 'on'
# Warning: Do not expose your RPC API to the internet!
# Recommended value:
#   linux: 127.0.0.1
#   macos or windows: IP address of the VM running the Docker host
# Type: string
BITCOIND_RPC_EXTERNAL_IP=127.0.0.1

#
#
# INSTALL AND RUN BITCOIND INSIDE DOCKER
#

# Install and run bitcoind inside Docker
# Set this option to 'off' to use a bitcoind hosted outside of Docker (not recommended)
# Value: on | off
BITCOIND_INSTALL=off

# IP address of bitcoind used by Dojo
# Set the value to 172.28.1.5 if BITCOIND_INSTALL is set to 'on'
# Type: string
BITCOIND_IP={ipaddress}

# Port of the RPC API
# Set the value to 28256 if BITCOIND_INSTALL is set to 'on'
# Type: integer
BITCOIND_RPC_PORT=8332

# Port exposing ZMQ notifications for raw transactions
# Set the value to 9501 if BITCOIND_INSTALL is set to 'on'
# Type: integer
BITCOIND_ZMQ_RAWTXS=28333

# Port exposing ZMQ notifications for block hashes
# Set value to 9502 if BITCOIND_INSTALL is set to 'on'
# Type: integer
BITCOIND_ZMQ_BLK_HASH=28334


#
# SHUTDOWN
#

# Max delay for bitcoind shutdown (expressed in seconds)
# Defines how long Dojo waits for a clean shutdown of bitcoind before shutting >
# This parameter is inactive if BITCOIND_INSTALL is set to 'off'
# Type: integer
BITCOIND_SHUTDOWN_DELAY=180
'''

    # Use sudo to write the file with elevated privileges
    subprocess.run(['sudo', 'tee', filepath], input=bitcoind_content.format(ipaddress=ipaddress, rpcusername=rpcusername, rpcpassword=rpcpassword), text=True, check=True)

def create_docker_explorer_conf():
    conf_directory = os.path.expanduser('~/dojo-app/samourai-dojo-v1.20.0/docker/my-dojo/conf')
    filename = 'docker-explorer.conf.tpl'
    filepath = os.path.join(conf_directory, filename)

    explorer_content = '''\
#########################################
# CONFIGURATION OF EXPLORER CONTAINER
#########################################

# Install and run a block explorer inside Dojo (recommended)
# Value: on | off
EXPLORER_INSTALL=off
'''

    # Use sudo to write the file with elevated privileges
    subprocess.run(['sudo', 'tee', filepath], input=explorer_content, text=True, check=True)

def create_docker_common_conf():
    conf_directory = os.path.expanduser('~/dojo-app/samourai-dojo-v1.20.0/docker/my-dojo/conf')
    filename = 'docker-common.conf.tpl'
    filepath = os.path.join(conf_directory, filename)

    common_content = '''\
#
# EXPERT AND DEV SETTINGS
#


#
# NETWORK ENVIRONMENT
#

# Select a Bitcoin network
# Do not modify this value after the first install
# Value: mainnet | testnet
COMMON_BTC_NETWORK=mainnet
'''

    # Use sudo to write the file with elevated privileges
    subprocess.run(['sudo', 'tee', filepath], input=common_content, text=True, check=True)

def create_docker_indexer_conf():
    conf_directory = os.path.expanduser('~/dojo-app/samourai-dojo-v1.20.0/docker/my-dojo/conf')
    filename = 'docker-indexer.conf.tpl'
    filepath = os.path.join(conf_directory, filename)

    indexer_content = '''\
#########################################
# CONFIGURATION OF A LOCAL INDEXER
#########################################

# Install and run a local indexer inside Docker
# Set this option to 'off' to use an indexer hosted outside of Docker
# or when using a different data source (local bitcoind, OXT)
# Value: on | off
INDEXER_INSTALL=off

# Choice of the Indexer you would like to install:
# addrindexrs - basic but fast indexer for your Dojo - takes 8-12 hrs to index
# Fulcrum - fast indexer, can be used as Electrum server for personal use - takes 2-3 days to index
# Value: addrindexrs | fulcrum
INDEXER_TYPE=fulcrum

# IP address of the local indexer used by Dojo
# Set the value to 172.28.1.6 if INDEXER_INSTALL is set to 'on'
# Type: string
INDEXER_IP={ipaddress}

# Port of the RPC API
# Set the value to 50001 if INDEXER_INSTALL is set to 'on'
# Type: integer
INDEXER_RPC_PORT=50002

# Support of batch requests by the local indexer
# Set the value to 'active' if INDEXER_TYPE is set to 'fulcrum' or you're using an external Electrum server with RPC batching support
# Value: active | inactive
INDEXER_BATCH_SUPPORT=active

# Choose between TCP and TLS transport when using an external Electrum server
# Value: tcp | tls
INDEXER_PROTOCOL=tls

# Expose the Electrum API to external apps
# Has an effect only if INDEXER_TYPE=fulcrum
# Warning: Do not expose your Electrum API to the internet!
# See INDEXER_EXTERNAL_IP
# Value: on | off
INDEXER_EXTERNAL=off

# IP address used to expose the Electrum API to external apps
# This parameter is inactive if INDEXER_EXTERNAL isn't set to 'on'
# Warning: Do not expose your RPC API to the internet!
# Recommended value:
#   linux: 127.0.0.1
#   macOS or Windows: IP address of the VM running the Docker host
# Type: string
INDEXER_EXTERNAL_IP=127.0.0.1

#
# EXPERT SETTINGS
# (ACTIVE IF INDEXER_INSTALL IS SET TO ON)
#

# Number of blocks to get in one JSONRPC request from bitcoind
# Type: integer
INDEXER_BATCH_SIZE=10

# Total size of block txids to cache (in MB)
# Type: integer
INDEXER_BLK_TXIDS_CACHE_SIZE_MB=10

# Number of transactions to lookup before returning an error
# Type: integer
INDEXER_TXID_LIMIT=501
'''

    # Use sudo to write the file with elevated privileges
    subprocess.run(['sudo', 'tee', filepath], input=indexer_content.format(ipaddress=ipaddress), text=True, check=True)

# Create the configuration files
create_docker_bitcoind_conf()
create_docker_explorer_conf()
create_docker_common_conf()
create_docker_indexer_conf()
def generate_random_password(length):
    characters = string.ascii_letters + string.digits
    password = ''.join(random.choice(characters) for _ in range(length))
    return password

def create_docker_mysql_conf():
    conf_directory = os.path.expanduser('~/dojo-app/samourai-dojo-v1.20.0/docker/my-dojo/conf')
    filename = 'docker-mysql.conf.tpl'
    filepath = os.path.join(conf_directory, filename)

    # Generate random passwords
    MYSQL_ROOT_PASSWORD = generate_random_password(12)
    MYSQL_USER = "samourai"
    MYSQL_PASSWORD = generate_random_password(10)

    content = '''\
#########################################
# CONFIGURATION OF MYSQL CONTAINER
#########################################

# Password of MySql root account
# Warning: This option must not be modified after the first installation
# Type: alphanumeric
MYSQL_ROOT_PASSWORD={MYSQL_ROOT_PASSWORD}

# User account used for db access
# Warning: This option must not be modified after the first installation
# Type: alphanumeric
MYSQL_USER={MYSQL_USER}

# Password of user account
# Warning: This option must not be modified after the first installation
# Type: alphanumeric
MYSQL_PASSWORD={MYSQL_PASSWORD}

# MySQL configuration profile
#   default = default configuration parameters
#   low_mem = configuration minimizing the RAM consumed by the database
# Values: default | low_mem
MYSQL_CONF_PROFILE=default
'''

    # Use sudo to write the file with elevated privileges
    command = f'echo "{content.format(MYSQL_ROOT_PASSWORD=MYSQL_ROOT_PASSWORD, MYSQL_USER=MYSQL_USER, MYSQL_PASSWORD=MYSQL_PASSWORD)}" | sudo tee {filepath} > /dev/null'
    subprocess.run(command, shell=True)

# Create the configuration file
create_docker_mysql_conf()

def generate_random_password(length):
    characters = string.ascii_letters + string.digits
    password = ''.join(random.choice(characters) for _ in range(length))
    return password

def create_docker_node_conf():
    conf_directory = os.path.expanduser('~/dojo-app/samourai-dojo-v1.20.0/docker/my-dojo/conf')
    filename = 'docker-node.conf.tpl'
    filepath = os.path.join(conf_directory, filename)

    # Generate random passwords
    NODE_API_KEY = generate_random_password(20)
    NODE_ADMIN_KEY = generate_random_password(20)
    NODE_PAYMENT_CODE = generate_random_password(20)
    NODE_JWT_SECRET = generate_random_password(20)

    content = '''\
#########################################
# CONFIGURATION OF NODE JS CONTAINER
#########################################

# API key required for accessing the services provided by the server
# Keep this API key secret!
# Provide a value with a high entropy!
# Type: alphanumeric
NODE_API_KEY={NODE_API_KEY}

# API key required for accessing the admin/maintenance services provided by the server
# Keep this Admin key secret!
# Provide a value with a high entropy!
# Type: alphanumeric
NODE_ADMIN_KEY={NODE_ADMIN_KEY}

# BIP47 Payment Code used for admin authentication
# Type: alphanumeric
NODE_PAYMENT_CODE={NODE_PAYMENT_CODE}

# Secret used by the server for signing Json Web Token
# Keep this value secret!
# Provide a value with a high entropy!
# Type: alphanumeric
NODE_JWT_SECRET={NODE_JWT_SECRET}

# Indexer or third-party service used for imports and rescans of addresses
# Values: local_bitcoind | local_indexer | third_party_explorer
NODE_ACTIVE_INDEXER=local_indexer

# FEE TYPE USED FOR FEES ESTIMATIONS BY BITCOIND
# Allowed values are ECONOMICAL or CONSERVATIVE
NODE_FEE_TYPE=ECONOMICAL
'''

    # Use sudo to write the file with elevated privileges
    command = f'echo "{content.format(NODE_API_KEY=NODE_API_KEY, NODE_ADMIN_KEY=NODE_ADMIN_KEY, NODE_PAYMENT_CODE=NODE_PAYMENT_CODE, NODE_JWT_SECRET=NODE_JWT_SECRET)}" | sudo tee {filepath} > /dev/null'
    subprocess.run(command, shell=True)

# Create the configuration file
create_docker_node_conf()

def create_docker_tor_conf():
    conf_directory = os.path.expanduser('~/dojo-app/samourai-dojo-v1.20.0/docker/my-dojo/conf')
    filename = 'docker-tor.conf.tpl'
    filepath = os.path.join(conf_directory, filename)

    content = '''\
#########################################
# CONFIGURATION OF TOR CONTAINER
#########################################

# Port of the Tor Socks proxy
# Type: integer
TOR_SOCKS_PORT=9050

#
# USE TOR BRIDGES
#
# To get Tor bridges head over to https://bridges.torproject.org and click on
# Get bridges, then you will see a form with "Advanced Options" header
# leave the Pluggable Transport as obfs4 and click on Get Bridges button
# solve the captcah, you will get the bridge addresses (usually 3)
#
# Then, set TOR_USE_BRIDGES to "on" and initialize the TOR_BRIDGE_n options
# with the 3 lines generated by the online tool.
#
# For instance, if the first line generated by the tool is:
#   obfs4 24.106.248.94:65531 B9EFBC5... cert=yrX... iat-mode=0
# You will have to set:
#   TOR_BRIDGE_1="obfs4 24.106.248.94:65531 B9EFBC5... cert=yrX... iat-mode=0"
#
# Activate the use of Tor bridges
# Value: on | off
TOR_USE_BRIDGES=off

# Bridge 1
TOR_BRIDGE_1=ToBeDefined

# Bridge 2
TOR_BRIDGE_2=ToBeDefined

# Bridge 3
TOR_BRIDGE_3=ToBeDefined
'''

    # Use sudo to write the file with elevated privileges
    command = f'echo "{content}" | sudo tee {filepath} > /dev/null'
    subprocess.run(command, shell=True)

# Create the configuration file
create_docker_tor_conf()

def create_docker_whirlpool_conf():
    conf_directory = os.path.expanduser('~/dojo-app/samourai-dojo-v1.20.0/docker/my-dojo/conf')
    filename = 'docker-whirlpool.conf.tpl'
    filepath = os.path.join(conf_directory, filename)

    content = '''\
#########################################
# CONFIGURATION OF WHIRLPOOL CONTAINER
#########################################

# Install and run an instance of whirlpool-cli inside Docker
# Value: on | off
WHIRLPOOL_INSTALL=off

# Resynchronize mix counters on startup (startup will be slower)
# Value: on | off
WHIRLPOOL_RESYNC=off

# Contact coordinator through its onion address or clearnet address
# Set to on for onion address, set to off for clearnet address
# Value: on | off
WHIRLPOOL_COORDINATOR_ONION=on

#
# EXPERT SETTINGS
#

# Activate debug logs
# Value: on | off
WHIRLPOOL_DEBUG=off

# Activate more debug logs
# Value: on | off
WHIRLPOOL_DEBUG_CLIENT=off
'''

    # Use sudo to write the file with elevated privileges
    command = f'echo "{content}" | sudo tee {filepath} > /dev/null'
    subprocess.run(command, shell=True)

# Create the configuration file
create_docker_whirlpool_conf()

def run_dojo_install():
    directory = os.path.expanduser('~/dojo-app/samourai-dojo-v1.20.0/docker/my-dojo')
    command = './dojo.sh install'

    # Use sudo to execute the command with elevated privileges
    subprocess.run(['sudo', '-E', 'bash', '-c', command], cwd=directory)

# Run the dojo.sh install command
run_dojo_install()

def run_dojo_onion():
    directory = os.path.expanduser('~/dojo-app/samourai-dojo-v1.20.0/docker/my-dojo')
    command = './dojo.sh onion'

    # Use sudo to execute the command with elevated privileges
    result = subprocess.run(['sudo', '-E', 'bash', '-c', command], cwd=directory, capture_output=True, text=True)
    
    # Save the result to a file
    with open('.PasswordsSamourai', 'w') as password_file:
        password_file.write(result.stdout)

# Run the dojo.sh onion command and save the result to a file
run_dojo_onion()

def get_node_api_key_from_conf():
    conf_directory = os.path.expanduser('~/dojo-app/samourai-dojo-v1.20.0/docker/my-dojo/conf')
    filename = 'docker-node.conf.tpl'
    filepath = os.path.join(conf_directory, filename)

    with open(filepath, 'r') as file:
        content = file.read()
    
    # Find and extract the value of NODE_API_KEY
    start_index = content.find('NODE_API_KEY=')
    if start_index != -1:
        start_index += len('NODE_API_KEY=')
        end_index = content.find('\n', start_index)
        if end_index != -1:
            node_api_key = content[start_index:end_index].strip()
            
            # Append the result to the existing .Passwords file
            with open('.Passwords', 'a') as password_file:
                password_file.write('\nNODE_API_KEY: ' + node_api_key)
        else:
            print("NODE_API_KEY not found in the file.")
    else:
        print("NODE_API_KEY not found in the file.")

# Get and append the NODE_API_KEY from the configuration file to the .Passwords file
get_node_api_key_from_conf()


def create_dojo_service(system_username, service_file_path):
    # Define the systemd service unit content
    service_unit = f"""\
[Unit]
Description=Dojo Docker Compose Stack
Requires=docker.service
After=docker.service

[Service]
ExecStart=/usr/bin/docker-compose up
ExecStop=/usr/bin/docker-compose down
WorkingDirectory=/home/humble/dojo-app/samourai-dojo-v1.20.0/docker/my-dojo/
Restart=always

[Install]
WantedBy=multi-user.target

"""

    # Write the service unit content to a temporary file
    temp_service_file = "/tmp/dojo.service"
    with open(temp_service_file, "w") as file:
        file.write(service_unit)

    try:
        # Use sudo to move the temporary file to the target directory
        move_command = ["sudo", "mv", temp_service_file, service_file_path]
        subprocess.run(move_command, check=True)

        # Set the correct ownership and permissions for the service file
        chown_command = ["sudo", "chown", "root:root", service_file_path]
        subprocess.run(chown_command, check=True)
        chmod_command = ["sudo", "chmod", "644", service_file_path]
        subprocess.run(chmod_command, check=True)

        # Reload systemd configuration
        reload_command = ["sudo", "systemctl", "daemon-reload"]
        subprocess.run(reload_command, check=True)

        # Enable and start the dojo service
        enable_command = ["sudo", "systemctl", "enable", "dojo.service"]
        subprocess.run(enable_command, check=True)
        start_command = ["sudo", "systemctl", "start", "dojo.service"]
        subprocess.run(start_command, check=True)

        print("Dojo service created, enabled, and started successfully.")
    except Exception as e:
        print(f"Error: {str(e)}")

def main():
    system_username = "humble"  # Replace with your system username
    service_file_path = "/etc/systemd/system/dojo.service"  # Replace with your desired target path
    create_dojo_service(system_username, service_file_path)

if __name__ == "__main__":
    main()