Ton Bug Triage

__pycache__/
*.pyc
*.pyo
.DS_Store
__MACOSX/

interface:
  display_name: "TON Bug Triage"
  short_description: "Triage TON local repros through contract txs or validator probes"
  default_prompt: "Use $ton-bug-triage to verify a TON local-network repro through either Workflow A (contract transaction trigger) or Workflow B (mixed-build validator behavior)."

"""Fetch raw account state through tonlib and optionally dump code/data BoCs.

Use this to confirm activation, inspect current balance and last transaction,
or export code/data artifacts for follow-up debugging.
"""

from __future__ import annotations

import argparse
import asyncio
import json
from pathlib import Path

from ton_triage_lib import (
    build_tonlib_client,
    normalize_account_address,
    raw_get_account_state_with_timeout,
    resolve_path,
    runtime_from_args,
)


async def _run(args: argparse.Namespace) -> None:
    runtime = runtime_from_args(args)
    out_dir = resolve_path(Path.cwd(), args.out_dir) if args.out_dir else None

    client = await build_tonlib_client(runtime, verbosity=args.verbosity, request_timeout=args.request_timeout)
    try:
        normalized = await normalize_account_address(client, args.address, request_timeout=args.request_timeout)
        state = await raw_get_account_state_with_timeout(
            client,
            normalized.serialized,
            args.request_timeout,
        )
    finally:
        await client.aclose()

    code = state.code or b""
    data = state.data or b""
    result = {
        "address_input": args.address,
        "address_serialized": normalized.serialized,
        "address_raw": normalized.raw,
        "code_len": len(code),
        "data_len": len(data),
    }

    if out_dir is not None:
        out_dir.mkdir(parents=True, exist_ok=True)
        (out_dir / "account-state.json").write_text(state.to_json())
        (out_dir / "code.boc").write_bytes(code)
        (out_dir / "data.boc").write_bytes(data)
        result["out_dir"] = str(out_dir)

    print(json.dumps(result, indent=2))


def main() -> None:
    parser = argparse.ArgumentParser(description="Fetch raw account state through tonlib")
    parser.add_argument("--wallet-env", help="Path to wallet-env.txt emitted by the network runner")
    parser.add_argument("--run-dir", help="Run directory containing wallet-env.txt")
    parser.add_argument("--repo-root", help="Path to the TON repo root")
    parser.add_argument("--build", help="Build directory containing tonlibjson")
    parser.add_argument("--config", help="Lite-client config JSON path")
    parser.add_argument("--state-dir", help="Optional state dir for helper defaults")
    parser.add_argument(
        "--address",
        required=True,
        help="TON account address accepted by tonlib; use --address=<value> for raw forms like -1:...",
    )
    parser.add_argument("--out-dir", help="Optional output directory for dumped code/data/state")
    parser.add_argument("--verbosity", type=int, default=0, help="Tonlib verbosity level")
    parser.add_argument(
        "--request-timeout",
        type=float,
        default=5.0,
        help="Per-request timeout for tonlib address/state queries",
    )

    args = parser.parse_args()
    asyncio.run(_run(args))


if __name__ == "__main__":
    main()

"""Normalize a TON account address through tonlib.

Use this when you need to convert between raw and serialized forms or inspect
address metadata such as bounceability and testnet bits.
"""

from __future__ import annotations

import argparse
import asyncio
import json

from ton_triage_lib import build_tonlib_client, normalize_account_address, runtime_from_args


async def _run(args: argparse.Namespace) -> None:
    runtime = runtime_from_args(args)

    client = await build_tonlib_client(runtime, verbosity=args.verbosity, request_timeout=args.request_timeout)
    try:
        normalized = await normalize_account_address(client, args.address, request_timeout=args.request_timeout)
    finally:
        await client.aclose()

    print(
        json.dumps(
            {
                "address_input": normalized.input_value,
                "address_serialized": normalized.serialized,
                "address_raw": normalized.raw,
                "workchain_id": normalized.workchain_id,
                "bounceable": normalized.bounceable,
                "testnet": normalized.testnet,
                "addr_hex": normalized.addr_hex,
            },
            indent=2,
        )
    )


def main() -> None:
    parser = argparse.ArgumentParser(description="Normalize and inspect a TON account address through tonlib")
    parser.add_argument("--wallet-env", help="Path to wallet-env.txt emitted by the network runner")
    parser.add_argument("--run-dir", help="Run directory containing wallet-env.txt")
    parser.add_argument("--repo-root", help="Path to the TON repo root")
    parser.add_argument("--build", help="Build directory containing tonlibjson")
    parser.add_argument("--config", help="Lite-client config JSON path")
    parser.add_argument("--state-dir", help="Optional state dir for helper defaults")
    parser.add_argument(
        "--address",
        required=True,
        help="TON account address in any tonlib-accepted form; use --address=<value> for raw forms like -1:...",
    )
    parser.add_argument("--verbosity", type=int, default=0, help="Tonlib verbosity level")
    parser.add_argument(
        "--request-timeout",
        type=float,
        default=5.0,
        help="Per-request timeout for tonlib address normalization",
    )

    args = parser.parse_args()
    asyncio.run(_run(args))


if __name__ == "__main__":
    main()

"""Build a deployable StateInit BoC from code, data, and optional libraries.

Use this after compiling contract code and before deployment or zerostate-style
address calculation.
"""

from __future__ import annotations

import argparse
import json
from pathlib import Path

from ton_triage_lib import (
    resolve_path,
    run_fift_script_command,
    runtime_from_args,
    wallet_address_from_base,
)


SCRIPT_DIR = Path(__file__).resolve().parent
FIFT_DIR = SCRIPT_DIR / "fift"


def _parse_marker(output: str, marker: str) -> str | None:
    prefix = f"{marker}: "
    for raw_line in output.splitlines():
        line = raw_line.strip()
        if line.startswith(prefix):
            return line.removeprefix(prefix).strip()
    return None


def _validate_name(value: str) -> str:
    if value in {"", ".", ".."}:
        raise argparse.ArgumentTypeError("name must be a simple non-empty filename base")
    path = Path(value)
    if path.name != value:
        raise argparse.ArgumentTypeError("name must not contain directory separators")
    return value


def main() -> None:
    parser = argparse.ArgumentParser(
        description="Build a deployable StateInit BoC from code plus optional data and libraries",
        epilog=(
            "Examples:\n"
            "  python3 build_stateinit.py --wallet-env /tmp/run/wallet-env.txt \\\n"
            "    --code-boc /tmp/contract/code.boc --out-dir /tmp/contract-build\n"
            "  python3 build_stateinit.py --repo-root /path/to/repo --build /path/to/repo/build \\\n"
            "    --code-boc code.boc --data-boc data.boc --library-boc libs.boc \\\n"
            "    --workchain 0 --name target --out-dir /tmp/target-stateinit"
        ),
        formatter_class=argparse.RawDescriptionHelpFormatter,
    )
    parser.add_argument("--wallet-env", help="Path to wallet-env.txt emitted by the network runner")
    parser.add_argument("--run-dir", help="Run directory containing wallet-env.txt")
    parser.add_argument("--repo-root", help="Path to the TON repo root")
    parser.add_argument("--build", help="Build directory containing create-state")
    parser.add_argument("--config", help="Unused here; accepted for wallet-env compatibility")
    parser.add_argument("--state-dir", help="Unused here; accepted for wallet-env compatibility")
    parser.add_argument("--code-boc", required=True, help="Compiled contract code BoC")
    parser.add_argument("--data-boc", help="Optional initial data BoC")
    parser.add_argument(
        "--library-boc",
        help="Optional library-dictionary root cell BoC; pass a prebuilt HashmapE root, not raw library code",
    )
    parser.add_argument("--workchain", type=int, default=0, help="Destination workchain id")
    parser.add_argument("--name", type=_validate_name, default="contract", help="Filename base for emitted artifacts")
    parser.add_argument("--out-dir", required=True, help="Output directory for the emitted StateInit and address files")

    args = parser.parse_args()
    runtime = runtime_from_args(args, require_config=False)

    out_dir = resolve_path(Path.cwd(), args.out_dir)
    out_dir.mkdir(parents=True, exist_ok=True)

    code_boc = resolve_path(Path.cwd(), args.code_boc)
    data_boc = resolve_path(Path.cwd(), args.data_boc) if args.data_boc else None
    library_boc = resolve_path(Path.cwd(), args.library_boc) if args.library_boc else None

    completed = run_fift_script_command(
        runtime.repo_root,
        runtime.build_dir,
        FIFT_DIR / "build_stateinit.fif",
        cwd=out_dir,
        script_args=[
            str(args.workchain),
            str(code_boc),
            str(data_boc) if data_boc is not None else "-",
            str(library_boc) if library_boc is not None else "-",
            args.name,
        ],
        capture_output=True,
    )

    if completed.stdout:
        print(completed.stdout, end="" if completed.stdout.endswith("\n") else "\n")

    contract_base = out_dir / args.name
    stateinit_boc = contract_base.with_name(f"{args.name}-stateinit.boc")
    address_file = contract_base.with_suffix(".addr")

    result = {
        "workchain": args.workchain,
        "code_boc": str(code_boc),
        "data_boc": str(data_boc) if data_boc is not None else None,
        "library_boc": str(library_boc) if library_boc is not None else None,
        "stateinit_boc": str(stateinit_boc),
        "address_file": str(address_file),
        "address_raw": wallet_address_from_base(contract_base),
        "address_non_bounceable": _parse_marker(completed.stdout, "contract address non-bounceable"),
        "address_bounceable": _parse_marker(completed.stdout, "contract address bounceable"),
    }
    print(json.dumps(result, indent=2))


if __name__ == "__main__":
    main()

"""Compile a Tolk contract and materialize its code BoC.

Use this when Workflow A starts from a `.tolk` source and you want a checked
path that refuses to use a stale `tolk` binary.
"""

from __future__ import annotations

import argparse
import json
from pathlib import Path

from ton_triage_lib import (
    ensure_tolk_matches_repo,
    resolve_path,
    run_fift_script_command,
    run_subprocess,
    runtime_from_args,
)


def _validate_name(value: str) -> str:
    if value in {"", ".", ".."}:
        raise argparse.ArgumentTypeError("name must be a simple non-empty filename base")
    path = Path(value)
    if path.name != value:
        raise argparse.ArgumentTypeError("name must not contain directory separators")
    return value


def main() -> None:
    parser = argparse.ArgumentParser(
        description="Compile a Tolk contract and materialize its code BoC",
        epilog=(
            "Examples:\n"
            "  python3 compile_tolk.py --repo-root /path/to/repo --build /path/to/repo/build \\\n"
            "    --source /tmp/counter.tolk --out-dir /tmp/counter-build\n"
            "  python3 compile_tolk.py --wallet-env /tmp/run/wallet-env.txt \\\n"
            "    --source contracts/trigger.tolk --name trigger --out-dir /tmp/trigger-build"
        ),
        formatter_class=argparse.RawDescriptionHelpFormatter,
    )
    parser.add_argument("--wallet-env", help="Path to wallet-env.txt emitted by the network runner")
    parser.add_argument("--run-dir", help="Run directory containing wallet-env.txt")
    parser.add_argument("--repo-root", help="Path to the TON repo root")
    parser.add_argument("--build", help="Build directory containing tolk and create-state")
    parser.add_argument("--config", help="Unused here; accepted for wallet-env compatibility")
    parser.add_argument("--state-dir", help="Unused here; accepted for wallet-env compatibility")
    parser.add_argument("--source", required=True, help="Path to the .tolk source file")
    parser.add_argument("--out-dir", required=True, help="Output directory for compiler artifacts")
    parser.add_argument("--name", type=_validate_name, help="Filename base for emitted artifacts; defaults to the source stem")

    args = parser.parse_args()
    runtime = runtime_from_args(args, require_config=False)

    source = resolve_path(Path.cwd(), args.source)
    out_dir = resolve_path(Path.cwd(), args.out_dir)
    out_dir.mkdir(parents=True, exist_ok=True)
    name = args.name or source.stem

    build_info = ensure_tolk_matches_repo(runtime.repo_root, runtime.build_dir)

    fift_out = out_dir / f"{name}.fif"
    code_boc = out_dir / f"{name}.code.boc"

    completed = run_subprocess(
        [
            str(build_info.binary),
            "-o",
            str(fift_out),
            "-b",
            str(code_boc),
            str(source),
        ],
        cwd=out_dir,
        capture_output=True,
    )
    if completed.stdout:
        print(completed.stdout, end="" if completed.stdout.endswith("\n") else "\n")
    if completed.stderr:
        print(completed.stderr, end="" if completed.stderr.endswith("\n") else "\n")

    fift_completed = run_fift_script_command(
        runtime.repo_root,
        runtime.build_dir,
        fift_out,
        cwd=out_dir,
        capture_output=True,
    )
    if fift_completed.stdout:
        print(fift_completed.stdout, end="" if fift_completed.stdout.endswith("\n") else "\n")

    print(
        json.dumps(
            {
                "source": str(source),
                "tolk_binary": str(build_info.binary),
                "tolk_version": build_info.version,
                "build_commit": build_info.build_commit,
                "build_date": build_info.build_date,
                "fift_output": str(fift_out),
                "code_boc": str(code_boc),
            },
            indent=2,
        )
    )


if __name__ == "__main__":
    main()

"""Run the proven wallet-to-wallet smoke flow on a local tontester network.

Use this script when you want a known-good end-to-end helper check before a
more specialized deploy or validator-behavior repro.
"""

from __future__ import annotations

import argparse
import asyncio
import json
import shlex
import subprocess
import sys
import time
from pathlib import Path


SCRIPT_DIR = Path(__file__).resolve().parent
if str(SCRIPT_DIR) not in sys.path:
    sys.path.insert(0, str(SCRIPT_DIR))

from inspect_latest_transaction import inspect_latest_transaction
from ton_triage_lib import (
    build_tonlib_client,
    normalize_account_address,
    raw_get_account_state_with_timeout,
    resolve_wallet_seqno,
    runtime_from_args,
    wallet_address_from_base,
)

if hasattr(sys.stdout, "reconfigure"):
    sys.stdout.reconfigure(line_buffering=True)
if hasattr(sys.stderr, "reconfigure"):
    sys.stderr.reconfigure(line_buffering=True)


def _format_command(cmd: list[str]) -> str:
    return " ".join(shlex.quote(part) for part in cmd)


def _run_command(cmd: list[str], *, cwd: Path | None = None) -> str:
    print(f"running: {_format_command(cmd)}")
    completed = subprocess.run(
        cmd,
        cwd=cwd,
        check=True,
        text=True,
        capture_output=True,
    )
    if completed.stdout:
        print(completed.stdout, end="" if completed.stdout.endswith("\n") else "\n")
    if completed.stderr:
        print(completed.stderr, end="" if completed.stderr.endswith("\n") else "\n", file=sys.stderr)
    return completed.stdout


def _run_json_command(cmd: list[str], *, cwd: Path | None = None) -> dict[str, object]:
    return json.loads(_run_command(cmd, cwd=cwd))


def _runtime_from_wallet_env(wallet_env: Path):
    return runtime_from_args(
        argparse.Namespace(
            wallet_env=str(wallet_env),
            run_dir=None,
            repo_root=None,
            build=None,
            config=None,
            state_dir=None,
            wallet_base=None,
        )
    )


def _require_process_alive(process: subprocess.Popen[str], *, context: str) -> None:
    if process.poll() is not None:
        raise RuntimeError(f"network launcher exited during {context} with status {process.returncode}")


def _launch_network(args: argparse.Namespace) -> tuple[subprocess.Popen[str], Path, Path]:
    if args.validators < 2:
        raise SystemExit("--validators must be at least 2 for this demo")

    cmd = [
        sys.executable,
        "-u",
        str(SCRIPT_DIR / "run_basic_network.py"),
        "--repo-root",
        str(args.repo_root),
        "--build",
        str(args.build),
        "--workdir",
        args.workdir,
        "--base-port",
        str(args.base_port),
        "--validators",
        str(args.validators),
        "--mc-seqno",
        str(args.mc_seqno),
        "--emit-wallet-env",
        "--keep-alive",
        str(args.keep_alive),
    ]
    print(f"running: {_format_command(cmd)}")
    process = subprocess.Popen(
        cmd,
        cwd=args.repo_root,
        stdout=subprocess.PIPE,
        stderr=subprocess.STDOUT,
        text=True,
        bufsize=1,
    )
    if process.stdout is None:
        raise RuntimeError("failed to capture launcher stdout")

    run_dir: Path | None = None
    wallet_env: Path | None = None
    deadline = time.time() + args.launch_timeout
    while True:
        line = process.stdout.readline()
        if not line:
            if process.poll() is not None:
                raise RuntimeError(f"network launcher exited early with status {process.returncode}")
            if time.time() >= deadline:
                raise TimeoutError("timed out waiting for network launcher output")
            time.sleep(0.1)
            continue

        print(line, end="")
        if line.startswith("run dir: "):
            run_dir = Path(line.removeprefix("run dir: ").strip())
        elif line.startswith("wallet env: "):
            wallet_env = Path(line.removeprefix("wallet env: ").strip())
        elif line.startswith("reached mc seqno >="):
            break

        if time.time() >= deadline:
            raise TimeoutError("timed out waiting for the launcher to reach the target mc seqno")

    if run_dir is None or wallet_env is None:
        raise RuntimeError("launcher output did not include run dir and wallet env")
    return process, run_dir, wallet_env


def _stop_process(process: subprocess.Popen[str]) -> None:
    if process.poll() is not None:
        return
    process.terminate()
    try:
        process.wait(timeout=10)
    except subprocess.TimeoutExpired:
        process.kill()
        process.wait(timeout=10)


def _build_wallet(wallet_env: Path, output_dir: Path, name: str) -> Path:
    wallet_dir = output_dir / name
    wallet_dir.mkdir(parents=True, exist_ok=True)
    _run_command(
        [
            sys.executable,
            str(SCRIPT_DIR / "run_fift_script.py"),
            "--wallet-env",
            str(wallet_env),
            "--script",
            str(SCRIPT_DIR / "fift" / "new-wallet-save-stateinit.fif"),
            "--cwd",
            str(wallet_dir),
            "--",
            "0",
            name,
        ]
    )
    return wallet_dir / name


def _deploy_wallet(wallet_env: Path, dest_addr: str, init_boc: Path, amount: str) -> None:
    _run_command(
        [
            sys.executable,
            str(SCRIPT_DIR / "wallet_send.py"),
            "--wallet-env",
            str(wallet_env),
            f"--dest-addr={dest_addr}",
            "--auto-seqno",
            "--amount",
            amount,
            "--init-boc",
            str(init_boc),
            "--show-seqno",
            "--wait-mc-advance",
            "--wait-timeout",
            "20",
        ]
    )


def _send_from_wallet(
    wallet_env: Path,
    wallet_base: Path,
    dest_addr: str,
    amount: str,
    comment: str,
) -> None:
    _run_command(
        [
            sys.executable,
            str(SCRIPT_DIR / "wallet_send.py"),
            "--wallet-env",
            str(wallet_env),
            "--wallet-base",
            str(wallet_base),
            f"--dest-addr={dest_addr}",
            "--auto-seqno",
            "--amount",
            amount,
            "--comment",
            comment,
            "--show-seqno",
            "--wait-mc-advance",
            "--wait-timeout",
            "20",
        ]
    )


def _verify_seqno_helper(wallet_env: Path, address: str, expected: int) -> dict[str, object]:
    result = _run_json_command(
        [
            sys.executable,
            str(SCRIPT_DIR / "get_method.py"),
            "--wallet-env",
            str(wallet_env),
            f"--address={address}",
            "--method",
            "85143",
        ]
    )
    if result.get("exit_code") != 0 or result.get("top_number") != expected:
        raise RuntimeError(f"unexpected seqno helper result for {address}: {result}")
    return result


async def _wait_for_active(
    client,
    address: str,
    *,
    label: str,
    wait_timeout: float,
    request_timeout: float,
):
    normalized = await normalize_account_address(client, address, request_timeout=request_timeout)
    deadline = asyncio.get_running_loop().time() + wait_timeout
    while True:
        state = await raw_get_account_state_with_timeout(client, normalized.serialized, request_timeout)
        if state.code and state.data and state.last_transaction_id is not None:
            print(
                f"{label} active:"
                f" balance={state.balance}"
                f" last_lt={state.last_transaction_id.lt}"
            )
            return normalized, state
        if asyncio.get_running_loop().time() >= deadline:
            raise TimeoutError(f"timed out waiting for {label} activation")
        await asyncio.sleep(0.5)


async def _wait_for_seqno(
    client,
    address: str,
    *,
    expected: int,
    label: str,
    wait_timeout: float,
    request_timeout: float,
) -> int:
    deadline = asyncio.get_running_loop().time() + wait_timeout
    while True:
        seqno, _method = await resolve_wallet_seqno(client, address, request_timeout=request_timeout)
        if seqno >= expected:
            print(f"{label} seqno now {seqno}")
            return seqno
        if asyncio.get_running_loop().time() >= deadline:
            raise TimeoutError(f"timed out waiting for {label} seqno {expected}")
        await asyncio.sleep(0.5)


async def _wait_for_recipient_transaction(
    client,
    *,
    address: str,
    previous_lt: int,
    expected_source: str,
    expected_comment: str,
    wait_timeout: float,
    request_timeout: float,
) -> dict[str, object]:
    deadline = asyncio.get_running_loop().time() + wait_timeout
    while True:
        tx = await inspect_latest_transaction(client, address, request_timeout=request_timeout)
        transaction = tx["transaction"]
        transaction_id = transaction["transaction_id"]
        current_lt = transaction_id["lt"]
        in_msg = transaction["in_msg"]
        if (
            isinstance(current_lt, int)
            and current_lt > previous_lt
            and isinstance(in_msg, dict)
            and in_msg.get("source") == expected_source
            and in_msg.get("comment") == expected_comment
        ):
            print(
                "recipient transfer observed:"
                f" lt={current_lt}"
                f" comment={expected_comment!r}"
            )
            return tx
        if asyncio.get_running_loop().time() >= deadline:
            raise TimeoutError("timed out waiting for recipient transfer transaction")
        await asyncio.sleep(0.5)


async def _run(args: argparse.Namespace) -> None:
    process: subprocess.Popen[str] | None = None
    client = None
    try:
        process, run_dir, wallet_env = _launch_network(args)
        artifact_dir = run_dir / "wallet-demo"
        artifact_dir.mkdir(parents=True, exist_ok=True)

        wallet_a_base = _build_wallet(wallet_env, artifact_dir, "wallet-a")
        wallet_b_base = _build_wallet(wallet_env, artifact_dir, "wallet-b")
        wallet_a_raw = wallet_address_from_base(wallet_a_base)
        wallet_b_raw = wallet_address_from_base(wallet_b_base)
        print(f"wallet A raw address: {wallet_a_raw}")
        print(f"wallet B raw address: {wallet_b_raw}")

        _require_process_alive(process, context="wallet deployment setup")
        _deploy_wallet(
            wallet_env,
            wallet_a_raw,
            wallet_a_base.with_name(wallet_a_base.name + "-stateinit.boc"),
            args.deploy_amount,
        )
        _require_process_alive(process, context="wallet A deployment")
        _deploy_wallet(
            wallet_env,
            wallet_b_raw,
            wallet_b_base.with_name(wallet_b_base.name + "-stateinit.boc"),
            args.deploy_amount,
        )

        runtime = _runtime_from_wallet_env(wallet_env)
        client = await build_tonlib_client(
            runtime,
            verbosity=args.verbosity,
            request_timeout=args.request_timeout,
        )

        wallet_a_normalized, wallet_a_state = await _wait_for_active(
            client,
            wallet_a_raw,
            label="wallet A",
            wait_timeout=args.wait_timeout,
            request_timeout=args.request_timeout,
        )
        wallet_b_normalized, wallet_b_state = await _wait_for_active(
            client,
            wallet_b_raw,
            label="wallet B",
            wait_timeout=args.wait_timeout,
            request_timeout=args.request_timeout,
        )

        wallet_a_seqno_before = _verify_seqno_helper(wallet_env, wallet_a_raw, expected=0)
        wallet_b_seqno_before = _verify_seqno_helper(wallet_env, wallet_b_raw, expected=0)

        _require_process_alive(process, context="wallet-to-wallet send")
        _send_from_wallet(
            wallet_env,
            wallet_a_base,
            wallet_b_raw,
            args.transfer_amount,
            args.comment,
        )

        sender_seqno_after = await _wait_for_seqno(
            client,
            wallet_a_raw,
            expected=1,
            label="wallet A",
            wait_timeout=args.wait_timeout,
            request_timeout=args.request_timeout,
        )
        recipient_tx = await _wait_for_recipient_transaction(
            client,
            address=wallet_b_raw,
            previous_lt=wallet_b_state.last_transaction_id.lt,
            expected_source=wallet_a_normalized.serialized,
            expected_comment=args.comment,
            wait_timeout=args.wait_timeout,
            request_timeout=args.request_timeout,
        )
        recipient_tx_from_helper = _run_json_command(
            [
                sys.executable,
                str(SCRIPT_DIR / "inspect_latest_transaction.py"),
                "--wallet-env",
                str(wallet_env),
                f"--address={wallet_b_raw}",
            ]
        )
        wallet_a_seqno_after = _verify_seqno_helper(wallet_env, wallet_a_raw, expected=1)

        final_wallet_a_state = await raw_get_account_state_with_timeout(
            client,
            wallet_a_normalized.serialized,
            args.request_timeout,
        )
        final_wallet_b_state = await raw_get_account_state_with_timeout(
            client,
            wallet_b_normalized.serialized,
            args.request_timeout,
        )

        summary = {
            "run_dir": str(run_dir),
            "wallet_env": str(wallet_env),
            "wallet_a": {
                "raw": wallet_a_raw,
                "serialized": wallet_a_normalized.serialized,
                "deploy_balance": wallet_a_state.balance,
                "deploy_last_lt": wallet_a_state.last_transaction_id.lt,
                "seqno_before_send": wallet_a_seqno_before["top_number"],
                "seqno_after_send": wallet_a_seqno_after["top_number"],
                "seqno_after_send_polled": sender_seqno_after,
                "final_balance": final_wallet_a_state.balance,
                "final_last_lt": (
                    final_wallet_a_state.last_transaction_id.lt
                    if final_wallet_a_state.last_transaction_id is not None
                    else None
                ),
            },
            "wallet_b": {
                "raw": wallet_b_raw,
                "serialized": wallet_b_normalized.serialized,
                "deploy_balance": wallet_b_state.balance,
                "deploy_last_lt": wallet_b_state.last_transaction_id.lt,
                "seqno_before_receive": wallet_b_seqno_before["top_number"],
                "final_balance": final_wallet_b_state.balance,
                "final_last_lt": (
                    final_wallet_b_state.last_transaction_id.lt
                    if final_wallet_b_state.last_transaction_id is not None
                    else None
                ),
            },
            "transfer": {
                "amount": args.transfer_amount,
                "comment": args.comment,
                "recipient_transaction": recipient_tx,
                "recipient_transaction_helper": recipient_tx_from_helper,
            },
        }
        summary_path = run_dir / "wallet-demo-summary.json"
        summary_path.write_text(json.dumps(summary, indent=2) + "\n")
        print(f"summary json: {summary_path}")
        print(json.dumps(summary, indent=2))
    finally:
        if client is not None:
            await client.aclose()
        if process is not None:
            _stop_process(process)


def main() -> None:
    parser = argparse.ArgumentParser(
        description="Run a 2-validator local TON network, deploy two wallets, send a comment transfer, and inspect it",
    )
    parser.add_argument("--repo-root", required=True, help="Path to the TON repo root")
    parser.add_argument("--build", required=True, help="Build directory to run")
    parser.add_argument(
        "--workdir",
        default="tmp/tontester-demo-wallet",
        help="Base working directory for run artifacts",
    )
    parser.add_argument("--base-port", type=int, default=3201, help="First TCP/UDP port to allocate")
    parser.add_argument("--validators", type=int, default=2, help="Number of validator nodes")
    parser.add_argument("--mc-seqno", type=int, default=3, help="Initial masterchain seqno target")
    parser.add_argument("--keep-alive", type=int, default=240, help="Seconds to keep the network alive")
    parser.add_argument(
        "--launch-timeout",
        type=float,
        default=90.0,
        help="Timeout while waiting for the launcher to reach the initial mc seqno",
    )
    parser.add_argument(
        "--wait-timeout",
        type=float,
        default=60.0,
        help="Timeout for wallet activation and post-send transaction observation",
    )
    parser.add_argument("--deploy-amount", default="1", help="Amount sent to each wallet on deploy")
    parser.add_argument("--transfer-amount", default="0.1", help="Amount sent from wallet A to wallet B")
    parser.add_argument("--comment", default="skill demo payment", help="Transfer comment payload")
    parser.add_argument("--verbosity", type=int, default=0, help="Tonlib verbosity level")
    parser.add_argument(
        "--request-timeout",
        type=float,
        default=5.0,
        help="Per-request timeout for tonlib calls made by the verifier",
    )

    args = parser.parse_args()
    args.repo_root = Path(args.repo_root).resolve()
    build_path = Path(args.build)
    if not build_path.is_absolute():
        build_path = (args.repo_root / build_path).resolve()
    args.build = build_path
    asyncio.run(_run(args))


if __name__ == "__main__":
    main()

"""Render a BoC cell tree through Fift for human inspection.

Use this when you need to inspect payload, StateInit, or transaction BoCs at
the cell level instead of treating them as opaque bytes.
"""

from __future__ import annotations

import argparse
import tempfile
from pathlib import Path

from ton_triage_lib import resolve_path, run_fift_script_command, runtime_from_args


SCRIPT_DIR = Path(__file__).resolve().parent
FIFT_DIR = SCRIPT_DIR / "fift"


def main() -> None:
    parser = argparse.ArgumentParser(
        description="Dump a BoC cell tree through Fift",
        epilog=(
            "Examples:\n"
            "  python3 dump_boc.py --wallet-env /tmp/run/wallet-env.txt --boc /tmp/contract/code.boc\n"
            "  python3 dump_boc.py --repo-root /path/to/repo --build /path/to/repo/build \\\n"
            "    --boc-hex b5ee9c72410101010004000000"
        ),
        formatter_class=argparse.RawDescriptionHelpFormatter,
    )
    parser.add_argument("--wallet-env", help="Path to wallet-env.txt emitted by the network runner")
    parser.add_argument("--run-dir", help="Run directory containing wallet-env.txt")
    parser.add_argument("--repo-root", help="Path to the TON repo root")
    parser.add_argument("--build", help="Build directory containing create-state")
    parser.add_argument("--config", help="Unused here; accepted for wallet-env compatibility")
    parser.add_argument("--state-dir", help="Unused here; accepted for wallet-env compatibility")
    parser.add_argument("--boc", help="Path to a BoC file")
    parser.add_argument("--boc-hex", help="BoC bytes as a hex string")
    parser.add_argument("--out-file", help="Optional path to also save the dump text")

    args = parser.parse_args()
    if bool(args.boc) == bool(args.boc_hex):
        raise SystemExit("pass exactly one of --boc or --boc-hex")

    runtime = runtime_from_args(args, require_config=False)

    if args.boc:
        boc_path = resolve_path(Path.cwd(), args.boc)
        with tempfile.TemporaryDirectory(prefix="dump-boc-") as tmp_dir:
            completed = run_fift_script_command(
                runtime.repo_root,
                runtime.build_dir,
                FIFT_DIR / "dump_boc.fif",
                cwd=Path(tmp_dir),
                script_args=[str(boc_path)],
                capture_output=True,
            )
    else:
        boc_bytes = bytes.fromhex(args.boc_hex)
        with tempfile.TemporaryDirectory(prefix="dump-boc-") as tmp_dir:
            tmp_path = Path(tmp_dir)
            boc_path = tmp_path / "inline.boc"
            boc_path.write_bytes(boc_bytes)
            completed = run_fift_script_command(
                runtime.repo_root,
                runtime.build_dir,
                FIFT_DIR / "dump_boc.fif",
                cwd=tmp_path,
                script_args=[str(boc_path)],
                capture_output=True,
            )

    dump_text = completed.stdout
    if args.out_file:
        out_file = resolve_path(Path.cwd(), args.out_file)
        out_file.parent.mkdir(parents=True, exist_ok=True)
        out_file.write_text(dump_text)

    print(dump_text, end="" if dump_text.endswith("\n") else "\n")


if __name__ == "__main__":
    main()

#!/usr/bin/fift -s
"TonUtil.fif" include

{ ."usage: " @' $0 type ." <workchain-id> <code-boc> <data-boc-or--> <library-boc-or--> [<filename-base>]" cr
  ."Builds a deployable StateInit BoC from code plus optional data and library dictionary cells." cr
  ."Saves <filename-base>-stateinit.boc and <filename-base>.addr ('contract' by default)." cr
  1 halt
} : usage

$# dup 4 < swap 5 > or ' usage if
5 :$1..n

$1 parse-workchain-id =: wc
$2 =: code-boc-file
$3 =: data-boc-file
$4 =: library-boc-file
$5 "contract" replace-if-null =: file-base

code-boc-file dup ."Loading code cell from file `" type ."`" cr
file>B B>boc =: code

data-boc-file "-" $=
  { null }
  { data-boc-file dup ."Loading data cell from file `" type ."`" cr file>B B>boc }
cond =: data

library-boc-file "-" $=
  { null }
  { library-boc-file dup ."Loading library dictionary cell from file `" type ."`" cr file>B B>boc }
cond =: libraries

data null? {
  libraries null? {
    <b b{00100} s, code ref, b>
  } {
    <b b{00101} s, code ref, libraries ref, b>
  } cond
} {
  libraries null? {
    <b b{00110} s, code ref, data ref, b>
  } {
    <b b{00111} s, code ref, data ref, libraries ref, b>
  } cond
} cond
dup =: state-init

."StateInit cell: " state-init <s csr. cr
state-init 2 boc+>B file-base +"-stateinit.boc" tuck B>file drop
state-init hashu wc swap 2dup 2constant contract_addr
."contract address raw: " 2dup .addr cr
2dup file-base +".addr" save-address-verbose
."contract address non-bounceable: " 2dup 7 .Addr cr
."contract address bounceable: " 6 .Addr cr
."stateinit boc path: " file-base +"-stateinit.boc" type cr
."address file path: " file-base +".addr" type cr

#!/usr/bin/fift -s
"TonUtil.fif" include

{ ."usage: " @' $0 type ." <boc-file>" cr
  ."Loads a single-root BoC from file and prints the cell tree." cr
  1 halt
} : usage

$# 1 <> ' usage if

$1 dup ."Loading BoC from file `" type ."`" cr
file>B B>boc <s csr. cr

#!/usr/bin/fift -s
"TonUtil.fif" include
"Asm.fif" include

{ ."usage: " @' $0 type ." <workchain-id> [<filename-base>]" cr
  ."Creates a new wallet in specified workchain, with private key saved to or loaded from <filename-base>.pk" cr
  ."('new-wallet.pk' by default)" cr 1 halt
} : usage
$# 1- -2 and ' usage if

$1 parse-workchain-id =: wc
def? $2 { @' $2 } { "new-wallet" } cond constant file-base

."Creating new wallet in workchain " wc . cr

<{ SETCP0 DUP IFNOTRET
   DUP 85143 INT EQUAL OVER 78748 INT EQUAL OR IFJMP:<{
     1 INT AND c4 PUSHCTR CTOS 32 LDU 256 PLDU CONDSEL
   }>
   INC 32 THROWIF
   512 INT LDSLICEX DUP 32 PLDU
   c4 PUSHCTR CTOS 32 LDU 256 LDU ENDS
   s1 s2 XCPU
   EQUAL 33 THROWIFNOT
   s2 PUSH HASHSU
   s0 s4 s4 XC2PU
   CHKSIGNU
   34 THROWIFNOT
   ACCEPT
   SWAP 32 LDU NIP
   DUP SREFS IF:<{
     8 LDU LDREF
     s0 s2 XCHG SENDRAWMSG
   }>
   ENDS
   INC NEWC 32 STU 256 STU ENDC c4 POPCTR
}>c
<b 0 32 u,
   file-base +".pk" load-generate-keypair
   constant wallet_pk
   B,
b>
null
<b b{0011} s, 3 roll ref, rot ref, swap dict, b>
dup ."StateInit: " <s csr. cr
dup 2 boc+>B file-base +"-stateinit.boc" tuck B>file drop
dup hashu wc swap 2dup 2constant wallet_addr
."new wallet address = " 2dup .addr cr
2dup file-base +".addr" save-address-verbose
."Non-bounceable address (for init): " 2dup 7 .Addr cr
."Bounceable address (for later access): " 6 .Addr cr
<b 0 32 u, b>
dup ."signing message: " <s csr. cr
dup hashu wallet_pk ed25519_sign_uint rot
<b b{1000100} s, wallet_addr addr, b{000010} s, swap <s s, b{0} s, swap B, swap <s s, b>
dup ."External message for initialization is " <s csr. cr
2 boc+>B dup Bx. cr
file-base +"-query.boc" tuck B>file
."(Saved wallet creating query to file " type .")" cr

"""Run a get-method through tonlib and print the decoded result.

Use this for activation checks, wallet seqno inspection, and contract-specific
state reads after deploy or trigger transactions.
"""

from __future__ import annotations

import argparse
import asyncio
import json

from ton_triage_lib import (
    build_tonlib_client,
    first_stack_number,
    run_get_method,
    runtime_from_args,
    stack_entry_to_json,
)


async def _run(args: argparse.Namespace) -> None:
    runtime = runtime_from_args(args)
    client = await build_tonlib_client(runtime, verbosity=args.verbosity, request_timeout=args.request_timeout)
    try:
        normalized, _info, result = await run_get_method(
            client,
            args.address,
            args.method,
            stack_numbers=args.stack_number,
            request_timeout=args.request_timeout,
        )
    finally:
        await client.aclose()

    output = {
        "address_input": args.address,
        "address_serialized": normalized.serialized,
        "address_raw": normalized.raw,
        "method": args.method,
        "gas_used": result.gas_used,
        "exit_code": result.exit_code,
        "stack": [stack_entry_to_json(entry) for entry in result.stack],
    }
    top_number = first_stack_number(result)
    if top_number is not None:
        output["top_number"] = top_number
    print(json.dumps(output, indent=2))


def main() -> None:
    parser = argparse.ArgumentParser(description="Run a get-method through tonlib and print JSON")
    parser.add_argument("--wallet-env", help="Path to wallet-env.txt emitted by the network runner")
    parser.add_argument("--run-dir", help="Run directory containing wallet-env.txt")
    parser.add_argument("--repo-root", help="Path to the TON repo root")
    parser.add_argument("--build", help="Build directory containing tonlibjson")
    parser.add_argument("--config", help="Lite-client config JSON path")
    parser.add_argument("--state-dir", help="Optional state dir for helper defaults")
    parser.add_argument(
        "--address",
        required=True,
        help="TON account address accepted by tonlib; use --address=<value> for raw forms like -1:...",
    )
    parser.add_argument("--method", required=True, help="Get-method name or numeric id")
    parser.add_argument(
        "--stack-number",
        type=int,
        action="append",
        default=[],
        help="Integer stack argument; repeat as needed",
    )
    parser.add_argument("--verbosity", type=int, default=0, help="Tonlib verbosity level")
    parser.add_argument(
        "--request-timeout",
        type=float,
        default=5.0,
        help="Per-request timeout for tonlib address loading and get-method execution",
    )

    args = parser.parse_args()
    asyncio.run(_run(args))


if __name__ == "__main__":
    main()

"""Fetch the latest account transaction and export useful artifacts.

Use this after deploy or trigger messages when you need transaction details,
decoded comments, or raw BoCs for deeper inspection.
"""

from __future__ import annotations

import argparse
import asyncio
import json
from pathlib import Path

from ton_triage_lib import (
    build_tonlib_client,
    normalize_account_address,
    raw_get_account_state_with_timeout,
    resolve_path,
    runtime_from_args,
    tonlib_call,
)


def _message_data_type(msg_data) -> str:
    data = msg_data.to_dict()
    raw_type = data.get("@type", msg_data.__class__.__name__)
    return str(raw_type)


def _decode_comment_body(body: bytes) -> str | None:
    if len(body) < 4 or body[:4] != b"\x00\x00\x00\x00":
        return None
    payload = body[4:].rstrip(b"\x00")
    if not payload:
        return ""
    try:
        return payload.decode("utf-8")
    except UnicodeDecodeError:
        return None


def _write_bytes_artifact(out_dir: Path | None, filename: str, data: bytes) -> str | None:
    if out_dir is None or not data:
        return None
    path = out_dir / filename
    path.write_bytes(data)
    return str(path)


def _message_data_to_json(
    msg_data,
    *,
    out_dir: Path | None,
    artifact_prefix: str,
) -> dict[str, object]:
    result: dict[str, object] = {"type": _message_data_type(msg_data)}

    text = getattr(msg_data, "text", None)
    if isinstance(text, bytes):
        result["text_hex"] = text.hex()
        try:
            result["text_utf8"] = text.decode("utf-8")
        except UnicodeDecodeError:
            pass
        else:
            result["comment"] = result["text_utf8"]

    body = getattr(msg_data, "body", None)
    if isinstance(body, bytes):
        result["body_len"] = len(body)
        result["body_hex"] = body.hex()
        body_file = _write_bytes_artifact(out_dir, f"{artifact_prefix}-body.boc", body)
        if body_file is not None:
            result["body_file"] = body_file
        comment = _decode_comment_body(body)
        if comment is not None:
            result["comment"] = comment

    init_state = getattr(msg_data, "init_state", None)
    if isinstance(init_state, bytes):
        result["init_state_len"] = len(init_state)
        init_state_file = _write_bytes_artifact(out_dir, f"{artifact_prefix}-init-state.boc", init_state)
        if init_state_file is not None:
            result["init_state_file"] = init_state_file

    return result


def _account_address_value(account_address) -> str | None:
    if account_address is None:
        return None
    return account_address.account_address


def _message_to_json(
    message,
    *,
    out_dir: Path | None,
    artifact_prefix: str,
) -> dict[str, object] | None:
    if message is None:
        return None

    result: dict[str, object] = {
        "hash_hex": message.hash.hex(),
        "source": _account_address_value(message.source),
        "destination": _account_address_value(message.destination),
        "value": message.value,
        "fwd_fee": message.fwd_fee,
        "ihr_fee": message.ihr_fee,
        "created_lt": message.created_lt,
        "body_hash_hex": message.body_hash.hex(),
    }

    if message.msg_data is not None:
        result["msg_data"] = _message_data_to_json(
            message.msg_data,
            out_dir=out_dir,
            artifact_prefix=artifact_prefix,
        )
        comment = result["msg_data"].get("comment")
        if comment is not None:
            result["comment"] = comment

    return result


def _transaction_to_json(transaction, *, out_dir: Path | None) -> dict[str, object]:
    transaction_id = transaction.transaction_id
    result = {
        "address": _account_address_value(transaction.address),
        "utime": transaction.utime,
        "transaction_id": {
            "lt": transaction_id.lt if transaction_id is not None else None,
            "hash_hex": transaction_id.hash.hex() if transaction_id is not None else None,
        },
        "fee": transaction.fee,
        "storage_fee": transaction.storage_fee,
        "other_fee": transaction.other_fee,
        "data_len": len(transaction.data),
        "in_msg": _message_to_json(
            transaction.in_msg,
            out_dir=out_dir,
            artifact_prefix="in-msg",
        ),
        "out_msgs": [
            _message_to_json(
                message,
                out_dir=out_dir,
                artifact_prefix=f"out-msg-{index}",
            )
            for index, message in enumerate(transaction.out_msgs, start=1)
        ],
    }
    if isinstance(transaction.data, bytes):
        result["data_hex"] = transaction.data.hex()
        data_file = _write_bytes_artifact(out_dir, "transaction-data.boc", transaction.data)
        if data_file is not None:
            result["data_file"] = data_file
    return result


async def inspect_latest_transaction(
    client,
    address: str,
    *,
    request_timeout: float = 5.0,
    out_dir: Path | None = None,
) -> dict[str, object]:
    normalized = await normalize_account_address(client, address, request_timeout=request_timeout)
    state = await raw_get_account_state_with_timeout(
        client,
        normalized.serialized,
        request_timeout,
    )
    if state.last_transaction_id is None:
        raise RuntimeError(f"account {normalized.raw} has no transactions yet")

    transactions = await tonlib_call(
        client.raw_get_transactions(
            normalized.serialized,
            state.last_transaction_id.lt,
            state.last_transaction_id.hash,
        ),
        timeout=request_timeout,
        label="raw_get_transactions()",
    )

    latest = None
    for transaction in transactions.transactions:
        transaction_id = transaction.transaction_id
        if transaction_id is None:
            continue
        if (
            transaction_id.lt == state.last_transaction_id.lt
            and transaction_id.hash == state.last_transaction_id.hash
        ):
            latest = transaction
            break

    if latest is None:
        raise RuntimeError(
            "latest transaction id was not present in raw_get_transactions() result"
        )

    return {
        "address_input": address,
        "address_serialized": normalized.serialized,
        "address_raw": normalized.raw,
        "balance": state.balance,
        "last_transaction_id": {
            "lt": state.last_transaction_id.lt,
            "hash_hex": state.last_transaction_id.hash.hex(),
        },
        "transaction": _transaction_to_json(latest, out_dir=out_dir),
    }


async def _run(args: argparse.Namespace) -> None:
    runtime = runtime_from_args(args)
    out_dir = resolve_path(Path.cwd(), args.out_dir) if args.out_dir else None
    if out_dir is not None:
        out_dir.mkdir(parents=True, exist_ok=True)
    client = await build_tonlib_client(runtime, verbosity=args.verbosity, request_timeout=args.request_timeout)
    try:
        result = await inspect_latest_transaction(
            client,
            args.address,
            request_timeout=args.request_timeout,
            out_dir=out_dir,
        )
    finally:
        await client.aclose()

    if out_dir is not None:
        result["out_dir"] = str(out_dir)
        (out_dir / "latest-transaction.json").write_text(json.dumps(result, indent=2) + "\n")

    print(json.dumps(result, indent=2))


def main() -> None:
    parser = argparse.ArgumentParser(description="Fetch the latest account transaction through tonlib")
    parser.add_argument("--wallet-env", help="Path to wallet-env.txt emitted by the network runner")
    parser.add_argument("--run-dir", help="Run directory containing wallet-env.txt")
    parser.add_argument("--repo-root", help="Path to the TON repo root")
    parser.add_argument("--build", help="Build directory containing tonlibjson")
    parser.add_argument("--config", help="Lite-client config JSON path")
    parser.add_argument("--state-dir", help="Optional state dir for helper defaults")
    parser.add_argument(
        "--address",
        required=True,
        help="TON account address accepted by tonlib; use --address=<value> for raw forms like -1:...",
    )
    parser.add_argument("--out-dir", help="Optional output directory for raw transaction and message artifacts")
    parser.add_argument("--verbosity", type=int, default=0, help="Tonlib verbosity level")
    parser.add_argument(
        "--request-timeout",
        type=float,
        default=5.0,
        help="Per-request timeout for tonlib address, state, and transaction queries",
    )

    args = parser.parse_args()
    asyncio.run(_run(args))


if __name__ == "__main__":
    main()

"""Launch a small local TON network from a single build directory.

Use this for single-build smoke tests, contract deploy flows, and any repro
that does not need mixed honest/probing validator binaries.
"""

from __future__ import annotations

import argparse
import asyncio
import time
from pathlib import Path

from ton_triage_lib import (
    add_tontester_to_syspath,
    load_install,
    new_run_dir,
    resolve_path,
    write_wallet_env,
)


def _node_process(node):
    # tontester exposes no public process handle, so liveness checks use the
    # current name-mangled private attribute.
    return getattr(node, "_Node__process", None)


def _node_is_alive(node) -> bool:
    process = _node_process(node)
    return process is not None and process.returncode is None


async def _run(args: argparse.Namespace) -> None:
    if args.validators < 1:
        raise SystemExit("--validators must be at least 1")

    repo_root = resolve_path(Path.cwd(), args.repo_root)
    add_tontester_to_syspath(repo_root)

    from tontester.network import Network
    from tontester.zerostate import SimplexConsensusConfig

    build_dir = resolve_path(repo_root, args.build)
    workdir_base = resolve_path(repo_root, args.workdir)
    workdir = new_run_dir(workdir_base)
    install = load_install(repo_root, build_dir)

    async with Network(install, workdir) as net:
        # tontester does not expose a public base-port setter; this private
        # field controls the first allocated TCP/UDP port for the run.
        net._port = args.base_port - 1  # pylint: disable=protected-access
        if args.enable_simplex:
            simplex = SimplexConsensusConfig()
            net.config.mc_consensus = simplex
            net.config.shard_consensus = simplex
        if args.activate_spam:
            net.config.spam = True

        dht_nodes = [net.create_dht_node() for _ in range(args.dht_nodes)]
        full_nodes = [net.create_full_node() for _ in range(args.validators)]

        for node in full_nodes:
            node.make_initial_validator()
            for dht in dht_nodes:
                node.announce_to(dht)

        for dht in dht_nodes:
            await dht.run()
        for node in full_nodes:
            await node.run()

        print(f"run dir: {workdir}")
        print(f"repo root: {repo_root}")
        print(f"build dir: {build_dir}")
        print(f"base port: {args.base_port}")
        if args.enable_simplex:
            print(
                "simplex config:"
                f" target_block_rate_ms={simplex.target_block_rate_ms}"
                f" slots_per_leader_window={simplex.slots_per_leader_window}"
                f" first_block_timeout_ms={simplex.first_block_timeout_ms}"
                f" max_leader_window_desync={simplex.max_leader_window_desync}"
            )
        for index, dht in enumerate(dht_nodes, start=1):
            print(f"dht{index} log: {dht.log_path}")
        for index, node in enumerate(full_nodes, start=1):
            print(f"node{index} log: {node.log_path}")

        if args.emit_wallet_env:
            lite_config = workdir / args.liteclient_config
            lite_db = workdir / args.lite_db_dir
            lite_db.mkdir(parents=True, exist_ok=True)
            # tontester has no public serializer for the generated liteserver
            # config, so the helper uses the node's private config object here.
            lite_config.write_text(full_nodes[0]._liteserver_config.to_json())  # pylint: disable=protected-access

            env_file = workdir / "wallet-env.txt"
            write_wallet_env(
                env_file,
                repo_root=repo_root,
                build_dir=build_dir,
                tonlibjson=install.tonlibjson,
                workdir=workdir,
                state_dir=workdir / "state",
                main_wallet_base=workdir / "state" / "main-wallet",
                liteclient_config=lite_config,
                lite_db=lite_db,
                extra={
                    "RUNTIME_NODE": "node1",
                    "RUNTIME_ROLE": "baseline",
                },
            )
            print(f"wallet env: {env_file}")

        deadline = time.time() + args.wait_timeout
        last_error: Exception | None = None
        while True:
            if all(not _node_is_alive(node) for node in full_nodes):
                status = ", ".join(f"node{index}:{_node_process(node).returncode}" for index, node in enumerate(full_nodes, start=1))
                raise RuntimeError(f"all validator nodes exited before mc seqno {args.mc_seqno} was reached: {status}")
            try:
                await net.wait_mc_block(seqno=args.mc_seqno)
                break
            except Exception as exc:
                last_error = exc
                if time.time() >= deadline:
                    message = f"timed out waiting for mc seqno {args.mc_seqno}"
                    if last_error is not None:
                        message += f"; last error: {last_error}"
                    raise TimeoutError(message) from last_error
                await asyncio.sleep(0.5)

        print(f"reached mc seqno >= {args.mc_seqno}")

        keep_alive = args.keep_alive
        if keep_alive is None:
            keep_alive = 300 if args.emit_wallet_env else 0
        if keep_alive > 0:
            print(f"keeping network alive for {keep_alive} seconds")
            await asyncio.sleep(keep_alive)


def main() -> None:
    parser = argparse.ArgumentParser(description="Run a simple local TON test network with tontester")
    parser.add_argument("--repo-root", required=True, help="Path to the TON repo root")
    parser.add_argument("--build", required=True, help="Build directory to run")
    parser.add_argument(
        "--workdir",
        default="tmp/tontester-basic",
        help="Base working directory for node data",
    )
    parser.add_argument(
        "--base-port",
        type=int,
        default=2001,
        help="First TCP/UDP port to allocate inside the run",
    )
    parser.add_argument("--validators", type=int, default=1, help="Number of validator nodes")
    parser.add_argument("--dht-nodes", type=int, default=1, help="Number of DHT nodes")
    parser.add_argument("--mc-seqno", type=int, default=3, help="Masterchain seqno target")
    parser.add_argument(
        "--wait-timeout",
        type=int,
        default=60,
        help="Timeout in seconds while waiting for the target seqno",
    )
    parser.add_argument(
        "--keep-alive",
        type=int,
        default=None,
        help="Seconds to keep the network running after the target seqno is reached; defaults to 300 with --emit-wallet-env, else 0",
    )
    parser.add_argument(
        "--emit-wallet-env",
        action="store_true",
        help="Write wallet-env.txt and liteclient.config.json into the run directory",
    )
    parser.add_argument(
        "--liteclient-config",
        default="liteclient.config.json",
        help="Filename for lite-client config in the run directory",
    )
    parser.add_argument(
        "--lite-db-dir",
        default="lite-db",
        help="Lite-client DB directory name under the run directory",
    )
    parser.add_argument(
        "--enable-simplex",
        action="store_true",
        help="Enable simplex consensus in the generated zerostate",
    )
    parser.add_argument(
        "--activate-spam",
        action="store_true",
        help="Include the spammer contract in the generated zerostate",
    )

    args = parser.parse_args()
    try:
        asyncio.run(_run(args))
    except KeyboardInterrupt:
        print("interrupted")


if __name__ == "__main__":
    main()

"""Run a Fift script with the skill's standard TON include paths.

Use this for one-off Fift helpers that emit BoCs or other artifacts without
having to hand-assemble the create-state invocation each time.
"""

from __future__ import annotations

import argparse
import subprocess
from pathlib import Path

from ton_triage_lib import load_install, resolve_path, runtime_from_args


def main() -> None:
    parser = argparse.ArgumentParser(description="Run a Fift script with standard TON include paths")
    parser.add_argument("--wallet-env", help="Path to wallet-env.txt emitted by the network runner")
    parser.add_argument("--run-dir", help="Run directory containing wallet-env.txt")
    parser.add_argument("--repo-root", help="Path to the TON repo root")
    parser.add_argument("--build", help="Build directory containing create-state")
    parser.add_argument("--script", required=True, help="Path to the Fift script to execute")
    parser.add_argument(
        "--cwd",
        help="Working directory for outputs created by the Fift script; defaults to WORKDIR from wallet-env",
    )
    parser.add_argument(
        "script_args",
        nargs=argparse.REMAINDER,
        help="Arguments passed through to the Fift script after '--'",
    )

    args = parser.parse_args()
    runtime = runtime_from_args(args, require_config=False)
    repo_root = runtime.repo_root
    build_dir = runtime.build_dir
    script_path = resolve_path(Path.cwd(), args.script)
    if args.cwd:
        cwd = resolve_path(Path.cwd(), args.cwd)
    elif runtime.workdir is not None:
        cwd = runtime.workdir
    else:
        cwd = Path.cwd().resolve()
    cwd.mkdir(parents=True, exist_ok=True)
    install = load_install(repo_root, build_dir)

    passthrough = args.script_args
    if passthrough[:1] == ["--"]:
        passthrough = passthrough[1:]

    cmd = [str(install.fift_exe)]
    for include_dir in install.fift_include_dirs:
        cmd += ["-I", str(include_dir)]
    cmd += ["-s", str(script_path), *passthrough]

    print("running:", " ".join(cmd))
    print(f"cwd: {cwd}")
    subprocess.run(cmd, cwd=cwd, check=True)


if __name__ == "__main__":
    main()