effect 4.0.5 → 4.0.7

package/src/eventlog/EventLogEncryption.ts

@@ -9,62 +9,131 @@
  * @stability unstable
  * @since 4.0.0
  */
+import type { NonEmptyArray } from "../Array.ts"
 import * as Context from "../Context.ts"
 import * as Effect from "../Effect.ts"
+import * as SchemaBinary from "../encoding/SchemaBinary.ts"
 import * as Layer from "../Layer.ts"
 import * as Redacted from "../Redacted.ts"
 import * as Schema from "../Schema.ts"
 import * as Transferable from "../workers/Transferable.ts"
-import { Entry, EntryId, RemoteEntry } from "./EventJournal.ts"
+import { type Entry, EntryFields, entryFromFields, EntryId, RemoteEntry } from "./EventJournal.ts"
 import type { Identity } from "./EventLog.ts"
 import { makeGetIdentityRootSecretMaterial } from "./internal/identityRootSecretDerivation.ts"
 
 /**
- * Schema for an encrypted journal entry paired with its initialization vector
- * and the id of the original entry.
+ * Schema for a batch of journal entries encrypted as one AES-GCM message.
+ *
+ * **Details**
+ *
+ * `entryIds` lists the ids of the encrypted entries in order. It is sent in
+ * plaintext so the server can deduplicate batches, and it is authenticated
+ * together with the store id, so a server cannot alter it or move the batch to
+ * another store.
  *
  * @stability unstable
  * @category models
  * @since 4.0.0
  */
-export const EncryptedEntry = Schema.Struct({
-  entryId: EntryId,
+export const EncryptedBatch = Schema.Struct({
+  entryIds: Schema.NonEmptyArray(EntryId),
   iv: Transferable.Uint8Array,
-  encryptedEntry: Transferable.Uint8Array
+  encryptedBatch: Transferable.Uint8Array
 })
 
 /**
- * Type of an encrypted remote entry, including its remote sequence number,
- * initialization vector, entry id, and encrypted entry bytes.
+ * Type of an encrypted batch.
  *
  * @stability unstable
  * @category models
  * @since 4.0.0
  */
-export interface EncryptedRemoteEntry extends Schema.Schema.Type<typeof EncryptedRemoteEntry> {}
+export interface EncryptedBatch extends Schema.Schema.Type<typeof EncryptedBatch> {}
 
 /**
- * Schema for encrypted entries exchanged with a remote event-log server.
+ * Type of an encrypted batch stored by a remote server, including the remote
+ * sequence of its first entry.
  *
  * @stability unstable
  * @category models
  * @since 4.0.0
  */
-export const EncryptedRemoteEntry = Schema.Struct({
+export interface EncryptedRemoteBatch extends Schema.Schema.Type<typeof EncryptedRemoteBatch> {}
+
+/**
+ * Schema for encrypted batches exchanged with a remote event-log server.
+ *
+ * **Details**
+ *
+ * The entries of a batch have consecutive remote sequences starting at
+ * `sequence`.
+ *
+ * @stability unstable
+ * @category models
+ * @since 4.0.0
+ */
+export const EncryptedRemoteBatch = Schema.Struct({
   sequence: Schema.Natural,
-  iv: Transferable.Uint8Array,
-  entryId: EntryId,
-  encryptedEntry: Transferable.Uint8Array
+  ...EncryptedBatch.fields
 })
 
+const maxBatchEntries = 100
+const maxBatchPayloadBytes = 256 * 1024
+
+// A batch holds at most `maxBatchEntries` entries or `maxBatchPayloadBytes` of
+// payload, whichever comes first. A single larger entry is a batch on its own.
+const toBatches = (entries: ReadonlyArray<Entry>): Array<NonEmptyArray<Entry>> => {
+  const batches: Array<NonEmptyArray<Entry>> = []
+  let current: Array<Entry> = []
+  let bytes = 0
+  for (const entry of entries) {
+    const size = entry.payload.byteLength
+    if (current.length > 0 && (current.length === maxBatchEntries || bytes + size > maxBatchPayloadBytes)) {
+      batches.push(current as NonEmptyArray<Entry>)
+      current = []
+      bytes = 0
+    }
+    current.push(entry)
+    bytes += size
+  }
+  if (current.length > 0) batches.push(current as NonEmptyArray<Entry>)
+  return batches
+}
+
+const textEncoder = new TextEncoder()
+
+// The store id is length-prefixed, followed by the 16-byte entry ids.
+const additionalData = (storeId: string, entryIds: ReadonlyArray<EntryId>): Uint8Array<ArrayBuffer> => {
+  const store = textEncoder.encode(storeId)
+  const data = new Uint8Array(4 + store.byteLength + entryIds.length * 16)
+  new DataView(data.buffer).setUint32(0, store.byteLength)
+  data.set(store, 4)
+  let offset = 4 + store.byteLength
+  for (const id of entryIds) {
+    data.set(id, offset)
+    offset += 16
+  }
+  return data
+}
+
+const equalBytes = (a: Uint8Array, b: Uint8Array): boolean => {
+  if (a.byteLength !== b.byteLength) return false
+  for (let i = 0; i < a.byteLength; i++) {
+    if (a[i] !== b[i]) return false
+  }
+  return true
+}
+
+const BatchFromSchemaBinary = SchemaBinary.toCodec(Schema.NonEmptyArray(EntryFields))
+const encodeBatch = Schema.encodeEffect(BatchFromSchemaBinary)
+const decodeBatch = Schema.decodeEffect(BatchFromSchemaBinary)
+
 const toArrayBuffer = (data: Uint8Array): ArrayBuffer => {
   const buffer = new ArrayBuffer(data.byteLength)
   new Uint8Array(buffer).set(data)
   return buffer
 }
 
-const toBufferSource = (data: Uint8Array): ArrayBufferView<ArrayBuffer> => new Uint8Array(toArrayBuffer(data))
-
 /**
  * Service that provides identity generation, entry
  * encryption and decryption, and SHA-256 hashing for event-log replication.
@@ -81,16 +150,13 @@ const toBufferSource = (data: Uint8Array): ArrayBufferView<ArrayBuffer> => new U
 export class EventLogEncryption extends Context.Service<EventLogEncryption, {
   readonly encrypt: (
     identity: Identity["Service"],
+    storeId: string,
     entries: ReadonlyArray<Entry>
-  ) => Effect.Effect<
-    ReadonlyArray<{
-      readonly iv: Uint8Array<ArrayBuffer>
-      readonly encryptedEntry: Uint8Array<ArrayBuffer>
-    }>
-  >
+  ) => Effect.Effect<Array<EncryptedBatch>>
   readonly decrypt: (
     identity: Identity["Service"],
-    entries: ReadonlyArray<EncryptedRemoteEntry>
+    storeId: string,
+    batches: ReadonlyArray<EncryptedRemoteBatch>
   ) => Effect.Effect<Array<RemoteEntry>>
   readonly sha256String: (data: Uint8Array) => Effect.Effect<string>
   readonly sha256: (data: Uint8Array) => Effect.Effect<Uint8Array>
@@ -110,35 +176,54 @@ export const makeEncryptionSubtle = (crypto: Crypto): Effect.Effect<EventLogEncr
     const getIdentityRootSecretMaterial = makeGetIdentityRootSecretMaterial(crypto)
 
     return EventLogEncryption.of({
-      encrypt: Effect.fnUntraced(function*(identity, entries) {
-        const data = yield* Effect.orDie(Entry.encodeArray(entries))
+      encrypt: Effect.fnUntraced(function*(identity, storeId, entries) {
         const key = (yield* getIdentityRootSecretMaterial(identity)).encryptionKey
+        const batches = toBatches(entries)
+        const data = yield* Effect.orDie(Effect.forEach(batches, (batch) => encodeBatch(batch)))
         return yield* Effect.promise(() =>
-          Promise.all(
-            data.map((entry) => {
-              const iv = crypto.getRandomValues(new Uint8Array(12))
-              return crypto.subtle.encrypt(
-                { name: "AES-GCM", iv: toBufferSource(iv), tagLength: 128 },
-                key,
-                toBufferSource(entry)
-              ).then((encryptedEntry) => ({ iv, encryptedEntry: new Uint8Array(encryptedEntry) }))
-            })
-          )
+          Promise.all(batches.map((batch, i) => {
+            const entryIds = batch.map((entry) => entry.id) as NonEmptyArray<EntryId>
+            const iv = crypto.getRandomValues(new Uint8Array(12))
+            return crypto.subtle.encrypt(
+              { name: "AES-GCM", iv, additionalData: additionalData(storeId, entryIds), tagLength: 128 },
+              key,
+              data[i]
+            ).then((encryptedBatch) => ({ entryIds, iv, encryptedBatch: new Uint8Array(encryptedBatch) }))
+          }))
         )
       }),
-      decrypt: Effect.fnUntraced(function*(identity, entries) {
+      decrypt: Effect.fnUntraced(function*(identity, storeId, batches) {
         const key = (yield* getIdentityRootSecretMaterial(identity)).encryptionKey
-        const decryptedData = (yield* Effect.promise(() =>
-          Promise.all(entries.map((data) =>
+        const decrypted = yield* Effect.promise(() =>
+          Promise.all(batches.map((batch) =>
             crypto.subtle.decrypt(
-              { name: "AES-GCM", iv: toBufferSource(data.iv), tagLength: 128 },
+              {
+                name: "AES-GCM",
+                iv: batch.iv,
+                additionalData: additionalData(storeId, batch.entryIds),
+                tagLength: 128
+              },
               key,
-              toBufferSource(data.encryptedEntry)
+              batch.encryptedBatch
             )
           ))
-        )).map((buffer) => new Uint8Array(buffer))
-        const decoded = yield* Effect.orDie(Entry.decodeArray(decryptedData))
-        return decoded.map((entry, index) => new RemoteEntry({ remoteSequence: entries[index].sequence, entry }))
+        )
+        const result: Array<RemoteEntry> = []
+        for (let i = 0; i < batches.length; i++) {
+          const batch = batches[i]
+          const fields = yield* Effect.orDie(decodeBatch(new Uint8Array(decrypted[i])))
+          const entries = fields.map(entryFromFields)
+          if (
+            entries.length !== batch.entryIds.length ||
+            entries.some((entry, j) => !equalBytes(entry.id, batch.entryIds[j]))
+          ) {
+            return yield* Effect.die(new Error("Encrypted batch entries do not match its entry ids"))
+          }
+          for (let j = 0; j < entries.length; j++) {
+            result.push(new RemoteEntry({ remoteSequence: batch.sequence + j, entry: entries[j] }))
+          }
+        }
+        return result
       }),
       sha256: (data) =>
         Effect.promise(() => crypto.subtle.digest("SHA-256", toArrayBuffer(data))).pipe(

package/src/eventlog/EventLogMessage.ts

@@ -11,16 +11,18 @@
  */
 import type { NonEmptyArray, NonEmptyReadonlyArray } from "../Array.ts"
 import type { Brand } from "../Brand.ts"
+import * as Effect from "../Effect.ts"
 import * as SchemaBinary from "../encoding/SchemaBinary.ts"
 import * as Predicate from "../Predicate.ts"
 import * as Rpc from "../rpc/Rpc.ts"
 import * as RpcGroup from "../rpc/RpcGroup.ts"
 import * as RpcMiddleware from "../rpc/RpcMiddleware.ts"
 import * as Schema from "../Schema.ts"
+import type * as SchemaAST from "../SchemaAST.ts"
 import * as Transferable from "../workers/Transferable.ts"
-import { Entry, RemoteEntry, RemoteId } from "./EventJournal.ts"
+import { Entry, EntryFields, entryFromFields, EntryId, RemoteEntry, RemoteId } from "./EventJournal.ts"
 import type { Identity } from "./EventLog.ts"
-import { EncryptedEntry, EncryptedRemoteEntry } from "./EventLogEncryption.ts"
+import { EncryptedBatch, EncryptedRemoteBatch } from "./EventLogEncryption.ts"
 
 /**
  * Type-level identifier used to brand event-log store ids.
@@ -109,8 +111,8 @@ export class EventLogAuthentication extends RpcMiddleware.Service<EventLogAuthen
  *
  * **Details**
  *
- * It contains the server remote id and a challenge that must be signed by the
- * client.
+ * Contains the remote id, a challenge for the client to sign, and the lowest
+ * assigned sequence (default 0) for initializing acknowledgement cursors.
  *
  * @stability unstable
  * @category protocols
@@ -118,7 +120,8 @@ export class EventLogAuthentication extends RpcMiddleware.Service<EventLogAuthen
  */
 export class HelloResponse extends Schema.Class<HelloResponse>("effect/eventlog/EventLogRemote/HelloResponse")({
   remoteId: RemoteId,
-  challenge: Transferable.Uint8Array
+  challenge: Transferable.Uint8Array,
+  firstSequence: Schema.optional(Schema.Natural)
 }) {}
 
 /**
@@ -271,15 +274,45 @@ export class ChunkedMessage
   }
 }
 
+/**
+ * Schema for a written entry's id and a sequence at which the server stores
+ * it. Entries the server already held keep their stored sequence. When a write
+ * stores an entry again, as part of a partly known batch, it is acknowledged at
+ * its new position.
+ *
+ * @stability unstable
+ * @category protocols
+ * @since 4.0.6
+ */
+export const WriteAck = Schema.Struct({
+  entryId: EntryId,
+  sequence: Schema.Natural
+})
+
+/**
+ * Acknowledgement of one written entry.
+ *
+ * @stability unstable
+ * @category protocols
+ * @since 4.0.6
+ */
+export type WriteAck = typeof WriteAck.Type
+
 /**
  * RPC used to send one chunk of a large encoded write payload.
  *
+ * **Details**
+ *
+ * The completing chunk returns acknowledgements in request order; earlier
+ * chunks return an empty array.
+ *
  * @stability unstable
  * @category protocols
  * @since 4.0.0
  */
 export class WriteChunkedRpc extends Rpc.make("EventLog.WriteChunked", {
   payload: ChunkedMessage,
+  success: Schema.Array(WriteAck),
   error: EventLogProtocolError
 }).middleware(EventLogAuthentication) {}
 
@@ -288,8 +321,8 @@ export class WriteChunkedRpc extends Rpc.make("EventLog.WriteChunked", {
  *
  * **Details**
  *
- * It includes the client public key, target store id, and encrypted entries
- * with their AES-GCM initialization vectors.
+ * It includes the client public key, target store id, and the entries
+ * encrypted as batches.
  *
  * @stability unstable
  * @category protocols
@@ -298,7 +331,7 @@ export class WriteChunkedRpc extends Rpc.make("EventLog.WriteChunked", {
 export class WriteEntries extends Schema.Class<WriteEntries>("effect/eventlog/EventLogRemote/WriteEntries")({
   publicKey: Schema.String,
   storeId: StoreId,
-  encryptedEntries: Schema.Array(EncryptedEntry)
+  batches: Schema.Array(EncryptedBatch)
 }) {
   static FromSchemaBinary = SchemaBinary.toCodec(WriteEntries)
   static encode = Schema.encodeEffect(this.FromSchemaBinary)
@@ -324,15 +357,32 @@ export class WriteEntriesUnencrypted
 {
   static FromSchemaBinary = SchemaBinary.toCodec(WriteEntriesUnencrypted)
   static encode = Schema.encodeEffect(this.FromSchemaBinary)
-  static decode = Schema.decodeEffect(this.FromSchemaBinary)
+  static decode = (
+    data: Uint8Array<ArrayBuffer>,
+    options?: SchemaAST.ParseOptions
+  ): Effect.Effect<WriteEntriesUnencrypted, Schema.SchemaError> =>
+    Effect.map(
+      decodeWriteEntriesUnencryptedFields(data, options),
+      (fields) =>
+        Schema.makeClassTrusted(WriteEntriesUnencrypted, { ...fields, entries: fields.entries.map(entryFromFields) })
+    )
   get encoded() {
     return WriteEntriesUnencrypted.encode(this)
   }
 }
 
+const decodeWriteEntriesUnencryptedFields = Schema.decodeEffect(SchemaBinary.toCodec(Schema.Struct({
+  ...WriteEntriesUnencrypted.fields,
+  entries: Schema.Array(EntryFields)
+})))
+
 /**
  * RPC used to send an encoded write payload that fits in one message.
  *
+ * **Details**
+ *
+ * The response acknowledges every written entry, in request order.
+ *
  * @stability unstable
  * @category protocols
  * @since 4.0.0
@@ -341,6 +391,7 @@ export class WriteSingleRpc extends Rpc.make("EventLog.WriteSingle", {
   payload: {
     data: Transferable.Uint8Array
   },
+  success: Schema.Array(WriteAck),
   error: EventLogProtocolError
 }).middleware(EventLogAuthentication) {}
 
@@ -351,7 +402,7 @@ export class WriteSingleRpc extends Rpc.make("EventLog.WriteSingle", {
  * **Details**
  *
  * Responses are encoded as either `SingleMessage` values or `ChunkedMessage`
- * parts.
+ * parts. Entries written on this connection are acknowledged, not echoed.
  *
  * @stability unstable
  * @category protocols
@@ -367,7 +418,7 @@ export class ChangesRpc extends Rpc.make("EventLog.Changes", {
   error: EventLogProtocolError,
   stream: true
 }).middleware(EventLogAuthentication) {
-  static EncryptedFromSchemaBinary = SchemaBinary.toCodec(Schema.NonEmptyArray(EncryptedRemoteEntry))
+  static EncryptedFromSchemaBinary = SchemaBinary.toCodec(Schema.NonEmptyArray(EncryptedRemoteBatch))
   static UnencryptedFromSchemaBinary = SchemaBinary.toCodec(Schema.NonEmptyArray(RemoteEntry))
   static encodeEncrypted = Schema.encodeEffect(ChangesRpc.EncryptedFromSchemaBinary)
   static decodeEncrypted = Schema.decodeEffect(ChangesRpc.EncryptedFromSchemaBinary)

package/src/eventlog/EventLogRemote.ts

@@ -24,7 +24,7 @@ import type { RpcClientError } from "../rpc/RpcClientError.ts"
 import type * as RpcGroup from "../rpc/RpcGroup.ts"
 import type * as Schema from "../Schema.ts"
 import type * as Scope from "../Scope.ts"
-import type { Entry, RemoteEntry, RemoteId } from "./EventJournal.ts"
+import { type Entry, type EventJournal, type EventJournalError, RemoteEntry, type RemoteId } from "./EventJournal.ts"
 import { type Identity, Registry } from "./EventLog.ts"
 import { EventLogEncryption, layerSubtle } from "./EventLogEncryption.ts"
 import {
@@ -35,6 +35,7 @@ import {
   EventLogRemoteRpcs,
   type HelloResponse,
   type StoreId,
+  type WriteAck,
   WriteEntries,
   WriteEntriesUnencrypted
 } from "./EventLogMessage.ts"
@@ -54,22 +55,35 @@ import { makeGetIdentityRootSecretMaterial } from "./internal/identityRootSecret
  * It can write local entries to the remote, stream remote changes from a sequence
  * number, and run effects only after the supplied identity has authenticated.
  *
+ * Built-in remotes acknowledge writes instead of echoing them through `changes`.
+ * Custom remotes may return `void` from `write` to confirm uploads through
+ * `changes` instead.
+ *
  * @stability unstable
  * @category services
  * @since 4.0.0
  */
 export class EventLogRemote extends Context.Service<EventLogRemote, {
   readonly id: RemoteId
+  /**
+   * The lowest sequence the remote assigns, or 0 when omitted.
+   */
+  readonly firstSequence?: number | undefined
   readonly changes: (options: {
     readonly identity: Identity["Service"]
     readonly storeId: StoreId
     readonly startSequence: number
+    /**
+     * Looks up locally stored entries by id, so the remote can reuse them
+     * instead of decoding the matching changes.
+     */
+    readonly knownEntries?: EventJournal["Service"]["entriesById"] | undefined
   }) => Effect.Effect<Queue.Dequeue<RemoteEntry, EventLogRemoteError>, never, Scope.Scope>
   readonly write: (options: {
     readonly identity: Identity["Service"]
     readonly storeId: StoreId
     readonly entries: ReadonlyArray<Entry>
-  }) => Effect.Effect<void, EventLogRemoteError>
+  }) => Effect.Effect<ReadonlyArray<WriteAck> | void, EventLogRemoteError>
   readonly whenAuthenticated: <A, E, R>(
     effect: Effect.Effect<A, E, R>
   ) => Effect.Effect<A, E | EventLogRemoteError, R | Identity>
@@ -172,8 +186,10 @@ export const makeWith = Effect.fnUntraced(function*({ encodeWrite, decodeChanges
   }) => Effect.Effect<Uint8Array<ArrayBuffer>, Schema.SchemaError>
   readonly decodeChanges: (
     identity: Identity["Service"],
-    data: Uint8Array<ArrayBuffer>
-  ) => Effect.Effect<ReadonlyArray<RemoteEntry>, Schema.SchemaError>
+    storeId: StoreId,
+    data: Uint8Array<ArrayBuffer>,
+    knownEntries?: EventJournal["Service"]["entriesById"]
+  ) => Effect.Effect<ReadonlyArray<RemoteEntry>, Schema.SchemaError | EventJournalError>
 }): Effect.fn.Return<EventLogRemote["Service"], EventLogRemoteError, Scope.Scope | EventLogRemoteClient | Registry> {
   const client = yield* EventLogRemoteClient
   const registry = yield* Registry
@@ -236,6 +252,7 @@ export const makeWith = Effect.fnUntraced(function*({ encodeWrite, decodeChanges
 
   const remote = EventLogRemote.of({
     id: hello.remoteId,
+    firstSequence: hello.firstSequence,
     write: Effect.fnUntraced(
       function*(options) {
         yield* ensureAuthenticated(options.identity)
@@ -243,9 +260,13 @@ export const makeWith = Effect.fnUntraced(function*({ encodeWrite, decodeChanges
         if (encoded.byteLength <= ChunkedMessage.chunkSize) {
           return yield* client["EventLog.WriteSingle"]({ data: encoded })
         }
-        for (const part of ChunkedMessage.split(chunkedIdCounter++, encoded)) {
-          yield* client["EventLog.WriteChunked"](part)
-        }
+        // Only the part the server receives last carries acknowledgements.
+        const acks = yield* Effect.forEach(
+          ChunkedMessage.split(chunkedIdCounter++, encoded),
+          (part) => client["EventLog.WriteChunked"](part),
+          { concurrency: 4 }
+        )
+        return acks.flat()
       },
       retryForbidden,
       Effect.mapError((cause) => new EventLogRemoteError({ method: "write", cause }))
@@ -263,20 +284,30 @@ export const makeWith = Effect.fnUntraced(function*({ encodeWrite, decodeChanges
           startSequence: options.startSequence
         }, { asQueue: true })
 
+        // A batch can start before `startSequence`; its earlier entries are dropped.
+        const offer = Effect.fnUntraced(function*(data: Uint8Array<ArrayBuffer>) {
+          const entries = yield* decodeChanges(options.identity, options.storeId, data, options.knownEntries)
+          const first = entries.findIndex((entry) => entry.remoteSequence >= options.startSequence)
+          if (first === -1) return
+          yield* Queue.offerAll(outgoing, entries.slice(first))
+        })
+
         while (true) {
           const parts = yield* Queue.takeAll(incoming)
           for (let i = 0; i < parts.length; i++) {
             const part = parts[i]
             if (part._tag === "Single") {
-              yield* Queue.offerAll(outgoing, yield* decodeChanges(options.identity, part.data))
+              yield* offer(part.data)
               continue
             }
             const data = ChunkedMessage.join(chunkedState, part)
             if (!data) continue
-            yield* Queue.offerAll(outgoing, yield* decodeChanges(options.identity, data))
+            yield* offer(data)
           }
         }
       }).pipe(
+        // Forbidden retries resubscribe with the same `startSequence`. Other failures
+        // propagate to EventLog, which reconnects from the journal's committed sequence.
         (effect) => retryForbidden(effect, options),
         Effect.mapError((cause) => {
           if (cause._tag === "EventLogRemoteError") {
@@ -322,25 +353,50 @@ export const makeEncrypted = Effect.gen(function*(): Effect.fn.Return<
 > {
   const encryption = yield* EventLogEncryption
 
+  // Skip decryption only when every entry in a batch is already stored.
+  const decodeChanges = Effect.fnUntraced(function*(
+    identity: Identity["Service"],
+    storeId: StoreId,
+    data: Uint8Array<ArrayBuffer>,
+    knownEntries?: EventJournal["Service"]["entriesById"]
+  ) {
+    const batches = yield* ChangesRpc.decodeEncrypted(data)
+    if (knownEntries === undefined) return yield* encryption.decrypt(identity, storeId, batches)
+    const stored = yield* knownEntries(batches.flatMap((batch) => batch.entryIds))
+    let offset = 0
+    const knownBatches = batches.map((batch) => {
+      const entries = stored.slice(offset, offset + batch.entryIds.length)
+      offset += batch.entryIds.length
+      return entries.every((entry): entry is Entry => entry !== undefined) ? entries : undefined
+    })
+    const decrypted = yield* encryption.decrypt(
+      identity,
+      storeId,
+      batches.filter((_, i) => knownBatches[i] === undefined)
+    )
+    let next = 0
+    return batches.flatMap((batch, i) => {
+      const entries = knownBatches[i]
+      return entries === undefined
+        ? batch.entryIds.map(() => decrypted[next++])
+        : entries.map((entry, j) =>
+          new RemoteEntry({ remoteSequence: batch.sequence + j, entry }, { disableChecks: true })
+        )
+    })
+  })
+
   return yield* makeWith({
     encodeWrite: (options) =>
-      encryption.encrypt(options.identity, options.entries).pipe(
-        Effect.flatMap((encryptedEntries) =>
+      encryption.encrypt(options.identity, options.storeId, options.entries).pipe(
+        Effect.flatMap((batches) =>
           new WriteEntries({
             publicKey: options.identity.publicKey,
             storeId: options.storeId,
-            encryptedEntries: encryptedEntries.map((entry, i) => ({
-              entryId: options.entries[i].id,
-              iv: entry.iv,
-              encryptedEntry: entry.encryptedEntry
-            }))
+            batches
           }).encoded
         )
       ),
-    decodeChanges: (identity, data) =>
-      ChangesRpc.decodeEncrypted(data).pipe(
-        Effect.flatMap((entries) => encryption.decrypt(identity, entries))
-      )
+    decodeChanges
   })
 })
 
@@ -362,7 +418,7 @@ export const makeUnencrypted: Effect.Effect<
       storeId: options.storeId,
       entries: options.entries
     }).encoded,
-  decodeChanges: (_identity, data) => ChangesRpc.decodeUnencrypted(data)
+  decodeChanges: (_identity, _storeId, data) => ChangesRpc.decodeUnencrypted(data)
 })
 
 /**