feat(server,cli): auto-renew statement-store allowances

rust/crates/truapi-host-cli/e2e/run.sh

@@ -0,0 +1,103 @@
+#!/usr/bin/env bash
+# Headless end-to-end run: a pairing host drives a product script against a
+# signing host, pairing over the real People-chain statement store.
+#
+#   make headless                  # build once
+#   e2e/run.sh                     # generates pairing-host-cli.md (default)
+#   e2e/run.sh path/to/script.ts   # runs a custom product script
+#
+# Env:
+#   PRODUCT_ID               product id the pairing host serves (default truapi-playground.dot)
+#   HOST_CLI_SIGNER_MNEMONIC optional wallet mnemonic; when unset, signing-host auto-manages one
+#   TRUAPI_HOST_BASE_PATH    optional root for generated accounts and host state
+#   TRUAPI_PAIRING_BASE_PATH optional pairing-host state root; defaults to a fresh temporary root
+#   TRUAPI_E2E_LOAD_ENV      set to 0 to ignore the gitignored e2e/.env (default 1)
+#   FRAME                    frame-server address (default 127.0.0.1:9955)
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "$0")/../../../.." && pwd)"
+BIN="$ROOT/target/debug/truapi-host"
+
+# Load HOST_CLI_SIGNER_MNEMONIC / TRUAPI_HOST_BASE_PATH (and any other vars)
+# from a gitignored e2e/.env if present.
+ENV_FILE="$(dirname "$0")/.env"
+if [ "${TRUAPI_E2E_LOAD_ENV:-1}" = 1 ] && [ -f "$ENV_FILE" ]; then
+  set -a
+  . "$ENV_FILE"
+  set +a
+fi
+
+SCRIPT="${1:-$ROOT/rust/crates/truapi-host-cli/js/scripts/battery.ts}"
+PRODUCT_ID="${PRODUCT_ID:-truapi-playground.dot}"
+FRAME="${FRAME:-127.0.0.1:9955}"
+
+PAIRING_BASE_PATH_OWNED=0
+if [ -n "${TRUAPI_PAIRING_BASE_PATH:-}" ]; then
+  PAIRING_BASE_PATH="$TRUAPI_PAIRING_BASE_PATH"
+else
+  PAIRING_BASE_PATH="$(mktemp -d /tmp/truapi-e2e-pairing.XXXXXX)"
+  PAIRING_BASE_PATH_OWNED=1
+fi
+
+[ -x "$BIN" ] || { echo "missing $BIN — run: make headless" >&2; exit 2; }
+
+LOG="$(mktemp)"
+SIGNER_PID=""
+PAIR_PID=""
+stop_pairing_host() {
+  [ -n "$PAIR_PID" ] || return 0
+  pkill -TERM -P "$PAIR_PID" 2>/dev/null || true
+  kill -TERM "$PAIR_PID" 2>/dev/null || true
+  sleep 0.5
+  pkill -KILL -P "$PAIR_PID" 2>/dev/null || true
+  kill -KILL "$PAIR_PID" 2>/dev/null || true
+}
+cleanup() {
+  [ -n "$SIGNER_PID" ] && kill "$SIGNER_PID" 2>/dev/null || true
+  stop_pairing_host
+  rm -f "$LOG"
+  if [ "$PAIRING_BASE_PATH_OWNED" -eq 1 ]; then
+    rm -rf -- "$PAIRING_BASE_PATH"
+  fi
+}
+trap cleanup EXIT
+
+# The pairing host runs the product script; the script's
+# `truapi.account.requestLogin` makes the host emit a pairing deeplink, which we
+# hand to a signing host. The pairing host exits with the script's status.
+"$BIN" pairing-host --product-id "$PRODUCT_ID" --script "$SCRIPT" \
+  --frame-listen "$FRAME" --base-path "$PAIRING_BASE_PATH" \
+  --auto-accept > >(tee "$LOG") 2>&1 &
+PAIR_PID=$!
+
+deeplink=""
+for _ in $(seq 1 600); do
+  deeplink="$(grep -m1 -oE 'polkadotapp://pair\?handshake=[[:xdigit:]]+' "$LOG" || true)"
+  [ -n "$deeplink" ] && break
+  kill -0 "$PAIR_PID" 2>/dev/null || break
+  sleep 0.5
+done
+[ -n "$deeplink" ] || { echo "pairing host did not emit a deeplink" >&2; exit 1; }
+
+# The signing host reads HOST_CLI_SIGNER_MNEMONIC from the env when set.
+# Otherwise it auto-selects or creates an attested account under its base path.
+"$BIN" signing-host --auto-accept exec "/deeplink $deeplink" &
+SIGNER_PID=$!
+
+pid_running() {
+  local stat
+  stat="$(ps -p "$1" -o stat= 2>/dev/null || true)"
+  [ -n "$stat" ] && [ "${stat#Z}" = "$stat" ]
+}
+
+while :; do
+  if ! pid_running "$PAIR_PID"; then
+    wait "$PAIR_PID"
+    exit $?
+  fi
+  if ! pid_running "$SIGNER_PID"; then
+    stop_pairing_host
+    exit 1
+  fi
+  sleep 0.5
+done

rust/crates/truapi-host-cli/src/main.rs

@@ -37,7 +37,10 @@ use tracing_subscriber::util::SubscriberInitExt;
 use truapi_platform::{HostInfo, PlatformInfo};
 use truapi_server::statement_allowance as alloc;
 use truapi_server::subscription::Spawner;
-use truapi_server::{PairingHostConfig, PairingHostRuntime, SigningHostConfig, SigningHostRuntime};
+use truapi_server::{
+    PairingHostConfig, PairingHostRuntime, SigningHostConfig, SigningHostRuntime,
+    StatementRenewalTarget,
+};
 
 use crate::accounts::{ResolveSignerConfig, ResolvedSigner};
 use crate::network::{Network, NetworkConfig};
@@ -898,11 +901,9 @@ fn build_signing_runtime(
         network.bulletin_genesis,
     )
     .context("invalid signing host config")?;
-    Ok(Arc::new(SigningHostRuntime::new(
-        platform,
-        config,
-        tokio_spawner(),
-    )))
+    let runtime = Arc::new(SigningHostRuntime::new(platform, config, tokio_spawner()));
+    runtime.start_statement_allowance_renewal();
+    Ok(runtime)
 }
 
 impl Drop for SigningHostSession {
@@ -1082,7 +1083,10 @@ async fn prepare_pairing_response(session: &mut SigningHostSession, deeplink: &s
             )
         };
         match register_pairing_allowances(session.network.people_ws, &entropy, deeplink).await {
-            Ok(()) => return Ok(()),
+            Ok(device) => {
+                track_pairing_renewal_targets(session, device).await;
+                return Ok(());
+            }
             Err(err) if auto_managed && is_statement_slot_exhaustion(&err) => {
                 attempts += 1;
                 if attempts > 8 {
@@ -1132,6 +1136,99 @@ fn is_statement_slot_exhaustion(err: &anyhow::Error) -> bool {
     err.to_string().contains("no free StatementStore slot")
 }
 
+/// Best-effort: record the pairing allowance accounts in the renewal ledger so
+/// the background renewer keeps them allowed across periods.
+async fn track_pairing_renewal_targets(session: &SigningHostSession, device: [u8; 32]) {
+    let result = session
+        .runtime
+        .track_statement_renewal_targets(vec![
+            StatementRenewalTarget::WalletSso,
+            StatementRenewalTarget::Account {
+                account_id: device,
+                label: "device".to_string(),
+            },
+        ])
+        .await;
+    if let Err(err) = result {
+        tracing::warn!(reason = %err.reason, "failed to record pairing renewal targets");
+    }
+}
+
+/// Renew tracked statement-store allowances now, reporting each target. On
+/// slot exhaustion an auto-managed signer account is marked exhausted so the
+/// next pairing rotates to a fresh one.
+async fn run_renew(session: &mut SigningHostSession) -> Result<()> {
+    use truapi_server::statement_allowance::renewal::TargetRenewalStatus;
+
+    ensure_signer(session).await?;
+    let report = session
+        .runtime
+        .renew_statement_allowances()
+        .await
+        .map_err(|err| anyhow::anyhow!("allowance renewal failed: {}", err.reason))?;
+
+    let (mut renewed, mut fresh, mut failed, mut skipped) = (0usize, 0usize, 0usize, 0usize);
+    for (target, status) in &report.outcomes {
+        match status {
+            TargetRenewalStatus::Registered { seq, block_hash } => {
+                renewed += 1;
+                terminal_ui::output_event(SystemEvent::AllowanceReady {
+                    target: target.clone(),
+                    sequence: *seq,
+                    block_hash: Some(block_hash.clone()),
+                    already_allocated: false,
+                });
+            }
+            TargetRenewalStatus::AlreadyAllocated { seq } => {
+                fresh += 1;
+                terminal_ui::output_event(SystemEvent::AllowanceReady {
+                    target: target.clone(),
+                    sequence: *seq,
+                    block_hash: None,
+                    already_allocated: true,
+                });
+            }
+            TargetRenewalStatus::Failed { reason } => {
+                failed += 1;
+                terminal_ui::output_event(SystemEvent::AllowanceRenewalFailed {
+                    target: target.clone(),
+                    reason: reason.clone(),
+                });
+            }
+            TargetRenewalStatus::SkippedExhausted => skipped += 1,
+        }
+    }
+    terminal_ui::output_event(SystemEvent::AllowanceRenewalReport {
+        period: report.period,
+        renewed,
+        fresh,
+        failed,
+        skipped,
+    });
+
+    if report.slots_exhausted {
+        mark_current_account_exhausted(session)?;
+    }
+    Ok(())
+}
+
+fn mark_current_account_exhausted(session: &SigningHostSession) -> Result<()> {
+    let Some(signer) = session.signer.as_ref() else {
+        return Ok(());
+    };
+    if !signer.auto_managed {
+        return Ok(());
+    }
+    let Some(name) = signer.account_name.clone() else {
+        return Ok(());
+    };
+    let period = accounts::current_statement_period()?;
+    let account_base_path = current_account_base_path(session)?;
+    accounts::mark_account_exhausted(&account_base_path, session.network.id, &name, period)?;
+    terminal_ui::output_event(SystemEvent::SigningHostAccountExhausted { name, period });
+    Ok(())
+}
+
 async fn respond_to_deeplink(session: &mut SigningHostSession, deeplink: String) -> Result<()> {
     prepare_pairing_response(session, &deeplink).await?;
     let exit = session
@@ -1316,11 +1413,13 @@ async fn switch_session(session: &mut SigningHostSession, name: String) -> Resul
 /// statements during pairing: the signing host's RFC-0022 `uid.dot` identity
 /// account and the pairing host's per-pairing device key (from the deeplink).
 /// Proves the signing account's LitePeople ring membership once and reuses it.
+/// Returns the device statement account id so the caller can track it for
+/// renewal.
 async fn register_pairing_allowances(
     statement_store_url: &str,
     entropy: &[u8],
     deeplink: &str,
-) -> Result<()> {
+) -> Result<[u8; 32]> {
     use truapi_server::host_logic::product_account::{
         derive_identity_keypair, derive_lite_person_ring_vrf_entropy,
     };
@@ -1418,7 +1517,7 @@ async fn register_pairing_allowances(
             }
         }
     }
-    Ok(())
+    Ok(device)
 }
 
 async fn pairing_interactive_loop(
@@ -1527,7 +1626,7 @@ async fn pairing_interactive_loop(
                     Err(error) => ui.error(error.to_string()),
                 }
             }
-            ShellCommand::Pair(_) | ShellCommand::Session(_) => {
+            ShellCommand::Pair(_) | ShellCommand::Session(_) | ShellCommand::Renew => {
                 ui.error("command is only available on the signing host");
             }
         }
@@ -1777,6 +1876,7 @@ async fn execute_interactive_operation(
         ShellCommand::Session(SessionCommand::Switch(name)) => {
             switch_session(session, name).await?;
         }
+        ShellCommand::Renew => run_renew(session).await?,
         ShellCommand::Login => bail!("/login is only available on the pairing host"),
         ShellCommand::Logout => bail!("/logout is only available on the pairing host"),
         ShellCommand::Product(_) => bail!("command must be handled by the terminal UI"),
@@ -1858,6 +1958,7 @@ async fn execute_non_interactive_command(
         ShellCommand::Session(SessionCommand::Switch(name)) => {
             switch_session(session, name).await?;
         }
+        ShellCommand::Renew => run_renew(session).await?,
     }
     Ok(())
 }

rust/crates/truapi-host-cli/src/signing_shell.rs

@@ -52,6 +52,8 @@ pub enum ShellCommand {
     Product(ProductCommand),
     /// Inspect, list, or switch the active persistent session.
     Session(SessionCommand),
+    /// Renew tracked statement-store allowances for the current period.
+    Renew,
     /// Shut down the signing host.
     Quit,
 }
@@ -116,6 +118,7 @@ pub fn parse_command(input: &str) -> Result<ShellCommand, String> {
                 argument.to_string(),
             )))
         }
+        "/renew" => no_argument(name, argument, ShellCommand::Renew),
         "/quit" => no_argument(name, argument, ShellCommand::Quit),
         _ => Err(format!(
             "unknown command `{name}`; use /help to list commands"
@@ -146,6 +149,7 @@ const SIGNING_COMMANDS: &[(&str, &str)] = &[
     ("/log", "set error, warn, info, debug, or trace"),
     ("/product", "show or switch the active product"),
     ("/session", "show or switch the active session"),
+    ("/renew", "renew statement-store allowances now"),
     ("/help", "show commands and keyboard shortcuts"),
     ("/clear", "clear the visible transcript"),
     ("/copy", "copy the transcript to the clipboard"),
@@ -532,6 +536,7 @@ pub const HELP_TEXT: &str = "\
 /session                show the current session and path
 /session <name>         switch to or create a session
 /session --list         list sessions for this network
+/renew                  renew statement-store allowances now
 /help                   show this help
 /clear                  clear the visible transcript
 /copy                   copy the transcript to the clipboard
@@ -593,6 +598,7 @@ mod tests {
             )))
         );
         assert_eq!(parse_command("/copy"), Ok(ShellCommand::Copy));
+        assert_eq!(parse_command("/renew"), Ok(ShellCommand::Renew));
         assert_eq!(
             parse_command("/session"),
             Ok(ShellCommand::Session(SessionCommand::Current))
@@ -618,6 +624,7 @@ mod tests {
         assert!(parse_command("/logout now").is_err());
         assert!(parse_command("/pair https://example.com").is_err());
         assert!(parse_command("/deeplink polkadotapp://pair?handshake=01").is_err());
+        assert!(parse_command("/renew now").is_err());
         assert!(parse_command("/log noisy").is_err());
         assert!(parse_command("/product example.com").is_err());
         assert!(parse_command("/session ../escape").is_err());