cojson 0.19.7 → 0.19.10

package/src/coValueCore/coValueCore.ts

@@ -379,11 +379,6 @@ export class CoValueCore {
 
     this.counter.add(-1, { state: this.loadingState });
 
-    if (this.groupInvalidationSubscription) {
-      this.groupInvalidationSubscription();
-      this.groupInvalidationSubscription = undefined;
-    }
-
     this.node.internalDeleteCoValue(this.id);
 
     return true;
@@ -517,38 +512,6 @@ export class CoValueCore {
     this.scheduleNotifyUpdate();
   }
 
-  groupInvalidationSubscription?: () => void;
-
-  subscribeToGroupInvalidation() {
-    if (!this.verified) {
-      return;
-    }
-
-    if (this.groupInvalidationSubscription) {
-      return;
-    }
-
-    const header = this.verified.header;
-
-    if (header.ruleset.type == "ownedByGroup") {
-      const groupId = header.ruleset.group;
-      const entry = this.node.getCoValue(groupId);
-
-      if (entry.isAvailable()) {
-        this.groupInvalidationSubscription = entry.subscribe((_groupUpdate) => {
-          // When the group is updated, we need to reset the cached content because the transactions validity might have changed
-          this.resetParsedTransactions();
-          this.scheduleNotifyUpdate();
-        }, false);
-      } else {
-        logger.error("CoValueCore: Owner group not available", {
-          id: this.id,
-          groupId,
-        });
-      }
-    }
-  }
-
   contentInClonedNodeWithDifferentAccount(account: ControlledAccountOrAgent) {
     return this.node
       .loadCoValueAsDifferentAgent(this.id, account.agentSecret, account.id)
@@ -656,11 +619,34 @@ export class CoValueCore {
 
       this.processNewTransactions();
       this.scheduleNotifyUpdate();
+      this.invalidateDependants();
     } catch (e) {
       return { type: "InvalidSignature", id: this.id, error: e } as const;
     }
   }
 
+  notifyDependants() {
+    if (!this.isGroup()) {
+      return;
+    }
+
+    for (const dependency of this.dependant) {
+      this.node.getCoValue(dependency).scheduleNotifyUpdate();
+      this.node.getCoValue(dependency).notifyDependants();
+    }
+  }
+
+  invalidateDependants() {
+    if (!this.isGroup()) {
+      return;
+    }
+
+    for (const dependency of this.dependant) {
+      this.node.getCoValue(dependency).resetParsedTransactions();
+      this.node.getCoValue(dependency).invalidateDependants();
+    }
+  }
+
   private processNewTransactions() {
     if (this._cachedContent) {
       this._cachedContent.processNewTransactions();
@@ -807,6 +793,19 @@ export class CoValueCore {
     this.notifyUpdate();
     this.node.syncManager.syncLocalTransaction(this.verified, knownStateBefore);
 
+    if (madeAt === undefined) {
+      // We don't revalidate the dependants transactions because we assume that transactions that you are
+      // creating "now" on groups don't affect the validity of transactions you already have in memory.
+      // For validity I mean:
+      // - ability to decrypt a transaction
+      // - that the account that made the transaction had enough rights to do so
+      this.notifyDependants();
+    } else {
+      // If the transaction is not made "now", we need to revalidate the dependants transactions
+      // because the new transaction might affect the validity of the dependants transactions
+      this.invalidateDependants();
+    }
+
     return true;
   }
 
@@ -833,8 +832,6 @@ export class CoValueCore {
 
     const newContent = coreToCoValue(this as AvailableCoValueCore, options);
 
-    this.subscribeToGroupInvalidation();
-
     if (!options?.ignorePrivateTransactions) {
       this._cachedContent = newContent;
     }
@@ -853,19 +850,41 @@ export class CoValueCore {
 
   // Reset the parsed transactions and branches, to validate them again from scratch when the group is updated
   resetParsedTransactions() {
+    const verifiedTransactions = this.verifiedTransactions;
+
+    if (verifiedTransactions.length === 0) {
+      return;
+    }
+
     this.branchStart = undefined;
     this.mergeCommits = [];
 
-    for (const transaction of this.verifiedTransactions) {
+    // Store the validity of the transactions before resetting the parsed transactions
+    const validityBeforeReset = new Array<boolean>(verifiedTransactions.length);
+    this.verifiedTransactions.forEach((transaction, index) => {
       transaction.isValidated = false;
-    }
+      validityBeforeReset[index] = transaction.isValidTransactionWithChanges();
+    });
 
-    this.toValidateTransactions = this.verifiedTransactions.slice();
+    this.toValidateTransactions = verifiedTransactions.slice();
     this.toProcessTransactions = [];
     this.toDecryptTransactions = [];
     this.toParseMetaTransactions = [];
 
-    this._cachedContent?.rebuildFromCore();
+    this.parseNewTransactions(false);
+
+    // Check if the validity of the transactions has changed after resetting the parsed transactions
+    // If it has, we need to rebuild the content to reflect the new validity
+    const sameAsBefore = validityBeforeReset.every(
+      (valid, index) =>
+        valid === verifiedTransactions[index]?.isValidTransactionWithChanges(),
+    );
+
+    if (!sameAsBefore) {
+      this._cachedContent?.rebuildFromCore();
+    }
+
+    this.scheduleNotifyUpdate();
   }
 
   verifiedTransactions: VerifiedTransaction[] = [];

package/src/crypto/RNCrypto.ts

@@ -0,0 +1,307 @@
+import {
+  JsonValue,
+  RawCoID,
+  SessionID,
+  Stringified,
+  base64URLtoBytes,
+  bytesToBase64url,
+} from "../exports.js";
+import { CojsonInternalTypes } from "../exports.js";
+import { TransactionID } from "../ids.js";
+import { stableStringify } from "../jsonStringify.js";
+import { JsonObject } from "../jsonValue.js";
+import { logger } from "../logger.js";
+import { ControlledAccountOrAgent } from "../coValues/account.js";
+import {
+  PrivateTransaction,
+  Transaction,
+  TrustingTransaction,
+} from "../coValueCore/verifiedState.js";
+import {
+  CryptoProvider,
+  KeyID,
+  KeySecret,
+  Sealed,
+  SealerID,
+  SealerSecret,
+  SessionLogImpl,
+  Signature,
+  SignerID,
+  SignerSecret,
+  textDecoder,
+  textEncoder,
+} from "./crypto.js";
+import {
+  blake3HashOnce,
+  blake3HashOnceWithContext,
+  verify,
+  encrypt,
+  decrypt,
+  newEd25519SigningKey,
+  newX25519PrivateKey,
+  getSealerId,
+  getSignerId,
+  sign,
+  seal,
+  unseal,
+  Blake3Hasher,
+  SessionLog,
+} from "cojson-core-rn";
+
+type Blake3State = Blake3Hasher;
+
+/**
+ *
+ * @param view - The Uint8Array to convert to an ArrayBuffer.
+ * @returns The ArrayBuffer.
+ */
+function toArrayBuffer(view: Uint8Array): ArrayBuffer {
+  if (
+    view.byteOffset === 0 &&
+    view.byteLength === view.buffer.byteLength &&
+    view.buffer instanceof ArrayBuffer
+  ) {
+    return view.buffer;
+  }
+  const buffer = new ArrayBuffer(view.byteLength);
+  new Uint8Array(buffer).set(view);
+  return buffer;
+}
+
+export class RNCrypto extends CryptoProvider<Blake3State> {
+  private constructor() {
+    super();
+  }
+
+  getSignerID(secret: SignerSecret): SignerID {
+    return getSignerId(secret) as SignerID;
+  }
+  newX25519StaticSecret(): Uint8Array {
+    return new Uint8Array(newX25519PrivateKey());
+  }
+  getSealerID(secret: SealerSecret): SealerID {
+    return getSealerId(secret) as SealerID;
+  }
+  blake3HashOnce(data: Uint8Array): Uint8Array {
+    return new Uint8Array(blake3HashOnce(toArrayBuffer(data)));
+  }
+  blake3HashOnceWithContext(
+    data: Uint8Array,
+    { context }: { context: Uint8Array },
+  ): Uint8Array {
+    return new Uint8Array(
+      blake3HashOnceWithContext(toArrayBuffer(data), toArrayBuffer(context)),
+    );
+  }
+  seal<T extends JsonValue>({
+    message,
+    from,
+    to,
+    nOnceMaterial,
+  }: {
+    message: T;
+    from: SealerSecret;
+    to: SealerID;
+    nOnceMaterial: { in: RawCoID; tx: TransactionID };
+  }): Sealed<T> {
+    const messageBuffer = toArrayBuffer(
+      textEncoder.encode(stableStringify(message)),
+    );
+    const nOnceBuffer = toArrayBuffer(
+      textEncoder.encode(stableStringify(nOnceMaterial)),
+    );
+
+    return `sealed_U${bytesToBase64url(
+      new Uint8Array(seal(messageBuffer, from, to, nOnceBuffer)),
+    )}` as Sealed<T>;
+  }
+  unseal<T extends JsonValue>(
+    sealed: Sealed<T>,
+    sealer: SealerSecret,
+    from: SealerID,
+    nOnceMaterial: { in: RawCoID; tx: TransactionID },
+  ): T | undefined {
+    const sealedBytes = base64URLtoBytes(sealed.substring("sealed_U".length));
+    const nonceBuffer = toArrayBuffer(
+      textEncoder.encode(stableStringify(nOnceMaterial)),
+    );
+
+    const plaintext = textDecoder.decode(
+      unseal(toArrayBuffer(sealedBytes), sealer, from, nonceBuffer),
+    );
+    try {
+      return JSON.parse(plaintext) as T;
+    } catch (e) {
+      logger.error("Failed to decrypt/parse sealed message", { err: e });
+      return undefined;
+    }
+  }
+  createSessionLog(
+    coID: RawCoID,
+    sessionID: SessionID,
+    signerID?: SignerID,
+  ): SessionLogImpl {
+    return new SessionLogAdapter(new SessionLog(coID, sessionID, signerID));
+  }
+
+  static async create(): Promise<RNCrypto> {
+    return new RNCrypto();
+  }
+
+  newEd25519SigningKey(): Uint8Array {
+    return new Uint8Array(newEd25519SigningKey());
+  }
+
+  sign(
+    secret: CojsonInternalTypes.SignerSecret,
+    message: JsonValue,
+  ): CojsonInternalTypes.Signature {
+    return sign(
+      toArrayBuffer(textEncoder.encode(stableStringify(message))),
+      secret,
+    ) as CojsonInternalTypes.Signature;
+  }
+
+  verify(
+    signature: CojsonInternalTypes.Signature,
+    message: JsonValue,
+    id: CojsonInternalTypes.SignerID,
+  ): boolean {
+    const result = verify(
+      signature,
+      toArrayBuffer(textEncoder.encode(stableStringify(message))),
+      id,
+    );
+
+    return result;
+  }
+
+  encrypt<T extends JsonValue, N extends JsonValue>(
+    value: T,
+    keySecret: CojsonInternalTypes.KeySecret,
+    nOnceMaterial: N,
+  ): CojsonInternalTypes.Encrypted<T, N> {
+    const valueBytes = toArrayBuffer(
+      textEncoder.encode(stableStringify(value)),
+    );
+    const nOnceBytes = toArrayBuffer(
+      textEncoder.encode(stableStringify(nOnceMaterial)),
+    );
+
+    const encrypted = `encrypted_U${bytesToBase64url(
+      new Uint8Array(encrypt(valueBytes, keySecret, nOnceBytes)),
+    )}` as CojsonInternalTypes.Encrypted<T, N>;
+    return encrypted;
+  }
+
+  decryptRaw<T extends JsonValue, N extends JsonValue>(
+    encrypted: CojsonInternalTypes.Encrypted<T, N>,
+    keySecret: CojsonInternalTypes.KeySecret,
+    nOnceMaterial: N,
+  ): Stringified<T> {
+    const buffer = base64URLtoBytes(encrypted.substring("encrypted_U".length));
+
+    const decrypted = textDecoder.decode(
+      decrypt(
+        toArrayBuffer(buffer),
+        keySecret,
+        toArrayBuffer(textEncoder.encode(stableStringify(nOnceMaterial))),
+      ),
+    ) as Stringified<T>;
+
+    return decrypted;
+  }
+}
+
+class SessionLogAdapter implements SessionLogImpl {
+  constructor(private readonly sessionLog: SessionLog) {}
+
+  tryAdd(
+    transactions: Transaction[],
+    newSignature: Signature,
+    skipVerify: boolean,
+  ): void {
+    this.sessionLog.tryAdd(
+      transactions.map((tx) => stableStringify(tx)),
+      newSignature,
+      skipVerify,
+    );
+  }
+
+  addNewPrivateTransaction(
+    signerAgent: ControlledAccountOrAgent,
+    changes: JsonValue[],
+    keyID: KeyID,
+    keySecret: KeySecret,
+    madeAt: number,
+    meta: JsonObject | undefined,
+  ) {
+    const output = this.sessionLog.addNewPrivateTransaction(
+      stableStringify(changes),
+      signerAgent.currentSignerSecret(),
+      keySecret,
+      keyID,
+      madeAt,
+      meta ? stableStringify(meta) : undefined,
+    );
+    const parsedOutput = JSON.parse(output);
+    const transaction: PrivateTransaction = {
+      privacy: "private",
+      madeAt,
+      encryptedChanges: parsedOutput.encrypted_changes,
+      keyUsed: keyID,
+      meta: parsedOutput.meta,
+    };
+    return { signature: parsedOutput.signature as Signature, transaction };
+  }
+
+  addNewTrustingTransaction(
+    signerAgent: ControlledAccountOrAgent,
+    changes: JsonValue[],
+    madeAt: number,
+    meta: JsonObject | undefined,
+  ) {
+    const stringifiedChanges = stableStringify(changes);
+    const stringifiedMeta = meta ? stableStringify(meta) : undefined;
+    const output = this.sessionLog.addNewTrustingTransaction(
+      stringifiedChanges,
+      signerAgent.currentSignerSecret(),
+      madeAt,
+      stringifiedMeta,
+    );
+    const transaction: TrustingTransaction = {
+      privacy: "trusting",
+      madeAt,
+      changes: stringifiedChanges,
+      meta: stringifiedMeta,
+    };
+    return { signature: output as Signature, transaction };
+  }
+
+  decryptNextTransactionChangesJson(
+    txIndex: number,
+    keySecret: KeySecret,
+  ): string {
+    return this.sessionLog.decryptNextTransactionChangesJson(
+      txIndex,
+      keySecret,
+    );
+  }
+
+  decryptNextTransactionMetaJson(
+    txIndex: number,
+    keySecret: KeySecret,
+  ): string | undefined {
+    return this.sessionLog.decryptNextTransactionMetaJson(txIndex, keySecret);
+  }
+
+  free(): void {
+    this.sessionLog.uniffiDestroy();
+  }
+
+  clone(): SessionLogImpl {
+    return new SessionLogAdapter(
+      this.sessionLog.cloneSessionLog() as SessionLog,
+    );
+  }
+}

package/src/exports.ts

@@ -6,7 +6,10 @@ import {
   enablePermissionErrors,
   type AvailableCoValueCore,
 } from "./coValueCore/coValueCore.js";
-import { CoValueUniqueness } from "./coValueCore/verifiedState.js";
+import {
+  CoValueHeader,
+  CoValueUniqueness,
+} from "./coValueCore/verifiedState.js";
 import {
   ControlledAccount,
   ControlledAgent,
@@ -78,7 +81,9 @@ import { getDependedOnCoValuesFromRawData } from "./coValueCore/utils.js";
 import {
   CO_VALUE_LOADING_CONFIG,
   TRANSACTION_CONFIG,
+  setCoValueLoadingMaxRetries,
   setCoValueLoadingRetryDelay,
+  setCoValueLoadingTimeout,
   setIncomingMessagesTimeBudget,
   setMaxRecommendedTxSize,
 } from "./config.js";
@@ -118,6 +123,8 @@ export const cojsonInternals = {
   CO_VALUE_PRIORITY,
   setIncomingMessagesTimeBudget,
   setCoValueLoadingRetryDelay,
+  setCoValueLoadingMaxRetries,
+  setCoValueLoadingTimeout,
   ConnectedPeerChannel,
   textEncoder,
   textDecoder,
@@ -186,6 +193,7 @@ export type {
   AccountRole,
   AvailableCoValueCore,
   PeerState,
+  CoValueHeader,
 };
 
 export * from "./storage/index.js";

package/src/localNode.ts

@@ -31,7 +31,7 @@ import {
 } from "./coValues/group.js";
 import { CO_VALUE_LOADING_CONFIG } from "./config.js";
 import { AgentSecret, CryptoProvider } from "./crypto/crypto.js";
-import { AgentID, RawCoID, SessionID, isAgentID } from "./ids.js";
+import { AgentID, RawCoID, SessionID, isAgentID, isRawCoID } from "./ids.js";
 import { logger } from "./logger.js";
 import { StorageAPI } from "./storage/index.js";
 import { Peer, PeerID, SyncManager } from "./sync.js";
@@ -387,13 +387,17 @@ export class LocalNode {
     return coValue;
   }
 
+  hasLoadingSources(id: RawCoID) {
+    return this.storage || this.syncManager.getServerPeers(id).length > 0;
+  }
+
   /** @internal */
   async loadCoValueCore(
     id: RawCoID,
     skipLoadingFromPeer?: PeerID,
     skipRetry?: boolean,
   ): Promise<CoValueCore> {
-    if (typeof id !== "string" || !id.startsWith("co_z")) {
+    if (!isRawCoID(id)) {
       throw new TypeError(
         `Trying to load CoValue with invalid id ${Array.isArray(id) ? JSON.stringify(id) : id}`,
       );
@@ -421,6 +425,8 @@ export class LocalNode {
         const peers = this.syncManager.getServerPeers(id, skipLoadingFromPeer);
 
         if (!this.storage && peers.length === 0) {
+          // Flags the coValue as unavailable
+          coValue.markNotFoundInPeer("storage");
           return coValue;
         }