fix(sdk): preserve legacy proof compatibility on v5.0

Restore the legacy nested nonunique identity proof response while preserving
current server output and all verifier security, signature and freshness gates.
Backport only the identity-discovery feature commits onto v5.0-dev, adapting
fixture signing to its existing BLS API and regenerating latest fixtures at PV14.

Separate signed producer query layout from retained verifier rules for state
transition outcomes. A genuine PV13 document outcome verifies under a retained
PV14 verifier without an invented owner balance; PV14 still requires its balance.
Keep existing Drive callers and all shipped protocol generations unchanged.

Validate current Drive ABCI response codecs, signed proof adversarial cases,
SDK version policy, read-only mainnet/testnet discovery and pinned client output.
Scoped CI clippy, verify-only Drive clippy, rustfmt and wire tests pass.

Original commits: bb5b1ec, 6f40494.

<sub>🤖 Co-authored by [Claudius the Magnificent](https://github.com/lklimek/claudius) AI Agent</sub>

Co-Authored-By: Codex GPT-6 <noreply@openai.com>

Author: lklimek

book/src/sdk/identity-keys.md

@@ -444,7 +444,7 @@ let identity_ids = drive.fetch_identity_ids_by_non_unique_public_key_hash(
 
 `getIdentityByNonUniquePublicKeyHash` returns the first matching identity in
 lexicographic identity-ID byte order. `start_after` is exclusive; use the returned
-ID to fetch the next match. A proved response contains one standard `Proof`
+ID to fetch the next match. Current nodes return one standard `Proof`
 (result field 4). It proves the complete index prefix through that identity and
 all its keys, balance and revision at the same signed root. An absent hash or
 exhausted cursor proves the entire remaining range is empty. A missing identity
@@ -457,12 +457,17 @@ versions require an SDK update and fail closed. The Rust SDK still returns
 shape. The direct WASM verifier takes one proof blob and returns a root that the
 caller must authenticate independently.
 
-The nested double-proof response (retired field 2) has been removed with no
-fallback. Stable v4.1.1 clients and nodes use that old format and are incompatible
-with this proved endpoint during a mixed rollout. Update clients and nodes
-together; mismatched or unsupported-future-version responses can trigger the
-existing SDK retry and node-ban behavior. Unproved response field 1 and the
-request fields remain unchanged.
+The SDK also accepts the legacy nested response at field 2. It strictly verifies
+its first-after index proof and complete identity proof, requires equal roots,
+and authenticates that root with the trusted quorum key and signed metadata.
+Only proved index absence permits an omitted identity proof. Both formats require
+GroveDB V1 or newer; failed current-format proofs are never retried as legacy.
+The response field selects the format, independently of protocol version: current
+proofs can also be produced at protocol 13. Freshness checks and authenticated
+version learning apply after successful verification. Existing nodes continue
+emitting field 4; unproved response field 1 and request fields are unchanged.
+For a legacy response, `fetch_with_metadata_and_proof` returns the signed index
+`Proof`; independent replay of the full verification needs both original blobs.
 
 **Fetch all keys for an identity:**
 ```rust

book/src/sdk/put-operations.md

@@ -243,6 +243,13 @@ for a proof made at an earlier version or a transition without an owner);
 `put_to_platform_and_wait_for_response_with_owner_balance` return it next to
 the document. The balance is a snapshot at the proof's block: it may already
 include later transitions of the same identity.
+
+The signed producer version selects the execution-proof query layout. A client
+retaining protocol 14 verifier rules can therefore authenticate a protocol 13
+outcome without inventing a balance. A protocol 14 outcome must still prove the
+balance; verification never retries a malformed current proof as an older layout.
+Signature and freshness checks run before the SDK learns the producer version.
+
 `put_to_platform_and_wait_for_response_with_owner_balance_and_metadata` also
 returns the verified response metadata, whose `height` is that block, so a
 wallet keeping the balance can order it against balances it read elsewhere; it

packages/dapi-grpc/clients/drive/v0/nodejs/drive_pbjs.js

@@ -6972,6 +6972,11 @@ export namespace GetIdentityByNonUniquePublicKeyHashResponse {
     getIdentity(): GetIdentityByNonUniquePublicKeyHashResponse.GetIdentityByNonUniquePublicKeyHashResponseV0.IdentityResponse | undefined;
     setIdentity(value?: GetIdentityByNonUniquePublicKeyHashResponse.GetIdentityByNonUniquePublicKeyHashResponseV0.IdentityResponse): void;
 
+    hasLegacyProof(): boolean;
+    clearLegacyProof(): void;
+    getLegacyProof(): GetIdentityByNonUniquePublicKeyHashResponse.GetIdentityByNonUniquePublicKeyHashResponseV0.IdentityProvedResponse | undefined;
+    setLegacyProof(value?: GetIdentityByNonUniquePublicKeyHashResponse.GetIdentityByNonUniquePublicKeyHashResponseV0.IdentityProvedResponse): void;
+
     hasProof(): boolean;
     clearProof(): void;
     getProof(): Proof | undefined;
@@ -6996,6 +7001,7 @@ export namespace GetIdentityByNonUniquePublicKeyHashResponse {
   export namespace GetIdentityByNonUniquePublicKeyHashResponseV0 {
     export type AsObject = {
       identity?: GetIdentityByNonUniquePublicKeyHashResponse.GetIdentityByNonUniquePublicKeyHashResponseV0.IdentityResponse.AsObject,
+      legacyProof?: GetIdentityByNonUniquePublicKeyHashResponse.GetIdentityByNonUniquePublicKeyHashResponseV0.IdentityProvedResponse.AsObject,
       proof?: Proof.AsObject,
       metadata?: ResponseMetadata.AsObject,
     }
@@ -7024,9 +7030,40 @@ export namespace GetIdentityByNonUniquePublicKeyHashResponse {
       }
     }
 
+    export class IdentityProvedResponse extends jspb.Message {
+      hasGrovedbIdentityPublicKeyHashProof(): boolean;
+      clearGrovedbIdentityPublicKeyHashProof(): void;
+      getGrovedbIdentityPublicKeyHashProof(): Proof | undefined;
+      setGrovedbIdentityPublicKeyHashProof(value?: Proof): void;
+
+      hasIdentityProofBytes(): boolean;
+      clearIdentityProofBytes(): void;
+      getIdentityProofBytes(): Uint8Array | string;
+      getIdentityProofBytes_asU8(): Uint8Array;
+      getIdentityProofBytes_asB64(): string;
+      setIdentityProofBytes(value: Uint8Array | string): void;
+
+      serializeBinary(): Uint8Array;
+      toObject(includeInstance?: boolean): IdentityProvedResponse.AsObject;
+      static toObject(includeInstance: boolean, msg: IdentityProvedResponse): IdentityProvedResponse.AsObject;
+      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+      static serializeBinaryToWriter(message: IdentityProvedResponse, writer: jspb.BinaryWriter): void;
+      static deserializeBinary(bytes: Uint8Array): IdentityProvedResponse;
+      static deserializeBinaryFromReader(message: IdentityProvedResponse, reader: jspb.BinaryReader): IdentityProvedResponse;
+    }
+
+    export namespace IdentityProvedResponse {
+      export type AsObject = {
+        grovedbIdentityPublicKeyHashProof?: Proof.AsObject,
+        identityProofBytes: Uint8Array | string,
+      }
+    }
+
     export enum ResultCase {
       RESULT_NOT_SET = 0,
       IDENTITY = 1,
+      LEGACY_PROOF = 2,
       PROOF = 4,
     }
   }