commitment_manager.py

APP_NAME = "SIGNUM commitment_manager"
APP_VERSION = "1.2.0"

import tkinter as tk
from tkinter import ttk, messagebox
from datetime import datetime, timedelta
from PIL import Image, ImageTk

import signum_api
import storage
import webbrowser

BLOCKS_FOR_REMOVAL = 1440
BLOCK_TIME_SECONDS = 240


class CommitmentManager:

    def __init__(self, root):

        self.root = root
        self.root.title(
            f"{APP_NAME} v{APP_VERSION}"
        )

        self.root.geometry("1000x500")
        self.root.minsize(850, 400)

        self.root.rowconfigure(2, weight=1)
        self.root.columnconfigure(0, weight=1)

        self.root.resizable(True, True)

        self.set_icon()

        top = ttk.Frame(root)
        top.pack(fill="x", padx=8, pady=6)

        ttk.Label(
            top,
            text="Wallet Address"
        ).grid(row=0, column=0, sticky="w")

        self.address_var = tk.StringVar()

        self.address_combo = ttk.Combobox(
            top,
            textvariable=self.address_var,
            values=storage.load_addresses(),
            width=55
        )

        self.address_combo.grid(
            row=1,
            column=0,
            padx=(0, 5),
            sticky="ew"
        )

        self.address_combo.bind(
            "<Return>",
            lambda event: self.load_data()
        )

        ttk.Button(
            top,
            text="Load",
            command=self.load_data
        ).grid(
            row=1,
            column=1,
            padx=3
        )

        ttk.Button(
            top,
            text="Exit",
            command=self.root.destroy
        ).grid(
            row=1,
            column=2,
            padx=3
        )

        top.columnconfigure(0, weight=1)

        info_frame = ttk.LabelFrame(root, text="Commitment Status")
        info_frame.pack(fill="x", padx=8, pady=4)

        self.info_label = tk.Label(
            info_frame,
            justify="left",
            anchor="w",
            font=("Segoe UI", 9)
        )

        self.info_label.pack(fill="x", padx=6, pady=6)

        #
        # CHANGED:
        # "Commitment History (most recent first)"
        # ->
        # "Commitment History"
        #
        history_frame = ttk.LabelFrame(
            root,
            text="Commitment History"
        )

        history_frame.pack(
            fill="both",
            expand=True,
            padx=8,
            pady=4
        )

        columns = (
            "datetime",
            "action",
            "amount",
            "height",
            "status"
        )

        self.tree = ttk.Treeview(
            history_frame,
            columns=columns,
            show="headings"
        )

        #
        # SORTABLE COLUMN HEADERS
        #
        self.tree.heading(
            "datetime",
            text="Date / Time",
            command=lambda: self.sort_column("datetime", False)
        )

        self.tree.heading(
            "action",
            text="Action",
            command=lambda: self.sort_column("action", False)
        )

        self.tree.heading(
            "amount",
            text="Amount (SIGNA)",
            command=lambda: self.sort_column("amount", False)
        )

        self.tree.heading(
            "height",
            text="Height",
            command=lambda: self.sort_column("height", False)
        )

        self.tree.heading(
            "status",
            text="Status",
            command=lambda: self.sort_column("status", False)
        )

        self.tree.column("datetime", width=180, anchor="w")
        self.tree.column("action", width=80, anchor="center")
        self.tree.column("amount", width=140, anchor="e")
        self.tree.column("height", width=100, anchor="e")
        self.tree.column("status", width=320, anchor="w")

        scrollbar = ttk.Scrollbar(
            history_frame,
            orient="vertical",
            command=self.tree.yview
        )

        self.tree.configure(
            yscrollcommand=scrollbar.set
        )

        self.tree.pack(
            side="left",
            fill="both",
            expand=True
        )

        scrollbar.pack(
            side="right",
            fill="y"
        )

        self.history_data = []

        self.tree.bind(
            "<Double-1>",
            self.open_selected_entry
        )

    def set_icon(self):

        try:
            self.root.iconbitmap("assets/icon.ico")
        except:
            pass

        try:
            image = Image.open("assets/icon.png")
            photo = ImageTk.PhotoImage(image)
            self.root.iconphoto(True, photo)
            self._icon_photo = photo
        except:
            pass

    #
    # NEW:
    # SORTING SUPPORT
    #
    def sort_column(self, col, reverse):

        data = [
            (
                self.tree.set(item, col),
                item
            )
            for item in self.tree.get_children("")
        ]

        #
        # Numeric sorting
        #
        if col in ("amount", "height"):

            data.sort(
                key=lambda t: float(
                    str(t[0]).replace(",", "")
                ),
                reverse=reverse
            )

        #
        # Text sorting
        #
        else:

            data.sort(
                key=lambda t: t[0],
                reverse=reverse
            )

        #
        # Rearrange rows
        #
        for index, (_, item) in enumerate(data):

            self.tree.move(
                item,
                "",
                index
            )

        #
        # Toggle ascending/descending
        #
        self.tree.heading(
            col,
            command=lambda: self.sort_column(
                col,
                not reverse
            )
        )

    def load_data(self):

        address = self.address_var.get().strip()

        if not address:
            return

        storage.save_address(address)

        self.address_combo["values"] = (
            storage.load_addresses()
        )

        self.info_label.config(
            text="Scanning blockchain history..."
        )

        self.root.update_idletasks()

        try:

            history = (
                signum_api.get_commitment_history(
                    address
                )
            )

            #
            # Clear table
            #
            for item in self.tree.get_children():
                self.tree.delete(item)

            self.history_data = []

            if not history:

                self.info_label.config(
                    text="No commitments found for this address"
                )

                messagebox.showinfo(
                    "Information",
                    "No commitments found for this address"
                )

                return

            latest = history[0]

            remaining = latest["remaining"]

            total_locked = 0
            total_realized = 0

            for item in history:

                if item["action"] == "ADD":

                    total_locked += item["amount"]

                    if item["remaining"] == 0:
                        total_realized += item["amount"]

                elif item["action"] == "REMOVE":

                    total_locked -= item["amount"]

                    if item["remaining"] == 0:
                        total_realized -= item["amount"]

            text = []

            text.append(
                f"Last Commitment Change Height: "
                f"{latest['height']}"
            )

            text.append(
                f"Total commitment (locked): "
                f"{total_locked:,.2f} SIGNA"
            )

            text.append(
                f"Total commitment realized: "
                f"{total_realized:,.2f} SIGNA"
            )

            if remaining > 0:

                eta = signum_api.estimate_time(
                    remaining
                )

                hours = (
                    remaining * 4
                ) / 60

                text.append(
                    f"Commitment will be fully realized in "
                    f"{remaining} blocks"
                )

                text.append(
                    f"Approx: {hours:.1f} hours"
                )

                text.append(
                    f"Date: "
                    f"{eta.strftime('%Y-%m-%d %H:%M')}"
                )

            else:

                text.append(
                    "Commitment Fully Realized"
                )

            self.info_label.config(
                text="\n".join(text)
            )

            #
            # Populate table
            #
            for item in history:

                row_id = self.tree.insert(
                    "",
                    "end",
                    values=(
                        item["datetime"],
                        item["action"],
                        f"{item['amount']:,.2f}",
                        item["height"],
                        item["status"]
                    )
                )

                self.history_data.append({
                    "row_id": row_id,
                    "data": item
                })

        except Exception as e:

            messagebox.showerror(
                "Error",
                str(e)
            )

    def open_selected_entry(self, event):

        selected = self.tree.selection()

        if not selected:
            return

        row_id = selected[0]

        item_data = None

        for entry in self.history_data:

            if entry["row_id"] == row_id:

                item_data = entry["data"]
                break

        if not item_data:
            return

        txid = item_data.get("txid")

        if not txid:
            return

        url = (
            f"https://explorer.signum.network/tx/"
            f"{txid}"
        )

        webbrowser.open(url)


def main():

    root = tk.Tk()

    app = CommitmentManager(root)

    root.mainloop()


if __name__ == "__main__":
    main()