upstream changes

.editorconfig

@@ -0,0 +1,10 @@
+root = true
+
+[*.md]
+indent_style = space
+indent_size = 4
+trim_trailing_whitespace = false
+max_line_length = 80
+insert_final_newline = true
+charset = utf-8
+end_of_line = lf

.github/actions/export-env-vars/action.yml

@@ -0,0 +1,52 @@
+name: Export Repository Variables
+description: Export all repository/environment variables from a JSON map into GITHUB_ENV.
+
+inputs:
+  vars_json:
+    description: JSON object map of repository/environment variables.
+    required: true
+
+runs:
+  using: composite
+  steps:
+    - name: Export variables to GITHUB_ENV
+      shell: bash
+      env:
+        VARS_JSON: ${{ inputs.vars_json }}
+      run: |
+        python3 - <<'PY'
+        import json
+        import os
+        import uuid
+
+        vars_map = json.loads(os.environ.get("VARS_JSON", "{}"))
+        env_path = os.environ["GITHUB_ENV"]
+        alias_prefixes = (
+            "BB_DEV_RPC_URL_HTTP_",
+            "BB_DEV_RPC_URL_WS_",
+            "BB_DEV_MQ_URL_",
+            "BB_PROD_RPC_URL_HTTP_",
+            "BB_PROD_RPC_URL_WS_",
+            "BB_PROD_MQ_URL_",
+            "BB_RPC_BIND_HOST_",
+            "BB_RPC_ALLOW_IP_",
+            "BB_DEV_API_URL_HTTP_",
+            "BB_DEV_API_URL_WS_",
+        )
+
+        def write_env_var(env_file, key, value):
+            delimiter = f"__{uuid.uuid4().hex}__"
+            env_file.write(f"{key}<<{delimiter}\n{value}\n{delimiter}\n")
+
+        with open(env_path, "a", encoding="utf-8") as env_file:
+            for key, value in vars_map.items():
+                text = "" if value is None else str(value)
+                normalized = key
+                for prefix in alias_prefixes:
+                    if key.startswith(prefix):
+                        alias = key[len(prefix):]
+                        # Blockbook env lookups use lowercase coin aliases from configs/coins.
+                        normalized = prefix + alias.lower().replace("-", "_")
+                        break
+                write_env_var(env_file, normalized, text)
+        PY

.github/bin/bbcli

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+script_dir="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)"
+repo_root="$(cd -- "${script_dir}/../.." && pwd)"
+
+exec "${repo_root}/.github/scripts/run.py" "$@"

.github/scripts/backend_decision.py

@@ -0,0 +1,49 @@
+#!/usr/bin/env python3
+
+from __future__ import annotations
+
+import os
+import shlex
+import sys
+from pathlib import Path
+
+import backend_policy
+from coin_rpc import CoinRPCError, load_config, resolve_build_env
+
+
+def format_shell(decision: dict, build_env: str) -> str:
+    pairs = {
+        "BACKEND_SHOULD_BUILD": "1" if decision["should_build_backend"] else "0",
+        "BACKEND_REASON": decision["reason"],
+        "BACKEND_RPC_ENV": decision["rpc_env"],
+        "BACKEND_RPC_HOST": decision["rpc_host"],
+        "BACKEND_COIN_ALIAS": decision["coin_alias"],
+        "BACKEND_BUILD_ENV": build_env,
+    }
+    return "\n".join(f"{key}={shlex.quote(str(value))}" for key, value in pairs.items())
+
+
+def main(argv: list[str] | None = None) -> None:
+    args = list(sys.argv[1:] if argv is None else argv)
+    if len(args) != 1:
+        raise CoinRPCError(f"usage: {Path(sys.argv[0]).name} <coin>")
+    coin = args[0]
+    config_path = Path("configs") / "coins" / f"{coin}.json"
+    if not config_path.is_file():
+        raise CoinRPCError(f"missing coin config {config_path}")
+    build_env = resolve_build_env()
+    decision = backend_policy.compute_backend_decision(
+        coin=coin,
+        config=load_config(config_path),
+        build_env=build_env,
+        backend_mode=backend_policy.BACKEND_MODE_AUTO,
+    )
+    print(format_shell(decision, build_env))
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except CoinRPCError as exc:
+        print(str(exc), file=sys.stderr)
+        raise SystemExit(1)

.github/scripts/backend_policy.py

@@ -0,0 +1,57 @@
+#!/usr/bin/env python3
+
+from __future__ import annotations
+
+import os
+from typing import Mapping
+
+from coin_rpc import get_coin_alias, rpc_hostname, rpc_url_env_name
+
+BACKEND_MODE_AUTO = "auto"
+BACKEND_MODE_ALWAYS = "always"
+BACKEND_MODE_NEVER = "never"
+
+
+def should_build_backend(
+    *,
+    backend_mode: str,
+    rpc_url: str,
+) -> tuple[bool, str]:
+    if backend_mode == BACKEND_MODE_NEVER:
+        return False, "backend-mode-never"
+    if backend_mode == BACKEND_MODE_ALWAYS:
+        return True, "backend-mode-always"
+    if not rpc_url:
+        return True, "rpc-url-env-missing-or-empty"
+    rpc_host = rpc_hostname(rpc_url)
+    if not rpc_host:
+        return False, "rpc-host-missing"
+    if rpc_host in {"localhost", "127.0.0.1", "::1"}:
+        return True, f"rpc-host-is-local-{rpc_host}"
+    return False, f"rpc-host-is-remote-{rpc_host}"
+
+
+def compute_backend_decision(
+    *,
+    coin: str,
+    config: dict,
+    build_env: str,
+    backend_mode: str,
+    env: Mapping[str, str] | None = None,
+) -> dict:
+    if env is None:
+        env = os.environ
+    coin_alias = get_coin_alias(config, coin)
+    rpc_env = rpc_url_env_name(coin_alias, build_env)
+    rpc_url = env.get(rpc_env, "").strip()
+    should_build, reason = should_build_backend(
+        backend_mode=backend_mode,
+        rpc_url=rpc_url,
+    )
+    return {
+        "coin_alias": coin_alias,
+        "rpc_env": rpc_env,
+        "rpc_host": rpc_hostname(rpc_url),
+        "should_build_backend": should_build,
+        "reason": reason,
+    }