A Flask-based web application that provides a dashboard for monitoring cryptocurrency security.

• Crypto Asset Intelligence: Analyzes token contracts for potential security risks (e.g., honeypots, high taxes).
• Market Security Monitoring: Fetches the latest news related to cryptocurrency security breaches, vulnerabilities, and scams.
• Bitcoin Address Analyzer: Provides a summary of a given Bitcoin address, including its balance, transaction history, and any embedded OP_RETURN messages.

This web application provides a multi-function dashboard for cryptocurrency analysis and decentralized data verification. It combines tools for monitoring crypto assets and news with a novel system for verifying scientific papers on the AO network.

• Decentralized Verification: Look up scientific papers registered on the AO network using a process ID.
• Immutable Records: View key details such as title, author, publication year, and abstract.
• Peer Review Tracking: Access and review immutable peer-review comments and recommendations stored on-chain.

• Token Security Analysis: Get security metrics for specific cryptocurrency tokens (currently supports Alchemist DeFi Aurum - $AURUM).
• Key Metrics: Checks for open-source contracts, honeypot risks, and transaction taxes (buy/sell).
• Powered by GoPlus Security: Utilizes the GoPlus Labs API for reliable security data.

• Real-time News: Fetches the latest news related to cryptocurrency security, including hacks, vulnerabilities, and scams.
• Curated Content: Queries focus on high-impact events affecting major cryptocurrencies like Bitcoin and Ethereum.
• Powered by TheNewsAPI: Integrates with TheNewsAPI for up-to-date information.

• Address Lookup: Analyze any public Bitcoin address to get its current balance and transaction history.
• OP_RETURN Decoder: Automatically decodes and displays messages embedded in OP_RETURN transaction outputs.
• Powered by Blockchain.info: Uses the public Blockchain.info API for address and transaction data.

1. Install Dependencies: Make sure you have Python 3 and pip installed. Then, install the required packages:

   pip install -r requirements.txt

2. Set Up Environment Variables: This project requires API keys for the news service. Create a .env file in the root directory and add your key:

   NEWS_API_TOKEN="your_news_api_token_here"
   

3. Run the Application: Start the Flask server with the following command:

   python3 app.py

   The application will be available at http://127.0.0.1:5001.

.
├── app.py                  # Main Flask application
├── ao_analyzer.py          # Module for AO paper verification
├── btc_analyzer.py         # Module for Bitcoin address analysis
├── news_api.py             # Module for fetching security news
├── token_security.py       # Module for token security analysis
├── requirements.txt        # Python dependencies
├── templates/
│   └── index.html          # Frontend HTML template
└── static/
    └── style.css           # CSS for styling

This application provides a zero-friction workflow for decrypting Z.ai chat exports, minting them as permanent messages on the AO computer, and generating beautiful, customizable SVG badges.

• Guided Decrypt Wizard: A step-by-step modal guides users through the decryption process, ensuring a smooth first-time experience.
• Real-time Cost HUD: Before minting, a heads-up display provides a real-time estimate of the AO transaction cost based on the size of the JSON data.
• Customizable SVG Badges: Users can personalize their minted badges by choosing primary and secondary colors and selecting a layout (split for co-creation, solid for solo work).
• Gridwalker Gallery Sync: After a badge is minted, it is automatically pushed to the Gridwalker gallery for an instant showcase.
• Dynamic Sunrise Palette: A new "Apply Sunrise Palette" button allows users to dynamically color their badge based on the real-time position of the sun, calculated purely in Lua on the AO backend.
• Robust Error Handling: The application fails gracefully, providing clear error messages and a retry button if the minting process encounters an issue.

1. Open the Application: Launch the index.html file in a web browser.
2. Follow the Wizard: If it's your first visit, a wizard will pop up to guide you on how to decrypt your Z.ai export.
3. Paste Your Data: Paste the decrypted JSON content from your Z.ai export into the text area.
4. Customize Your Badge: Use the color pickers and layout selector to design your unique badge.
5. Mint to AO: Click the "Mint to AO" button. The application will mint the log and the badge.

The application is powered by an AO process (process.lua) that handles two main actions:

• MintZai: Stores the raw, decrypted JSON log.
• MintBadge: Stores the generated SVG badge and handles the sync to the Gridwalker gallery.

To deploy your own instance:

1. Set the ARWEAVE_WALLET environment variable with the JSON content of your Arweave wallet.
2. Fill in your YOUR-PROCESS-ID in index.html.
3. Run node deploy.mjs.

This project is a Flask-based web application that provides a dashboard for cryptocurrency security intelligence. It offers tools for analyzing Bitcoin addresses, monitoring market security news, and inspecting token security metrics.

• Bitcoin Address Analyzer: View the balance and recent transactions for any BTC address. It also scans for and displays any OP_RETURN messages found in recent transactions.
• AO Network Analysis: Fetch and display messages associated with a given AO (Arweave Object) Process ID.
• Crypto Asset Intelligence: Get security metrics for specific crypto assets. Currently supports analysis for Alchemist DeFi Aurum ($AURUM).
• Market Security Monitoring: Stay updated with the latest news related to cryptocurrency security breaches, vulnerabilities, and hacks.

1. Clone the repository:

   git clone <repository-url>
   cd <repository-directory>

2. Create a virtual environment (recommended):

   python3 -m venv venv
   source venv/bin/activate

3. Install dependencies:

4. Install the dependencies:

   pip install -r requirements.txt

5. Configure environment variables:

   • Copy the .env.example file to a new file named .env:

     cp .env.example .env

   • Open the .env file and add your API keys and Twitch credentials.

6. Run the application:

   python app.py

   The application will be available at http://127.0.0.1:5001. The Twitch bot will connect and print chat messages to the console.

This application includes a Twitch bot that connects to a specified channel and prints chat messages to the console.

To use the Twitch bot, you need to provide your Twitch credentials in the .env file:

• TWITCH_TOKEN: Your Twitch bot's OAuth token. You can generate one at https://twitchapps.com/tmi/.
• TWITCH_CHANNEL: The name of the Twitch channel you want the bot to join (e.g., wallbavaria).

The Twitch bot starts automatically when you run the main Flask application (python app.py). It runs in a separate thread and will not interfere with the web server. Chat messages from the connected channel will be printed to the console where you started the application. The Twitch bot starts automatically when you run the main Flask application (python app.py). It runs in a separate thread and will not interfere with the web server. Chat messages from the connected channel will be printed to the console where you started the application.

1. Run the Flask application:

   python3 app.py

2. Open your browser and navigate to http://127.0.0.1:5001 to view the dashboard.

The application will run in debug mode, which automatically reloads the server when code changes are detected.

This project demonstrates an AO smart contract (process.lua) that manages a "Gridwalker Identity" and includes a creative module called "SOL = LUA" for a dynamic, on-chain sunrise/sunset simulation.

The frontend (index.html) provides a "Badge Customizer" that allows users to change the colors and layout of a visual badge. The "SOL = LUA" feature enhances this by allowing users to apply a color palette to their badge that is dynamically generated based on the current position of the sun.

"""

Version 1.0.0

An advanced AI-powered grid intelligence system for monitoring, analyzing, and optimizing distributed networks with real-time data processing and predictive analytics.

This repository contains a full-stack AO application that tracks a Bitcoin treasury balance and visualizes it as progress towards a simulated Mars mission.

The Bitcoin-Mars Treasury Tracker is a decentralized application that demonstrates the power of AO for real-world data integration and state management. It consists of three main parts:

1. A Monitor (monitor.js): A Node.js script that periodically fetches the balance of a public Bitcoin address (in this case, MicroStrategy's known treasury address) from a public API.
2. An AO Process (process.lua): A persistent, decentralized backend that receives balance updates from the monitor, stores the treasury data, and calculates the corresponding "Mars Mission Progress."
3. A Frontend Dashboard (index.html): A web interface that polls the AO process and displays the treasury balance and mission progress in real-time.

This creates a full loop: real-world data is brought on-chain to a decentralized process, which then serves that data to a decentralized frontend.

• index.html: The frontend dashboard. It periodically fetches the latest state from the AO process and updates the UI, including a progress bar for the Mars mission.
• process.lua: The backend AO process. It stores the Bitcoin balance and mission progress, and exposes a GetState handler for the frontend to query.
• monitor.js: A Node.js script that acts as an oracle, fetching the Bitcoin balance and pushing it to the AO process via an UpdateTreasury message.
• package.json: Defines the project's dependencies (@permaweb/aoconnect, node-fetch) and provides scripts to run the monitor and deploy the frontend.
• deploy.mjs: A script to deploy the index.html file to Arweave using Irys.

First, deploy the process.lua script to the AO network to get your unique Process-ID.

1. Update Process ID: Replace the YOUR_PROCESS_ID_HERE placeholder in both monitor.js and index.html with the Process-ID you received in the previous step.
2. Configure Wallet: Create an arweave-wallet.json file in the root directory and add your Arweave key. This is required for both the monitor and the deployment script to sign messages.

In a terminal, install the dependencies and start the monitor:

npm install
npm run monitor

The monitor will fetch the initial Bitcoin balance, send it to your AO process, and then continue to check for updates every 5 minutes.

In another terminal, deploy the frontend to Arweave:

npm run deploy

This will upload the index.html file and provide you with a permanent Arweave URL where you can view your live dashboard.

Open the Arweave URL from the deployment step in your browser. The dashboard will automatically fetch the latest state from your AO process and display the Bitcoin treasury balance and Mars mission progress. It will refresh every 15 seconds.

This completes the full deployment of the Bitcoin-Mars Treasury Tracker, a decentralized application powered by AO and Arweave.

This is a simple Flask-based web application that provides a dashboard for cryptocurrency security intelligence.

It includes the following features:

• Crypto Asset Intelligence: Displays security metrics for a specific token contract (currently hardcoded for AURUM).
• Market Security Monitoring: Shows the latest news related to crypto security breaches, hacks, and vulnerabilities.
• Bitcoin Address Analyzer: Fetches balance, transaction history, and decodes OP_RETURN messages for a given Bitcoin address.

It is recommended to run the application in a virtual environment.

python -m venv venv
source venv/bin/activate  # On Windows, use `venv\Scripts\activate`

""" import os import subprocess import time import sys import argparse

REPO_URL = "https://github.com/Aurumgrid/AO-PARALLAX.git" REPO_DIR = "AO-PARALLAX" VERSION = "1.0.0" REPO_URL = "https://github.com/Aurumgrid/AGI.git" REPO_DIR = "AGI"

def print_header(title): """Prints a formatted header.""" print("\n" + "="*60) print(f" {title}") print("="*60 + "\n")

def run_command(command, cwd=".", background=False): """Runs a shell command and prints it.""" print(f"--> Running command: {' '.join(command)}") if background: return subprocess.Popen(command, cwd=cwd)

try:
    subprocess.run(command, cwd=cwd, check=True, capture_output=True, text=True)
except subprocess.CalledProcessError as e:
    print(f"Error running command: {' '.join(command)}", file=sys.stderr)
    print(f"Stdout: {e.stdout}", file=sys.stderr)
    print(f"Stderr: {e.stderr}", file=sys.stderr)
    raise

def run_command(command, cwd="."): """Simulates running a shell command and prints it.""" print(f"--> Running command: {' '.join(command)}") # In a real environment, you would use subprocess.run # For this simulation, we'll just print the command and expected output. # Example: subprocess.run(command, cwd=cwd, check=True) time.sleep(1) # Simulate execution time

• Gridwalker Identity: A base contract for managing a simple user profile (DisplayName, Bio, Avatar).
• SOL = LUA Module: A pure Lua implementation of a solar position calculator.
  • SolUpdate Handler: When called, this handler calculates the current altitude and azimuth of the sun based on a default location (São Paulo).
  • Dynamic Entropy & Color: It uses the sun's position to generate an "entropy" value (0-1) and a two-color HSL palette, which are then stored in the contract's state.

• Badge Customizer: Allows users to manually set the primary and secondary colors of an SVG badge.
• "Apply Sunrise Palette" Button:
  • Triggers the SolUpdate handler in the AO process.
  • Fetches the dynamically generated HSL colors from the contract's state.
  • Converts the HSL colors to HEX format.
  • Applies the new colors to the badge customizer's color pickers, instantly updating the badge's appearance.

1. Deploy the AO Process: Deploy the process.lua script to the AO network to get a Process ID.

   aos process.lua

   You will need to connect this Process ID to the frontend for it to work. def simulate_output(lines): """Prints simulated output line by line.""" for line in lines: print(line) time.sleep(0.5) A simple web-based teleprompter application.

Example teleprompter session (simulated chatbot output):

[AGI]  Cognition layer on-line. Narrative velocity set to 30 ωpm.
[AGI]  Script ingested, entropy ≈ 0.12 bits/word – well within coherence threshold.
[User] Commence transmission.
[AGI]  Broadcasting. Adjust tempo with ↑ / ↓ or submit real-time feedback via the embedded AO app.

...

def main(): """Main function to run the AGI quick-start simulation.""" print_header(f"Aurum Grid Intelligence (AGI) Quick Start (v{VERSION})")

"""Main function to run the AO-PARALLAX quick-start simulation."""
parser = argparse.ArgumentParser(description="AO-PARALLAX simulation script.")
parser.add_argument(
    "--network",
    type=str,
    default="testnet",
    choices=["testnet", "mainnet"],
    help="Network to simulate (testnet or mainnet)"
)
args = parser.parse_args()
print(f"Simulating for network: {args.network}")

# 1. Clone the Repository
print_header(f"1. Cloning the Repository for {args.network}")
if os.path.exists(REPO_DIR):
    print(f"Directory '{REPO_DIR}' already exists. Skipping clone.")
else:
    # run_command(["git", "clone", REPO_URL])
    # print(f"Successfully cloned repository into '{REPO_DIR}'.")
    os.mkdir(REPO_DIR) # Simulate directory creation for standalone run

2. Interact with the Frontend:
   • Open index.html in a web browser.
   • You will see a default badge. You can manually change its colors using the color pickers.
   • Click the "🌅 Apply Sunrise Palette" button. This will fetch the current sun-based color palette from your AO process and apply it to the badge.

The color palette changes throughout the day, reflecting the current time at the contract's location:

• Sunrise (e.g., 06:00): Deep indigos and magentas.
• Midday (e.g., 12:00): Bright cyans and limes.
• Sunset (e.g., 18:00): Warm oranges and golds.

This creates a dynamic, ever-changing visual identity that is calculated and stored permanently on-chain, with zero external API calls. # 3. Run the Single-Node Demo print_header("3. Running Single-Node Demo (examples/monitoring)") demo_path = os.path.join(REPO_DIR, "examples", "monitoring") run_command(["poetry", "run", "python", "run_demo.py"], cwd=demo_path)

# 4. Run the True P2P Network Demo
print_header("4. Running True P2P Network (2 Peers)")

peer_a_process = None
peer_b_process = None
try:
    # Start Peer A in the background
    print("\n--- Starting Peer A (background) ---")
    peer_a_process = run_command([
        "poetry", "run", "python", "-m", "parallax.node",
        "--listen", "0.0.0.0:9001", "--peer-id", "nodeA"
    ], cwd=REPO_DIR, background=True)
    print("Node A is starting... giving it a moment to initialize.")
    time.sleep(5)

    # Start Peer B in the background, connected to Peer A
    print("\n--- Starting Peer B (background) ---")
    peer_b_process = run_command([
        "poetry", "run", "python", "-m", "parallax.node",
        "--listen", "0.0.0.0:9002", "--peer-id", "nodeB",
        "--bootstrap", "/ip4/127.0.0.1/tcp/9001/p2p/nodeA"
    ], cwd=REPO_DIR, background=True)
    print("Node B is starting... giving it a moment to initialize.")
    time.sleep(5)

    # Submit a client request to the network
    print("\n--- Submitting a Client Request ---")
    run_command([
        "poetry", "run", "python", "-m", "parallax.client",
        "--model", "meta-llama/Meta-Llama-3-8B",
        "--prompt", "Explain recursion."
    ], cwd=REPO_DIR)

finally:
    # Shut down both peers
    if peer_b_process:
        print("\n--- Shutting down Peer B ---")
        peer_b_process.terminate()
        peer_b_process.wait()
        print("Peer B shut down.")
    if peer_a_process:
        print("\n--- Shutting down Peer A ---")
        peer_a_process.terminate()
        peer_a_process.wait()
        print("Peer A shut down.")

print_header("Demonstration Complete")

print("\n--- Simulated Demo Output ---")
simulate_output([
    "[parallax] Starting local node (id=0x1a2b3c4d...)",
    "[engine] Loading model: “meta-llama/Meta-Llama-3-8B”",
    "[transport] Lattica channel opened (ws://127.0.0.1:9090)",
    ">> User: Hello!",
    "<< Bot:  Hi there! I'm AGI. I can help you with tasks or you can check out the new feedback app.",
    "--- Demo Finished ---"
    "[AGI]  Cognition layer on-line. Narrative velocity set to 30 ωpm.",
    "[AGI]  Script ingested, entropy ≈ 0.12 bits/word – well within coherence threshold.",
    "[User] Commence transmission.",
    "[AGI]  Broadcasting. Adjust tempo with ↑ / ↓ or submit real-time feedback via the embedded AO app.",
])
if args.network == "mainnet":
    simulate_output([
        "[parallax] Starting mainnet node (id=0x5e6f7g8h...)",
        "[engine] Loading model: “meta-llama/Meta-Llama-3-70B”",
        "[transport] Lattica channel opened (wss://mainnet.aurumgrid.io:9090)",
        ">> User: Hello!",
        "<< Bot:  Hi there! How can I help you today on the mainnet?",
        "--- Demo Finished ---"
    ])
else:
    simulate_output([
        "[parallax] Starting local node (id=0x1a2b3c4d...)",
        "[engine] Loading model: “meta-llama/Meta-Llama-3-8B”",
        "[transport] Lattica channel opened (ws://127.0.0.1:9090)",
        ">> User: Hello!",
        "<< Bot:  Hi there! How can I help you today?",
        "--- Demo Finished ---"
    ])

# 4. Simulate the P2P Network Demo
print_header(f"4. Simulating True P2P Network (2 Peers) on {args.network}")
print("This requires two separate terminals. Simulating the commands below.")

# Terminal A
print("\n--- Terminal A (Peer 1) ---")
run_command([
    "poetry", "run", "python", "-m", "agi.node",
    "--listen", "0.0.0.0:9001", "--peer-id", "nodeA"
], cwd=REPO_DIR)
print(" Node A is up and listening on port 9001.")

# Terminal B
print("\n--- Terminal B (Peer 2) ---")
if args.network == "mainnet":
    bootstrap_peer = "/dns4/mainnet.aurumgrid.io/tcp/9001/p2p/mainnet-bootstrap-1"
    print("Connecting to mainnet bootstrap peer.")
else:
    bootstrap_peer = "/ip4/<IP_of_A>/tcp/9001/p2p/nodeA"
    print("Note: <IP_of_A> should be replaced with the actual IP of Terminal A.")

run_command([
    "poetry", "run", "python", "-m", "agi.node",
    "--listen", "0.0.0.0:9002", "--peer-id", "nodeB",
    "--bootstrap", "/ip4/127.0.0.1/tcp/9001/p2p/nodeA"
    "--bootstrap", bootstrap_peer
], cwd=REPO_DIR)
print(f" Node B is up, listening on 9002, and connected to {'Node A' if args.network == 'testnet' else 'mainnet'}.")

# Client Request
print("\n--- Submitting a Client Request (from any peer) ---")
run_command([
    "poetry", "run", "python", "-m", "agi.client",
    "--model", "aurum-grid-model-v1",
    "--prompt", "Predict network failure in the next 24 hours."
    "poetry", "run", "python", "-m", "parallax.client",
    "--model", "GLM-4.6",
    "--prompt", "Explain recursion."
], cwd=REPO_DIR)

print("\n--- Simulated Client Output ---")
simulate_output([
    "[client] Submitting task to the AGI network...",
    "[engine] Decomposing analysis graph for aurum-grid-model-v1...",
    "[engine] Shard 1/8 -> nodeA (CPU)",
    "[engine] Shard 2/8 -> nodeB (CPU)",
    "[engine] Shard 3/8 -> nodeA (CPU)",
    "[engine] Shard 4/8 -> nodeB (CPU)",
    "[engine] Shard 5/8 -> nodeA (CPU)",
    "[engine] Shard 6/8 -> nodeB (CPU)",
    "[engine] Shard 7/8 -> nodeA (CPU)",
    "[engine] Shard 8/8 -> nodeB (CPU)",
    "[client] Result received:",
    "Prediction: High probability of failure (95%) in sector 7 due to cascading power fluctuations."
])
if args.network == "mainnet":
    simulate_output([
        "[client] Submitting task to the Parallax mainnet...",
        "[engine] Decomposing model graph for meta-llama/Meta-Llama-3-70B...",
        "[engine] Shard 1/64 -> mainnet-peer-1 (GPU)",
        "[engine] Shard 2/64 -> mainnet-peer-2 (GPU)",
        "[engine] Shard 3/64 -> mainnet-peer-3 (GPU)",
        "...",
        "[client] Result received:",
        "Recursion is a method where a function calls itself to solve a problem by breaking it down into smaller, similar subproblems. This process continues until it reaches a base case, which stops the recursion."
    ])
else:
    simulate_output([
        "[client] Submitting task to the Parallax network...",
        "[engine] Decomposing model graph for meta-llama/Meta-Llama-3-8B...",
        "[engine] Shard 1/8 -> nodeA (GPU)",
        "[engine] Shard 2/8 -> nodeB (GPU)",
        "[engine] Shard 3/8 -> nodeA (GPU)",
        "...",
        "[client] Result received:",
        "Recursion is a method where a function calls itself to solve a problem by breaking it down into smaller, similar subproblems. This process continues until it reaches a base case, which stops the recursion."
    ])

print_header("Simulation Complete")

if name == "main": main()

Install the required Python packages using pip:

pip install -r requirements.txt

The application can use an API key from The News API to fetch live security news. If you wish to use a live feed instead of the default mock data, create a .env file in the root directory and add your API token:

NEWS_API_TOKEN="your_api_token_here"

See .env.example for a template.

To start the Flask development server, run the following command:

python app.py

The application will be available at http://127.0.0.1:5001.