Merge upstream develop

Author: github-actions[bot]

.gitlab-ci.yml

@@ -1,16 +1,16 @@
 include:
-  - local: .gitlab/ci/build_rs_core.yml
-  - local: .gitlab/ci/build_js_sdks.yml
-  - local: .gitlab/ci/build_server.yml
-  - local: .gitlab/ci/deploy_pages.yml
-
+- local: ".gitlab/ci/build_rs_core.yml"
+- local: ".gitlab/ci/build_js_sdks.yml"
+- local: ".gitlab/ci/build_server.yml"
+- local: ".gitlab/ci/deploy_pages.yml"
+- local: ".gitlab/ci/scan_dependencies.yml"
 stages:
-  - setup
-  - check
-  - build
-  - publish
-  - deploy
-
+- setup
+- check
+- build
+- publish
+- deploy
+- test
 default:
   tags:
-    - dind
+  - dind

.gitlab/ci/scan_dependencies.yml

@@ -0,0 +1,22 @@
+trivy:
+  stage: test
+  image:
+    name: aquasec/trivy:0.69.3
+    entrypoint: [""]
+  variables:
+    TRIVY_NO_PROGRESS: "true"
+    TRIVY_CACHE_DIR: ".trivycache/"
+  allow_failure: true
+  script:
+    # Gitlab code quality report output
+    - trivy filesystem --scanners misconfig,vuln --exit-code 0 --severity CRITICAL --format template --template "@/contrib/gitlab-codequality.tpl" -o gl-codeclimate.json .
+    # Console output
+    - trivy filesystem --scanners misconfig,vuln --exit-code 1 --severity CRITICAL .
+  cache:
+    paths:
+      - .trivycache/
+  artifacts:
+    paths:
+      - gl-codeclimate.json
+    reports:
+      codequality: gl-codeclimate.json

apps/polycentric/src/features/composer/ComposeSheetInner.tsx

@@ -94,7 +94,7 @@ export function ComposeSheetInner({
 
       const event = await client.buildEvent(content);
 
-      event.vectorClocks = await client.buildVectorClock(event);
+      console.log(event);
 
       const signedEvent = await client.signEvent(event);
 

packages/js-browser/examples/react/src/components/posts/post-compose.tsx

@@ -27,7 +27,7 @@ export const PostCompose = () => {
     const event = await client.buildEvent(content);
 
     const signedEvent = await client.signEvent(event);
-    await client.commitEvent(signedEvent);
+    await client.commitEvent(signedEvent, content);
 
     postField.current.value = '';
   };

packages/js-browser/src/storage/indexeddb/content.repository.ts

@@ -76,4 +76,35 @@ export class IndexedDBContentRepository implements IContentRepository {
       throw new DatabaseError('Failed to get content: ', error);
     }
   }
+
+  async getAll(): Promise<
+    { digest: Proto.ContentDigest; content: Proto.Content }[]
+  > {
+    try {
+      const transaction = this.database.createTransaction(
+        IndexedDBContentRepository.STORE_NAME,
+        'readonly',
+      );
+      const store = transaction.objectStore(
+        IndexedDBContentRepository.STORE_NAME,
+      );
+
+      const rows = await IndexedDBDatabase.requestAsPromise<
+        { digestHex: string; contentBytes: Uint8Array }[]
+      >(store.getAll());
+
+      return rows.map((row) => {
+        // digestHex encodes the full serialized ContentDigest proto.
+        const digestBytes = new Uint8Array(
+          row.digestHex.match(/.{1,2}/g)!.map((b) => parseInt(b, 16)),
+        );
+        return {
+          digest: Proto.ContentDigest.fromBinary(digestBytes),
+          content: Proto.Content.fromBinary(row.contentBytes),
+        };
+      });
+    } catch (error) {
+      throw new DatabaseError('Failed to get all content: ', error);
+    }
+  }
 }

packages/js-browser/src/storage/indexeddb/event.repository.ts

@@ -132,83 +132,26 @@ export class IndexedDBEventRepository implements IEventRepository {
     }
   }
 
-  async getNextSequence(
-    publicKey: Proto.PublicKey,
-    collection: number,
-    identity: string,
-  ): Promise<bigint> {
+  async getByEventKey(key: Proto.EventKey): Promise<Proto.SignedEvent | null> {
+    if (!key.signedBy) return null;
     try {
-      const pubKeyHex = bytesToHex(Proto.PublicKey.toBinary(publicKey));
-      console.log(pubKeyHex);
-
       const transaction = this.database.createTransaction(
         IndexedDBEventRepository.STORE_NAME,
         'readonly',
       );
       const store = transaction.objectStore(
         IndexedDBEventRepository.STORE_NAME,
       );
-
-      const results = await IndexedDBDatabase.requestAsPromise<
-        PersistedEvent[]
-      >(store.getAll());
-
-      let maxSeq = 0n;
-      for (const row of results) {
-        if (
-          row.publicKey === pubKeyHex &&
-          row.collection === collection &&
-          row.identity === identity
-        ) {
-          const seq = BigInt(row.sequence);
-          if (seq > maxSeq) maxSeq = seq;
-        }
-      }
-
-      return maxSeq + 1n;
+      const pkHex = bytesToHex(Proto.PublicKey.toBinary(key.signedBy));
+      const result = await IndexedDBDatabase.requestAsPromise<
+        PersistedEvent | undefined
+      >(store.get([key.identity, pkHex, key.collection, Number(key.sequence)]));
+      return result ? this.toSignedEvent(result) : null;
     } catch (error) {
-      throw new DatabaseError('Failed to get next sequence: ', error);
+      throw new DatabaseError('Failed to get event by key: ', error);
     }
   }
 
-  async getEventsByIdentity(
-    publicKey: Proto.PublicKey,
-    identity: string,
-  ): Promise<Proto.SignedEvent[]> {
-    try {
-      const pubKeyHex = bytesToHex(Proto.PublicKey.toBinary(publicKey));
-
-      const transaction = this.database.createTransaction(
-        IndexedDBEventRepository.STORE_NAME,
-        'readonly',
-      );
-      const store = transaction.objectStore(
-        IndexedDBEventRepository.STORE_NAME,
-      );
-
-      const results = await IndexedDBDatabase.requestAsPromise<
-        PersistedEvent[]
-      >(store.getAll());
-
-      return results
-        .filter(
-          (row) => row.publicKey === pubKeyHex && row.identity === identity,
-        )
-        .sort((a, b) => a.sequence - b.sequence)
-        .map((row) => this.toSignedEvent(row));
-    } catch (error) {
-      throw new DatabaseError('Failed to get events by identity: ', error);
-    }
-  }
-
-  async getLatestEvent(
-    publicKey: Proto.PublicKey,
-    identity: string,
-  ): Promise<Proto.SignedEvent | null> {
-    const events = await this.getEventsByIdentity(publicKey, identity);
-    return events.length > 0 ? events[events.length - 1] : null;
-  }
-
   async getBatch(
     batchSize: number,
     offset?: number,
@@ -222,7 +165,14 @@ export class IndexedDBEventRepository implements IEventRepository {
     return { events, offset: start + events.length };
   }
 
-  async getHeadsByIdentity(identity: string): Promise<Proto.SignedEvent[]> {
+  async getByIdentity(
+    identity: string,
+    options?: {
+      signer?: Proto.PublicKey;
+      collection?: number;
+      headsOnly?: boolean;
+    },
+  ): Promise<Proto.SignedEvent[]> {
     try {
       const transaction = this.database.createTransaction(
         IndexedDBEventRepository.STORE_NAME,
@@ -233,34 +183,48 @@ export class IndexedDBEventRepository implements IEventRepository {
       );
 
       // Compound keyPath: [identity, publicKey, collection, sequence].
-      // Reverse cursor hits the max-sequence entry for each
-      // (publicKey, collection) group first. After reading a head,
-      // skip the rest of the group by continuing to
-      // [identity, publicKey, collection] (without sequence) — this
-      // compares less than any key with a sequence component, so the
-      // reverse cursor jumps to the previous group's max.
-      const range = IDBKeyRange.bound([identity], [identity, '\uffff']);
-      const heads: PersistedEvent[] = [];
+      // Build the longest prefix of fixed components so the cursor scans
+      // only matching rows.
+      const prefix: (string | number)[] = [identity];
+      if (options?.signer) {
+        prefix.push(bytesToHex(Proto.PublicKey.toBinary(options.signer)));
+        if (options.collection !== undefined) prefix.push(options.collection);
+      }
+      const range = IDBKeyRange.bound(prefix, [...prefix, []]);
+      const headsOnly = options?.headsOnly ?? false;
+      const collectionFilter = options?.collection;
+
+      // headsOnly: walk in reverse; first hit per (signer, collection) is
+      // its max-sequence entry, then skip the rest of the group.
+      // Otherwise: walk forward and collect everything matching.
+      const direction: IDBCursorDirection = headsOnly ? 'prev' : 'next';
+      const rows: PersistedEvent[] = [];
 
       await new Promise<void>((resolve, reject) => {
-        const request = store.openCursor(range, 'prev');
+        const request = store.openCursor(range, direction);
         request.onerror = () => reject(request.error);
         request.onsuccess = () => {
           const cursor = request.result;
-          if (!cursor) {
-            resolve();
-            return;
-          }
+          if (!cursor) return resolve();
           const row = cursor.value as PersistedEvent;
-          heads.push(row);
-          // Skip to the previous group's max entry.
-          cursor.continue([identity, row.publicKey, row.collection]);
+          if (
+            collectionFilter === undefined ||
+            row.collection === collectionFilter
+          ) {
+            rows.push(row);
+          }
+          if (headsOnly) {
+            // Skip the rest of this (signer, collection) group.
+            cursor.continue([identity, row.publicKey, row.collection]);
+          } else {
+            cursor.continue();
+          }
         };
       });
 
-      return heads.map((row) => this.toSignedEvent(row));
+      return rows.map((row) => this.toSignedEvent(row));
     } catch (error) {
-      throw new DatabaseError('Failed to get heads by identity: ', error);
+      throw new DatabaseError('Failed to get events by identity: ', error);
     }
   }
 }

packages/js-core/src/client-internal/identity-manager.ts

@@ -89,10 +89,10 @@ export class IdentityManager {
 
     const digest = this.client.contentManager.buildDigest(content);
 
-    const sequence = await this.client.storage.events.getNextSequence(
-      this.client.currentKeyPair.publicKey,
-      COLLECTION.IDENTITY,
+    const sequence = this.client.core!.next_sequence(
       identityKey,
+      COLLECTION.IDENTITY,
+      Proto.PublicKey.toBinary(this.client.currentKeyPair.publicKey),
     );
 
     const event = Proto.Event.create({
@@ -109,7 +109,7 @@ export class IdentityManager {
 
     await this.client.storage.content.save(digest, content);
     const signedEvent = await this.client.signEvent(event);
-    await this.client.commitEvent(signedEvent);
+    await this.client.commitEvent(signedEvent, content);
 
     this.client.setActiveIdentityKey(identityKey);
 

packages/js-core/src/platform-interfaces/content.repository.ts

@@ -19,4 +19,10 @@ export interface IContentRepository {
    * @returns The content bytes, or null if not found
    */
   get(digest: Proto.ContentDigest): Promise<Proto.Content | null>;
+
+  /**
+   * Return every stored (digest, content) pair. Used to hydrate the
+   * in-memory Rust content store at startup.
+   */
+  getAll(): Promise<{ digest: Proto.ContentDigest; content: Proto.Content }[]>;
 }

packages/js-core/src/platform-interfaces/event.repository.ts

@@ -19,50 +19,29 @@ export interface IEventRepository {
   }>;
 
   /**
-   * Get the next sequence number for a given public key, collection, and identity.
-   * Returns max(sequence) + 1 across all stored events matching, or 1n if none exist.
+   * Point lookup by EventKey. Returns null if not present locally.
    *
-   * @param publicKey - The public key bytes of the signer
-   * @param collection - The collection ID
-   * @param identity - The identity key (hex hash)
+   * @param key - The full EventKey (collection, identity, signedBy, sequence)
    */
-  getNextSequence(
-    publicKey: Proto.PublicKey,
-    collection: number,
-    identity: string,
-  ): Promise<bigint>;
+  getByEventKey(key: Proto.EventKey): Promise<Proto.SignedEvent | null>;
 
   /**
-   * Get the event with the highest sequence number for a given public key and identity.
-   * Returns null if no events exist for the key+identity.
+   * Query events for an identity.
    *
-   * @param publicKey - The public key bytes of the signer
-   * @param identity - The identity key (hex hash)
-   */
-  getLatestEvent(
-    publicKey: Proto.PublicKey,
-    identity: string,
-  ): Promise<Proto.SignedEvent | null>;
-
-  /**
-   * Get all events for a given public key and identity, ordered by sequence ascending.
+   * Optional `signer` and `collection` filters narrow the scan. When
+   * `headsOnly` is true, returns one event per (signer, collection) — the
+   * highest-sequence entry for each stream. Otherwise returns all matching
+   * events sorted by sequence ascending.
    *
-   * @param publicKey - The public key bytes of the signer
    * @param identity - The identity key (hex hash)
+   * @param options - Optional filters and head-only flag
    */
-  getEventsByIdentity(
-    publicKey: Proto.PublicKey,
+  getByIdentity(
     identity: string,
+    options?: {
+      signer?: Proto.PublicKey;
+      collection?: number;
+      headsOnly?: boolean;
+    },
   ): Promise<Proto.SignedEvent[]>;
-
-  /**
-   * Get the head (highest-sequence) event for each unique (signer, collection)
-   * pair within a given identity. Useful for building vector clocks without
-   * loading every event.
-   *
-   * @param identity - The identity key (hex hash)
-   * @returns One SignedEvent per (signer, collection), each being the
-   *          highest-sequence event for that stream.
-   */
-  getHeadsByIdentity(identity: string): Promise<Proto.SignedEvent[]>;
 }