The #81 was created before we separated proving from the go-spacemesh into the post-service connected to the node via GRPC. Previously proving was called over FFI and it was a problem that it couldn't be interrupted. Now that's not an issue anymore.

What's the benefit of having this GRPC endpoint? The same thing can be achieved by shutting down the post-service (SIGINT).

I think the more interesting part is preservation of the progress:

It should be possible to interrupt proof generation and continue later from the point it stopped.

That should be useful for users that need to stop proving for some reason (e.g. HW issues, power outage etc.), so they could continue proving instead of starting over.

Regarding interrupting the FFI proving call, you could pass in a function to be called from rust to periodically check if it should stop, then the Go side could use an atomic set from a different thread to interrupt proving. Or Rust could spawn a thread in which proving would run and return an opaque handle. This handle could be passed into a C/Rust function to interrupt. Something like:

handle := C.generate_proof(....) // actual proving runs async on a thread
ticker := time.NewTicker(time.Minute)
defer ticker.Stop()
for {
  switch {
    case <- ctx.Done():
      C.interrupt_proving(handle)
    case <- ticker.C:
       result := C.proof(handle)
       // ... handle _in progress_ vs _finished_
    }
}