Merge upstream develop

Author: github-actions[bot]

apps/polycentric/src/features/verifications/hooks/useCreateClaim.ts

@@ -26,11 +26,9 @@ export default function useCreateClaim() {
     submit: async ({
       schema,
       values,
-      targetIdentities = [],
     }: {
       schema: v2.VerificationSchema;
       values: Record<string, string>;
-      targetIdentities?: string[];
     }): Promise<ClaimRef | undefined> => {
       if (isPending) {
         throw 'Already pending';
@@ -52,7 +50,6 @@ export default function useCreateClaim() {
             verificationClaim: {
               schema: serializeSchema(schema),
               fields,
-              targetIdentities,
             },
           },
         });

packages/js-core/src/proto/polycentric/v2/content.ts

@@ -13,6 +13,7 @@ import { reflectionMergePartial } from "@protobuf-ts/runtime";
 import { MessageType } from "@protobuf-ts/runtime";
 import { ContentDigest } from "./common";
 import { EventKey } from "./event_key";
+import { VerificationTarget } from "./verifications";
 import { VerificationVerify } from "./verifications";
 import { VerificationClaim } from "./verifications";
 import { Identity } from "./identity";
@@ -99,6 +100,12 @@ export interface Content {
          * @generated from protobuf field: polycentric.v2.VerificationVerify verification_verify = 13
          */
         verificationVerify: VerificationVerify;
+    } | {
+        oneofKind: "verificationTarget";
+        /**
+         * @generated from protobuf field: polycentric.v2.VerificationTarget verification_target = 14
+         */
+        verificationTarget: VerificationTarget;
     } | {
         oneofKind: undefined;
     };
@@ -500,7 +507,8 @@ class Content$Type extends MessageType<Content> {
             { no: 10, name: "report", kind: "message", oneof: "contentBody", T: () => Report },
             { no: 11, name: "labels", kind: "message", oneof: "contentBody", T: () => Labels },
             { no: 12, name: "verification_claim", kind: "message", oneof: "contentBody", T: () => VerificationClaim },
-            { no: 13, name: "verification_verify", kind: "message", oneof: "contentBody", T: () => VerificationVerify }
+            { no: 13, name: "verification_verify", kind: "message", oneof: "contentBody", T: () => VerificationVerify },
+            { no: 14, name: "verification_target", kind: "message", oneof: "contentBody", T: () => VerificationTarget }
         ]);
     }
     create(value?: PartialMessage<Content>): Content {
@@ -587,6 +595,12 @@ class Content$Type extends MessageType<Content> {
                         verificationVerify: VerificationVerify.internalBinaryRead(reader, reader.uint32(), options, (message.contentBody as any).verificationVerify)
                     };
                     break;
+                case /* polycentric.v2.VerificationTarget verification_target */ 14:
+                    message.contentBody = {
+                        oneofKind: "verificationTarget",
+                        verificationTarget: VerificationTarget.internalBinaryRead(reader, reader.uint32(), options, (message.contentBody as any).verificationTarget)
+                    };
+                    break;
                 default:
                     let u = options.readUnknownField;
                     if (u === "throw")
@@ -635,6 +649,9 @@ class Content$Type extends MessageType<Content> {
         /* polycentric.v2.VerificationVerify verification_verify = 13; */
         if (message.contentBody.oneofKind === "verificationVerify")
             VerificationVerify.internalBinaryWrite(message.contentBody.verificationVerify, writer.tag(13, WireType.LengthDelimited).fork(), options).join();
+        /* polycentric.v2.VerificationTarget verification_target = 14; */
+        if (message.contentBody.oneofKind === "verificationTarget")
+            VerificationTarget.internalBinaryWrite(message.contentBody.verificationTarget, writer.tag(14, WireType.LengthDelimited).fork(), options).join();
         let u = options.writeUnknownFields;
         if (u !== false)
             (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);

packages/js-core/src/proto/polycentric/v2/verifications.ts

@@ -115,10 +115,24 @@ export interface VerificationClaim {
     fields: {
         [key: string]: Uint8Array;
     };
+}
+/**
+ * Targets a claim at one or more identities. Separate from the claim so
+ * targeting can be set (or changed) after the claim is created.
+ *
+ * @generated from protobuf message polycentric.v2.VerificationTarget
+ */
+export interface VerificationTarget {
+    /**
+     * The claim event being targeted.
+     *
+     * @generated from protobuf field: polycentric.v2.EventKey claim_event_key = 1
+     */
+    claimEventKey?: EventKey;
     /**
-     * Identities this claim is intended for
+     * Identities the claim is intended for.
      *
-     * @generated from protobuf field: repeated string target_identities = 3
+     * @generated from protobuf field: repeated string target_identities = 2
      */
     targetIdentities: string[];
 }
@@ -379,14 +393,12 @@ class VerificationClaim$Type extends MessageType<VerificationClaim> {
     constructor() {
         super("polycentric.v2.VerificationClaim", [
             { no: 1, name: "schema", kind: "message", T: () => SerializedVerificationSchema },
-            { no: 2, name: "fields", kind: "map", K: 9 /*ScalarType.STRING*/, V: { kind: "scalar", T: 12 /*ScalarType.BYTES*/ } },
-            { no: 3, name: "target_identities", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ }
+            { no: 2, name: "fields", kind: "map", K: 9 /*ScalarType.STRING*/, V: { kind: "scalar", T: 12 /*ScalarType.BYTES*/ } }
         ]);
     }
     create(value?: PartialMessage<VerificationClaim>): VerificationClaim {
         const message = globalThis.Object.create((this.messagePrototype!));
         message.fields = {};
-        message.targetIdentities = [];
         if (value !== undefined)
             reflectionMergePartial<VerificationClaim>(this, message, value);
         return message;
@@ -402,9 +414,6 @@ class VerificationClaim$Type extends MessageType<VerificationClaim> {
                 case /* map<string, bytes> fields */ 2:
                     this.binaryReadMap2(message.fields, reader, options);
                     break;
-                case /* repeated string target_identities */ 3:
-                    message.targetIdentities.push(reader.string());
-                    break;
                 default:
                     let u = options.readUnknownField;
                     if (u === "throw")
@@ -439,9 +448,6 @@ class VerificationClaim$Type extends MessageType<VerificationClaim> {
         /* map<string, bytes> fields = 2; */
         for (let k of globalThis.Object.keys(message.fields))
             writer.tag(2, WireType.LengthDelimited).fork().tag(1, WireType.LengthDelimited).string(k).tag(2, WireType.LengthDelimited).bytes(message.fields[k]).join();
-        /* repeated string target_identities = 3; */
-        for (let i = 0; i < message.targetIdentities.length; i++)
-            writer.tag(3, WireType.LengthDelimited).string(message.targetIdentities[i]);
         let u = options.writeUnknownFields;
         if (u !== false)
             (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -453,6 +459,60 @@ class VerificationClaim$Type extends MessageType<VerificationClaim> {
  */
 export const VerificationClaim = new VerificationClaim$Type();
 // @generated message type with reflection information, may provide speed optimized methods
+class VerificationTarget$Type extends MessageType<VerificationTarget> {
+    constructor() {
+        super("polycentric.v2.VerificationTarget", [
+            { no: 1, name: "claim_event_key", kind: "message", T: () => EventKey },
+            { no: 2, name: "target_identities", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<VerificationTarget>): VerificationTarget {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.targetIdentities = [];
+        if (value !== undefined)
+            reflectionMergePartial<VerificationTarget>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: VerificationTarget): VerificationTarget {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* polycentric.v2.EventKey claim_event_key */ 1:
+                    message.claimEventKey = EventKey.internalBinaryRead(reader, reader.uint32(), options, message.claimEventKey);
+                    break;
+                case /* repeated string target_identities */ 2:
+                    message.targetIdentities.push(reader.string());
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: VerificationTarget, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* polycentric.v2.EventKey claim_event_key = 1; */
+        if (message.claimEventKey)
+            EventKey.internalBinaryWrite(message.claimEventKey, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* repeated string target_identities = 2; */
+        for (let i = 0; i < message.targetIdentities.length; i++)
+            writer.tag(2, WireType.LengthDelimited).string(message.targetIdentities[i]);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message polycentric.v2.VerificationTarget
+ */
+export const VerificationTarget = new VerificationTarget$Type();
+// @generated message type with reflection information, may provide speed optimized methods
 class VerificationVerify$Type extends MessageType<VerificationVerify> {
     constructor() {
         super("polycentric.v2.VerificationVerify", [

packages/js-core/src/proto/polycentric/v2/verifications_service.client.ts

@@ -14,8 +14,6 @@ import type { RpcOptions } from "@protobuf-ts/runtime-rpc";
  */
 export interface IVerificationsServiceClient {
     /**
-     * List the verification claims created by an identity.
-     *
      * @generated from protobuf rpc: ListClaims
      */
     listClaims(input: ListClaimsRequest, options?: RpcOptions): UnaryCall<ListClaimsRequest, ListClaimsResponse>;
@@ -30,8 +28,6 @@ export class VerificationsServiceClient implements IVerificationsServiceClient,
     constructor(private readonly _transport: RpcTransport) {
     }
     /**
-     * List the verification claims created by an identity.
-     *
      * @generated from protobuf rpc: ListClaims
      */
     listClaims(input: ListClaimsRequest, options?: RpcOptions): UnaryCall<ListClaimsRequest, ListClaimsResponse> {

packages/js-core/src/proto/polycentric/v2/verifications_service.ts

@@ -12,19 +12,14 @@ import type { PartialMessage } from "@protobuf-ts/runtime";
 import { reflectionMergePartial } from "@protobuf-ts/runtime";
 import { MessageType } from "@protobuf-ts/runtime";
 import { EventBundle } from "./events";
-// RPC surface for verification claims. Kept separate from
-// verifications.proto because the response references EventBundle
-// (events.proto), and events.proto -> content.proto -> verifications.proto
-// already form a chain; importing events.proto from verifications.proto
-// would create a cyclic import.
+// Separate from verifications.proto: that file is imported by content.proto,
+// so importing events.proto (for EventBundle) there would be a cyclic import.
 
 /**
  * @generated from protobuf message polycentric.v2.ListClaimsRequest
  */
 export interface ListClaimsRequest {
     /**
-     * Identity whose verification claims to list.
-     *
      * @generated from protobuf field: string claimed_by_identity = 1
      */
     claimedByIdentity: string;
@@ -34,8 +29,6 @@ export interface ListClaimsRequest {
  */
 export interface ListClaimsResponse {
     /**
-     * Claim events created by the identity, newest first.
-     *
      * @generated from protobuf field: repeated polycentric.v2.EventBundle event_bundles = 1
      */
     eventBundles: EventBundle[];

packages/react-native/src/generated/rn/polycentric_core.ts

@@ -3005,9 +3005,8 @@ export interface PolycentricCoreLike {
    */
   getServers(): Array<string>;
   /**
-   * Clear the per-server cache for `query_key`, notify live
-   * subscribers with `Loading(None)`, then trigger a fresh fan-out.
-   * No-op when the key has never been queried.
+   * Clear the cache for a query key and discard the responses for any
+   * in-flight merge queries.
    */
   invalidateQuery(queryKey: Array<string>): void;
   /**
@@ -3512,9 +3511,8 @@ export class PolycentricCore
   }
 
   /**
-   * Clear the per-server cache for `query_key`, notify live
-   * subscribers with `Loading(None)`, then trigger a fresh fan-out.
-   * No-op when the key has never been queried.
+   * Clear the cache for a query key and discard the responses for any
+   * in-flight merge queries.
    */
   invalidateQuery(queryKey: Array<string>): void {
     uniffiCaller.rustCall(
@@ -4469,7 +4467,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_polycentric_core_checksum_method_polycentriccore_invalidate_query() !==
-    34463
+    44746
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       'uniffi_polycentric_core_checksum_method_polycentriccore_invalidate_query'

packages/rs-core/src/query/claims.rs

@@ -15,9 +15,7 @@ pub struct ListClaimsArgs {
     pub claimed_by_identity: String,
 }
 
-/// Merge `ListClaimsResponse` payloads from every server: concatenate
-/// the bundles, dedupe by `EventKey`, then drop any that fail signature
-/// / proof validation against the local client state.
+/// Concatenate per-server bundles, dedupe by `EventKey`, drop invalid ones.
 fn merge_list_claims_responses(
     values: &[Vec<u8>],
     client: &std::sync::Arc<std::sync::Mutex<crate::client::PolycentricClient>>,
@@ -44,9 +42,8 @@ fn merge_list_claims_responses(
     merged.encode_to_vec()
 }
 
-/// List the verification claims created by `claimed_by_identity` across
-/// the configured servers. Emits serialized `ListClaimsResponse` proto
-/// bytes with `event_bundles` deduped by `EventKey` and validated.
+/// List an identity's verification claims across servers. Emits serialized
+/// `ListClaimsResponse` bytes.
 pub fn list_claims(
     query_client: &QueryClient<Vec<u8>>,
     query_key: Option<QueryKey>,

protos/polycentric/v2/content.proto

@@ -22,6 +22,7 @@ message Content {
     // Verifications (see verifications.proto)
     VerificationClaim verification_claim = 12;
     VerificationVerify verification_verify = 13;
+    VerificationTarget verification_target = 14;
   }
 }
 

protos/polycentric/v2/verifications.proto

@@ -54,8 +54,15 @@ message VerificationClaim {
   SerializedVerificationSchema schema = 1;
   // Values keyed by FieldDef.key, decoded per the schema's FieldKind.
   map<string, bytes> fields = 2;
-  // Identities this claim is intended for
-  repeated string target_identities = 3;
+}
+
+// Targets a claim at one or more identities. Separate from the claim so
+// targeting can be set (or changed) after the claim is created.
+message VerificationTarget {
+  // The claim event being targeted.
+  EventKey claim_event_key = 1;
+  // Identities the claim is intended for.
+  repeated string target_identities = 2;
 }
 
 // ── A verifier's attestation ──

protos/polycentric/v2/verifications_service.proto

@@ -3,23 +3,17 @@ package polycentric.v2;
 
 import "polycentric/v2/events.proto";
 
-// RPC surface for verification claims. Kept separate from
-// verifications.proto because the response references EventBundle
-// (events.proto), and events.proto -> content.proto -> verifications.proto
-// already form a chain; importing events.proto from verifications.proto
-// would create a cyclic import.
+// Separate from verifications.proto: that file is imported by content.proto,
+// so importing events.proto (for EventBundle) there would be a cyclic import.
 
 message ListClaimsRequest {
-  // Identity whose verification claims to list.
   string claimed_by_identity = 1;
 }
 
 message ListClaimsResponse {
-  // Claim events created by the identity, newest first.
   repeated EventBundle event_bundles = 1;
 }
 
 service VerificationsService {
-  // List the verification claims created by an identity.
   rpc ListClaims(ListClaimsRequest) returns (ListClaimsResponse);
 }