…ad code)

tx_manager.py imported 'grpc' (the grpcio library) and caught grpc.RpcError
in two places — _estimate_gas and _get_tx. But the gRPC channel underneath
is grpclib.client.Channel, from the unrelated 'grpclib' library. grpclib's
exception types (GRPCError, StreamTerminatedError, ProtocolError) all
inherit directly from Exception and are NOT subclasses of grpc.RpcError.

Result: both except blocks were silent dead code for the entire lifetime
of the SDK.

Practical impact:
  - _estimate_gas: 'account sequence mismatch' detection during gas
    simulation never fired. Real grpclib errors fell into the bare
    'except Exception' below it and re-raised without being converted to
    AccountSequenceMismatchError. The retry loop in _attempt_submissions
    then never refreshed the sequence number for the next attempt.
  - _get_tx: TxNotFoundError detection 'worked' only by accident — the
    bare 'except Exception' fallback's substring match on str(e) caught it
    because str(GRPCError) happens to contain both 'tx' and 'not found'.
    A genuinely tx-not-found-only check (e.g. 'tx' in details and 'not
    found' in details) was load-bearing on this accident.

Bonus latent bug: if anything had actually entered the grpc.RpcError
block, 'e.details()' would have crashed with TypeError. grpclib's
GRPCError.details is an attribute (defaulting to None), not a method.
The fix uses .message instead, which is the correct accessor for the
textual payload from the server.

Tests added: tests/test_tx_manager_grpclib_errors.py
  - 3 real-path tests for _get_tx (not-found conversion, propagation,
    happy path) using AsyncMock with grpclib.GRPCError side effects
  - 2 regression assertions pinning down grpclib semantics so a future
    'simplify the import' change doesn't accidentally re-introduce the
    bug:
      * GRPCError is NOT a subclass of grpc.RpcError
      * GRPCError.message is an attribute (str), not a callable

…rt failures

Adds explicit handling for grpclib transport-layer failures in the
_attempt_submissions retry loop. Pre-fix: any grpclib.StreamTerminatedError
or grpclib.GRPCError(Status.UNAVAILABLE) mid-broadcast fell through to the
bare 'except Exception' branch, which set the future to the error and
returned — zero retries, no recovery.

Changes:

1. New GRPCTransportError exception class. Raised when we observe one of
   the four transport-class failures (stream-terminated, UNAVAILABLE,
   'connection reset by peer', 'unexpected EOF'). Same scenarios that
   trigger node-switching in the Go offchain-node fix.

2. New _is_grpclib_transport_error(exc) helper. Classifies an arbitrary
   exception as a transport failure (positive: StreamTerminatedError,
   UNAVAILABLE, the substring set above; negative: NOT_FOUND, sequence
   mismatch, permission errors, RuntimeError, etc.). Single source of
   truth for what counts as transport-class.

3. _estimate_gas and _get_tx now wrap grpclib transport errors as
   GRPCTransportError before re-raising. Non-transport grpclib errors
   keep their existing semantics (NOT_FOUND → TxNotFoundError, account
   sequence mismatch → AccountSequenceMismatchError, others propagate).

4. _attempt_submissions retry loop now has two new branches:
   - 'except GRPCTransportError': retry within the existing retry budget,
     call _on_transport_failure() between attempts (the actual reconnect
     wiring lands in the next commit).
   - 'except (GRPCError, StreamTerminatedError)' defensive net: catches
     grpclib errors that escaped from the broadcast/auth_info path
     without going through the GRPCTransportError wrapper. Re-classifies
     via _is_grpclib_transport_error and routes to the same retry
     behaviour, or falls through to the existing fail-the-future
     handling for non-transport flavours.

5. _on_transport_failure() hook added as a no-op stub. Commit 3 will
   replace this with an actual channel close-and-redial. The no-op emits
   a WARNING-level log so the dead-channel-retry situation is at least
   visible until the wiring lands.

Tests added (5 new in tests/test_tx_manager_grpclib_errors.py):
  - get_tx converts UNAVAILABLE to GRPCTransportError
  - get_tx converts 'connection reset by peer' to GRPCTransportError
  - get_tx converts StreamTerminatedError to GRPCTransportError
  - get_tx still re-raises non-transport non-not-found errors untouched
    (test now uses PERMISSION_DENIED instead of UNAVAILABLE)
  - _is_grpclib_transport_error classification: 4 positive cases (incl.
    StreamTerminatedError and all 3 substring forms) and 5 negative
    cases pinning the boundary (NOT_FOUND, sequence mismatch, permission
    denied, RuntimeError, plain Exception)

All 13 existing+new unit tests pass. Integration tests not run (require
testnet API access).

…ecovery hook

Replaces the no-op stub from the previous commit with the actual
close-and-redial logic. When a transport-class failure is detected in
the retry loop, TxManager now invokes a callback that:

  1. Closes the current grpclib.Channel (best-effort; closing a dead
     channel can itself raise — caught and debug-logged so it doesn't
     mask the original failure)
  2. Dials a fresh Channel against the same host/port/ssl settings
  3. Constructs fresh QueryStub instances bound to the new channel
  4. Mutates the TxManager's stub references in place
     (tx_client, auth_client, bank_client, feemarket_client) so the
     existing TxManager instance keeps working without callers needing
     to know anything reconnected

Implementation:

  * client.py: factored the stub-construction logic out of __init__
    into _build_clients(). __init__ now calls it once; _reconnect_grpc()
    calls it again on demand. Splitting the logic keeps the initial-
    setup path and the reconnect path on a single code path so they
    can't drift.

  * client.py: new async _reconnect_grpc() method. REST-protocol-aware
    (no-op when the configured URL is REST-only — REST uses pooled HTTP
    and doesn't have the same dead-channel problem).

  * client.py: AlloraRPCClient passes self._reconnect_grpc as the
    reconnect_callback when constructing TxManager.

  * tx_manager.py: __init__ now accepts reconnect_callback. The hook
    swallows exceptions from the callback itself — a failed reconnect
    should not cascade into a failed submission, since the retry loop
    is going to try again anyway.

Concurrency note: TxManager's stub references are reassigned without a
lock. This is safe under the current design because submit_transaction
is sequential per TxManager instance (no parallel _attempt_submissions
loops on the same manager). If that invariant ever changes, the stub
swap will need to move under a lock or be made copy-on-write.

Stub reference caveat: callers that captured a direct Stub reference
BEFORE a reconnect (e.g. `my_stub = client.tx_manager.tx_client` then
later `await my_stub.broadcast_tx(...)`) will still hit the dead
channel. New invocations through self.tx / self.bank / etc. always hit
the latest channel because the Client* wrappers reference TxManager /
query_client by attribute, and we mutate those in place. Documented
in the _reconnect_grpc docstring.

Tests added (3 new):
  - _on_transport_failure invokes the configured callback exactly once
  - _on_transport_failure is a clean no-op when no callback is configured
  - _on_transport_failure swallows callback failures (does not propagate
    a reconnect-failed exception to the retry loop)

All 16 unit tests pass.

…_status

Two related changes:

1. Promote retry-attempt logs from debug to warning.

   The retry loop in _attempt_submissions logs at debug when retrying
   on OutOfGasError, InsufficientFeesError, AccountSequenceMismatchError,
   and TxTimeoutError. At debug, these were effectively invisible in
   production — alerting systems and operators couldn't see when a
   transaction was struggling and retrying. They could only see the
   final outcome (success or final error).

   Warning is the right level: we are not yet at error (there are
   retries remaining and they may succeed) but we are also not in the
   happy path. This mirrors the Go-side fix where the per-retry log
   in QueryDataWithRetry went info → warning.

   The final-attempt logs (already at error level) remain unchanged.
   The GRPCTransportError retry path added in the previous commit
   already logs at warning, so this brings the rest of the retry
   branches into consistency.

2. Surface grpclib.Status name in simulation error logs.

   When grpclib raises GRPCError, the .status field carries the
   semantic class of the failure (NOT_FOUND, UNAVAILABLE, INVALID_ARGUMENT,
   PERMISSION_DENIED, etc.). Including the status name as a structured-ish
   field (grpc_status=<name>) lets dashboards group failures by class
   without having to substring-match against the freeform error message.

   Mirrors what the Go-side fix does with HTTP status codes in
   triageHTTPStatusError — same intent (make the failure self-describing
   so alerting rules don't have to be clever).

All 16 unit tests still pass.

The earlier prep commit (`fix(deps): remove invalid 'requests *' PEP 508
specifier`) edited pyproject.toml but didn't refresh uv.lock. CI on PR #66
runs `uv sync --locked` which refused with:

  The lockfile at `uv.lock` needs to be updated, but --locked was provided.
  To update the lockfile, run `uv lock`.

This commit is the result of running `uv lock` against the updated
pyproject.toml — a single-line removal of the duplicate `requests`
entry from uv.lock's requires-dist section. No behavioral change.

Caught by self-review of PR #66 — would have failed CI on every push
otherwise.