effect 4.0.0-beta.44 → 4.0.0-beta.45

package/src/unstable/eventlog/EventLogEncryption.ts

@@ -6,8 +6,10 @@ import * as Effect from "../../Effect.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 { Identity } from "./EventLog.ts"
+import { makeGetIdentityRootSecretMaterial } from "./internal/identityRootSecretDerivation.ts"
 
 /**
  * @since 4.0.0
@@ -15,7 +17,7 @@ import type { Identity } from "./EventLog.ts"
  */
 export const EncryptedEntry = Schema.Struct({
   entryId: EntryId,
-  encryptedEntry: Schema.Uint8Array
+  encryptedEntry: Transferable.Uint8Array
 })
 
 /**
@@ -30,9 +32,9 @@ export interface EncryptedRemoteEntry extends Schema.Schema.Type<typeof Encrypte
  */
 export const EncryptedRemoteEntry = Schema.Struct({
   sequence: Schema.Number,
-  iv: Schema.Uint8Array,
+  iv: Transferable.Uint8Array,
   entryId: EntryId,
-  encryptedEntry: Schema.Uint8Array
+  encryptedEntry: Transferable.Uint8Array
 })
 
 const toArrayBuffer = (data: Uint8Array): ArrayBuffer => {
@@ -52,8 +54,8 @@ export class EventLogEncryption extends Context.Service<EventLogEncryption, {
     identity: Identity["Service"],
     entries: ReadonlyArray<Entry>
   ) => Effect.Effect<{
-    readonly iv: Uint8Array
-    readonly encryptedEntries: ReadonlyArray<Uint8Array>
+    readonly iv: Uint8Array<ArrayBuffer>
+    readonly encryptedEntries: ReadonlyArray<Uint8Array<ArrayBuffer>>
   }>
   readonly decrypt: (
     identity: Identity["Service"],
@@ -61,6 +63,7 @@ export class EventLogEncryption extends Context.Service<EventLogEncryption, {
   ) => Effect.Effect<Array<RemoteEntry>>
   readonly sha256String: (data: Uint8Array) => Effect.Effect<string>
   readonly sha256: (data: Uint8Array) => Effect.Effect<Uint8Array>
+  readonly generateIdentity: Effect.Effect<Identity["Service"]>
 }>()("effect/eventlog/EventLogEncryption") {}
 
 /**
@@ -69,33 +72,12 @@ export class EventLogEncryption extends Context.Service<EventLogEncryption, {
  */
 export const makeEncryptionSubtle = (crypto: Crypto): Effect.Effect<EventLogEncryption["Service"]> =>
   Effect.sync(() => {
-    const keyCache = new WeakMap<Identity["Service"], CryptoKey>()
-    const getKey = (identity: Identity["Service"]) =>
-      Effect.suspend(() => {
-        if (keyCache.has(identity)) {
-          return Effect.succeed(keyCache.get(identity)!)
-        }
-        return Effect.promise(() =>
-          crypto.subtle.importKey(
-            "raw",
-            toArrayBuffer(Redacted.value(identity.privateKey)),
-            "AES-GCM",
-            true,
-            ["encrypt", "decrypt"]
-          )
-        ).pipe(
-          Effect.tap((key) =>
-            Effect.sync(() => {
-              keyCache.set(identity, key)
-            })
-          )
-        )
-      })
+    const getIdentityRootSecretMaterial = makeGetIdentityRootSecretMaterial(crypto)
 
     return EventLogEncryption.of({
       encrypt: Effect.fnUntraced(function*(identity, entries) {
         const data = yield* Effect.orDie(Entry.encodeArray(entries))
-        const key = yield* getKey(identity)
+        const key = (yield* getIdentityRootSecretMaterial(identity)).encryptionKey
         const iv = crypto.getRandomValues(new Uint8Array(12))
         const encryptedEntries = yield* Effect.promise(() =>
           Promise.all(
@@ -114,7 +96,7 @@ export const makeEncryptionSubtle = (crypto: Crypto): Effect.Effect<EventLogEncr
         }
       }),
       decrypt: Effect.fnUntraced(function*(identity, entries) {
-        const key = yield* getKey(identity)
+        const key = (yield* getIdentityRootSecretMaterial(identity)).encryptionKey
         const decryptedData = (yield* Effect.promise(() =>
           Promise.all(entries.map((data) =>
             crypto.subtle.decrypt(
@@ -141,7 +123,11 @@ export const makeEncryptionSubtle = (crypto: Crypto): Effect.Effect<EventLogEncr
               .join("")
             return hashHex
           }
-        )
+        ),
+      generateIdentity: Effect.sync(() => ({
+        publicKey: crypto.randomUUID(),
+        privateKey: Redacted.make(crypto.getRandomValues(new Uint8Array(32)))
+      }))
     })
   })
 

package/src/unstable/eventlog/EventLogMessage.ts

@@ -0,0 +1,277 @@
+/**
+ * @since 4.0.0
+ */
+import type { NonEmptyArray, NonEmptyReadonlyArray } from "../../Array.ts"
+import type { Brand } from "../../Brand.ts"
+import * as Schema from "../../Schema.ts"
+import * as Msgpack from "../encoding/Msgpack.ts"
+import * as Rpc from "../rpc/Rpc.ts"
+import * as RpcGroup from "../rpc/RpcGroup.ts"
+import * as RpcMiddleware from "../rpc/RpcMiddleware.ts"
+import * as Transferable from "../workers/Transferable.ts"
+import { Entry, RemoteEntry, RemoteId } from "./EventJournal.ts"
+import type { Identity } from "./EventLog.ts"
+import { EncryptedEntry, EncryptedRemoteEntry } from "./EventLogEncryption.ts"
+
+/**
+ * @since 4.0.0
+ * @category StoreId
+ */
+export type StoreIdTypeId = "effect/eventlog/EventLog/StoreId"
+
+/**
+ * @since 4.0.0
+ * @category StoreId
+ */
+export const StoreIdTypeId: StoreIdTypeId = "effect/eventlog/EventLog/StoreId"
+
+/**
+ * @since 4.0.0
+ * @category StoreId
+ */
+export type StoreId = string & Brand<StoreIdTypeId>
+
+/**
+ * @since 4.0.0
+ * @category StoreId
+ */
+export const StoreId = Schema.String.pipe(Schema.brand(StoreIdTypeId))
+
+/**
+ * @since 4.0.0
+ * @category protocol
+ */
+export class EventLogProtocolError extends Schema.TaggedErrorClass<EventLogProtocolError>(
+  "effect/eventlog/EventLogRemote/ProtocolError"
+)("EventLogProtocolError", {
+  requestTag: Schema.String,
+  publicKey: Schema.optional(Schema.String),
+  storeId: Schema.optional(StoreId),
+  code: Schema.Literals(["Unauthorized", "Forbidden", "NotFound", "InvalidRequest", "InternalServerError"]),
+  message: Schema.String
+}) {}
+
+/**
+ * @since 4.0.0
+ * @category Middleware
+ */
+export class EventLogAuthentication extends RpcMiddleware.Service<EventLogAuthentication, {
+  provides: Identity
+}>()("effect/eventlog/EventLogMessage/EventLogAuthentication", {
+  error: EventLogProtocolError
+}) {}
+
+/**
+ * @since 4.0.0
+ * @category protocol
+ */
+export class HelloResponse extends Schema.Class<HelloResponse>("effect/eventlog/EventLogRemote/HelloResponse")({
+  remoteId: RemoteId,
+  challenge: Transferable.Uint8Array
+}) {}
+
+/**
+ * @since 4.0.0
+ * @category protocol
+ */
+export class HelloRpc extends Rpc.make("EventLog.Hello", {
+  success: HelloResponse
+}) {}
+
+/**
+ * @since 4.0.0
+ * @category protocol
+ */
+export class Authenticate extends Schema.Class<Authenticate>("effect/eventlog/EventLogRemote/Authenticate")({
+  publicKey: Schema.String,
+  signingPublicKey: Transferable.Uint8Array,
+  signature: Transferable.Uint8Array,
+  algorithm: Schema.Literal("Ed25519")
+}) {}
+
+/**
+ * @since 4.0.0
+ * @category protocol
+ */
+export class AuthenticateRpc extends Rpc.make("EventLog.Authenticate", {
+  payload: Authenticate,
+  error: EventLogProtocolError
+}) {}
+
+/**
+ * @since 4.0.0
+ * @category protocol
+ */
+export class SingleMessage
+  extends Schema.TaggedClass<SingleMessage>("effect/eventlog/EventLogRemote/SingleMessage")("Single", {
+    data: Transferable.Uint8Array
+  })
+{}
+
+/**
+ * @since 4.0.0
+ * @category protocol
+ */
+export class ChunkedMessage
+  extends Schema.TaggedClass<ChunkedMessage>("effect/eventlog/EventLogRemote/ChunkedMessage")("Chunked", {
+    id: Schema.Number,
+    part: Schema.Tuple([Schema.Number, Schema.Number]),
+    data: Transferable.Uint8Array
+  })
+{
+  static chunkSize = 512_000
+
+  static initialJoinState() {
+    return new Map<number, {
+      readonly parts: Array<Uint8Array>
+      count: number
+      bytes: number
+    }>()
+  }
+
+  /**
+   * @since 4.0.0
+   */
+  static split(id: number, data: Uint8Array): NonEmptyReadonlyArray<ChunkedMessage> {
+    const parts = Math.ceil(data.byteLength / ChunkedMessage.chunkSize)
+    const result: NonEmptyArray<ChunkedMessage> = new Array(parts) as any
+    for (let i = 0; i < parts; i++) {
+      const start = i * ChunkedMessage.chunkSize
+      const end = Math.min((i + 1) * ChunkedMessage.chunkSize, data.byteLength)
+      result[i] = new ChunkedMessage({
+        id,
+        part: [i, parts],
+        data: data.subarray(start, end) as any
+      })
+    }
+    return result
+  }
+
+  /**
+   * @since 4.0.0
+   */
+  static join(
+    map: Map<number, {
+      readonly parts: Array<Uint8Array>
+      count: number
+      bytes: number
+    }>,
+    part: ChunkedMessage
+  ): Uint8Array<ArrayBuffer> | undefined {
+    const [index, total] = part.part
+    let entry = map.get(part.id)
+    if (!entry) {
+      entry = {
+        parts: new Array(total),
+        count: 0,
+        bytes: 0
+      }
+      map.set(part.id, entry)
+    }
+    entry.parts[index] = part.data
+    entry.count++
+    entry.bytes += part.data.byteLength
+    if (entry.count !== total) {
+      return
+    }
+    const data = new Uint8Array(entry.bytes)
+    let offset = 0
+    for (const part of entry.parts) {
+      data.set(part, offset)
+      offset += part.byteLength
+    }
+    map.delete(part.id)
+    return data
+  }
+}
+
+/**
+ * @since 4.0.0
+ * @category protocol
+ */
+export class WriteChunkedRpc extends Rpc.make("EventLog.WriteChunked", {
+  payload: ChunkedMessage,
+  error: EventLogProtocolError
+}).middleware(EventLogAuthentication) {}
+
+/**
+ * @since 4.0.0
+ * @category protocol
+ */
+export class WriteEntries extends Schema.Class<WriteEntries>("effect/eventlog/EventLogRemote/WriteEntries")({
+  publicKey: Schema.String,
+  storeId: StoreId,
+  iv: Transferable.Uint8Array,
+  encryptedEntries: Schema.Array(EncryptedEntry)
+}) {
+  static FromMsgpack = Msgpack.schema(WriteEntries)
+  static encode = Schema.encodeEffect(this.FromMsgpack)
+  static decode = Schema.decodeEffect(this.FromMsgpack)
+  get encoded() {
+    return WriteEntries.encode(this)
+  }
+}
+
+/**
+ * @since 4.0.0
+ * @category protocol
+ */
+export class WriteEntriesUnencrypted
+  extends Schema.Class<WriteEntriesUnencrypted>("effect/eventlog/EventLogRemote/WriteEntriesUnencrypted")({
+    publicKey: Schema.String,
+    storeId: StoreId,
+    entries: Schema.Array(Entry)
+  })
+{
+  static FromMsgpack = Msgpack.schema(WriteEntriesUnencrypted)
+  static encode = Schema.encodeEffect(this.FromMsgpack)
+  static decode = Schema.decodeEffect(this.FromMsgpack)
+  get encoded() {
+    return WriteEntriesUnencrypted.encode(this)
+  }
+}
+
+/**
+ * @since 4.0.0
+ * @category protocol
+ */
+export class WriteSingleRpc extends Rpc.make("EventLog.WriteSingle", {
+  payload: {
+    data: Transferable.Uint8Array
+  },
+  error: EventLogProtocolError
+}).middleware(EventLogAuthentication) {}
+
+/**
+ * @since 4.0.0
+ * @category protocol
+ */
+export class ChangesRpc extends Rpc.make("EventLog.Changes", {
+  payload: {
+    publicKey: Schema.String,
+    storeId: StoreId,
+    startSequence: Schema.Number
+  },
+  success: Schema.Union([SingleMessage, ChunkedMessage]),
+  error: EventLogProtocolError,
+  stream: true
+}).middleware(EventLogAuthentication) {
+  static EncryptedFromMsgpack = Msgpack.schema(Schema.NonEmptyArray(EncryptedRemoteEntry))
+  static UnencryptedFromMsgpack = Msgpack.schema(Schema.NonEmptyArray(RemoteEntry))
+  static encodeEncrypted = Schema.encodeEffect(ChangesRpc.EncryptedFromMsgpack)
+  static decodeEncrypted = Schema.decodeEffect(ChangesRpc.EncryptedFromMsgpack)
+  static encodeUnencrypted = Schema.encodeEffect(ChangesRpc.UnencryptedFromMsgpack)
+  static decodeUnencrypted = Schema.decodeEffect(ChangesRpc.UnencryptedFromMsgpack)
+}
+
+/**
+ * @since 4.0.0
+ * @category protocol
+ */
+export class EventLogRemoteRpcs extends RpcGroup.make(
+  HelloRpc,
+  AuthenticateRpc,
+  WriteChunkedRpc,
+  WriteSingleRpc,
+  ChangesRpc
+) {}