feat: CID generation and canonical DAG-CBOR encoding

PDSharp.Core/Cid.fs

···
+namespace PDSharp.Core
+
+open System
+open System.Text
+
+/// Minimal Base32 (RFC 4648 Lowercase)
+module Base32Encoding =
+  let private alphabet = "abcdefghijklmnopqrstuvwxyz234567"
+
+  let ToString (data : byte[]) : string =
+    if data.Length = 0 then
+      ""
+    else
+      let mutable i = 0
+      let mutable index = 0
+      let mutable digit = 0
+      let mutable currByte = 0
+      let mutable nextByte = 0
+      let sb = StringBuilder((data.Length + 7) * 8 / 5)
+
+      while i < data.Length do
+        currByte <- (int data.[i]) &&& 0xFF
+
+        if index > 3 then
+          if (i + 1) < data.Length then
+            nextByte <- (int data.[i + 1]) &&& 0xFF
+          else
+            nextByte <- 0
+
+          digit <- currByte &&& (0xFF >>> index)
+          index <- (index + 5) % 8
+          digit <- digit <<< index
+          digit <- digit ||| (nextByte >>> (8 - index))
+          i <- i + 1
+        else
+          digit <- currByte >>> 8 - (index + 5) &&& 0x1F
+          index <- (index + 5) % 8
+
+          if index = 0 then
+            i <- i + 1
+
+        sb.Append(alphabet.[digit]) |> ignore
+
+      sb.ToString()
+
+/// Basic CID implementation for AT Protocol (CIDv1 + dag-cbor + sha2-256)
+///
+/// Constants for ATProto defaults:
+///  - Version 1 (0x01)
+///  - Codec: dag-cbor (0x71)
+///  - Hash: sha2-256 (0x12) - Length 32 (0x20)
+[<Struct>]
+type Cid =
+  val Bytes : byte[]
+  new(bytes : byte[]) = { Bytes = bytes }
+
+  static member FromHash(hash : byte[]) =
+    if hash.Length <> 32 then
+      failwith "Hash must be 32 bytes (sha2-256)"
+
+    let cidBytes = Array.zeroCreate<byte> 36
+    cidBytes.[0] <- 0x01uy
+    cidBytes.[1] <- 0x71uy
+    cidBytes.[2] <- 0x12uy
+    cidBytes.[3] <- 0x20uy
+    Array.Copy(hash, 0, cidBytes, 4, 32)
+    Cid cidBytes
+
+  override this.ToString() =
+    "b" + Base32Encoding.ToString(this.Bytes)

PDSharp.Core/DagCbor.fs

···
+namespace PDSharp.Core
+
+open System
+open System.Collections.Generic
+open System.Formats.Cbor
+open System.IO
+open System.Text
+
+module DagCbor =
+  type SortKey = { Length : int; Bytes : byte[] }
+
+  let private getSortKey (key : string) =
+    let bytes = Encoding.UTF8.GetBytes(key)
+    { Length = bytes.Length; Bytes = bytes }
+
+  let private compareKeys (a : string) (b : string) =
+    let ka = getSortKey a
+    let kb = getSortKey b
+
+    if ka.Length <> kb.Length then
+      ka.Length.CompareTo kb.Length
+    else
+      let mutable res = 0
+      let mutable i = 0
+
+      while res = 0 && i < ka.Bytes.Length do
+        res <- ka.Bytes.[i].CompareTo(kb.Bytes.[i])
+        i <- i + 1
+
+      res
+
+  let rec private writeItem (writer : CborWriter) (item : obj) =
+    match item with
+    | null -> writer.WriteNull()
+    | :? bool as b -> writer.WriteBoolean(b)
+    | :? int as i -> writer.WriteInt32(i)
+    | :? int64 as l -> writer.WriteInt64(l)
+    | :? string as s -> writer.WriteTextString(s)
+    | :? (byte[]) as b -> writer.WriteByteString(b)
+    | :? Cid as c ->
+      let tag = LanguagePrimitives.EnumOfValue<uint64, CborTag>(42UL)
+      writer.WriteTag(tag)
+      let rawCid = c.Bytes
+      let linkBytes = Array.zeroCreate<byte> (rawCid.Length + 1)
+      linkBytes.[0] <- 0x00uy
+      Array.Copy(rawCid, 0, linkBytes, 1, rawCid.Length)
+      writer.WriteByteString(linkBytes)
+
+    | :? Map<string, obj> as m ->
+      let keys = m |> Map.toList |> List.map fst |> List.sortWith compareKeys
+      writer.WriteStartMap(keys.Length)
+
+      for k in keys do
+        writer.WriteTextString(k)
+        writeItem writer (m.[k])
+
+      writer.WriteEndMap()
+
+    | :? IDictionary<string, obj> as d ->
+      let keys = d.Keys |> Seq.toList |> List.sortWith compareKeys
+      writer.WriteStartMap(d.Count)
+
+      for k in keys do
+        writer.WriteTextString(k)
+        writeItem writer (d.[k])
+
+      writer.WriteEndMap()
+
+    | :? seq<obj> as l ->
+      let arr = l |> Seq.toArray
+      writer.WriteStartArray(arr.Length)
+
+      for x in arr do
+        writeItem writer x
+
+      writer.WriteEndArray()
+
+    | _ -> failwith $"Unsupported type for DAG-CBOR: {item.GetType().Name}"
+
+  let encode (data : obj) : byte[] =
+    let writer = new CborWriter(CborConformanceMode.Strict, false, false)
+    writeItem writer data
+    writer.Encode()

PDSharp.Core/PDSharp.Core.fsproj

···
     </PropertyGroup>
 
     <ItemGroup>
-        <Compile Include="Config.fs"/>
-        <Compile Include="Crypto.fs"/>
-        <Compile Include="DidResolver.fs"/>
-        <Compile Include="Library.fs"/>
+        <Compile Include="Config.fs" />
+        <Compile Include="Cid.fs" />
+        <Compile Include="DagCbor.fs" />
+        <Compile Include="Crypto.fs" />
+        <Compile Include="DidResolver.fs" />
+        <Compile Include="Library.fs" />
     </ItemGroup>
 
     <ItemGroup>
       <PackageReference Include="BouncyCastle.Cryptography" Version="2.6.2" />
+      <PackageReference Include="System.Formats.Cbor" Version="10.0.1" />
     </ItemGroup>
 </Project>

PDSharp.Tests/Tests.fs

···
 module Tests
 
-open System
 open Xunit
 open PDSharp.Core.Models
 open PDSharp.Core.Config
 open PDSharp.Core.Crypto
+open PDSharp.Core
 open PDSharp.Core.DidResolver
 open Org.BouncyCastle.Utilities.Encoders
 open System.Text
+open System.Text.Json
 open Org.BouncyCastle.Math
-
-[<Fact>]
-let ``My test`` () = Assert.True(true)
 
 [<Fact>]
 let ``Can instantiate AppConfig`` () =
···
     }"""
 
   let doc =
-    System.Text.Json.JsonSerializer.Deserialize<DidDocument>(
-      json,
-      Json.JsonSerializerOptions(PropertyNameCaseInsensitive = true)
-    )
+    JsonSerializer.Deserialize<DidDocument>(json, JsonSerializerOptions(PropertyNameCaseInsensitive = true))
 
   Assert.Equal("did:web:example.com", doc.Id)
   Assert.Single doc.VerificationMethod |> ignore
   Assert.Equal("Multikey", doc.VerificationMethod.Head.Type)
+
+[<Fact>]
+let ``CID Generation from Hash`` () =
+  let hash =
+    Hex.Decode("b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9")
+
+  let cid = Cid.FromHash hash
+  Assert.Equal<byte>(0x01uy, cid.Bytes.[0])
+  Assert.Equal<byte>(0x71uy, cid.Bytes.[1])
+  Assert.Equal<byte>(0x12uy, cid.Bytes.[2])
+  Assert.Equal<byte>(0x20uy, cid.Bytes.[3])
+
+[<Fact>]
+let ``DAG-CBOR Canonical Sorting`` () =
+  let m = Map.ofList [ ("b", box 1); ("a", box 2) ]
+  let encoded = DagCbor.encode m
+  let hex = Hex.ToHexString encoded
+  Assert.Equal("a2616102616201", hex)
+
+[<Fact>]
+let ``DAG-CBOR Sorting Length vs Bytes`` () =
+  let m = Map.ofList [ ("aa", box 1); ("b", box 2) ]
+  let encoded = DagCbor.encode m
+  let hex = Hex.ToHexString encoded
+  Assert.Equal("a261620262616101", hex)

roadmap.txt

···
 --------------------------------------------------------------------------------
 Milestone C: DAG-CBOR + CID
 --------------------------------------------------------------------------------
-- Canonical DAG-CBOR encode/decode with IPLD link tagging
-- CID creation/parsing (multicodec dag-cbor, sha2-256)
+- [x] Canonical DAG-CBOR encode/decode with IPLD link tagging
+- [x] CID creation/parsing (multicodec dag-cbor, sha2-256)
 DoD: Record JSON → stable DAG-CBOR bytes → deterministic CID
 --------------------------------------------------------------------------------
 Milestone D: MST Implementation
···
 Milestone K: DNS + TLS + Reverse Proxy
 --------------------------------------------------------------------------------
 - DNS A/AAAA records for PDS hostname
-- TLS certs (ACME) via Caddy/Nginx/Traefik
+- TLS certs (ACME) via Caddy
 DoD: https://<pds-hostname> responds with valid cert
 --------------------------------------------------------------------------------
 Milestone L: Deploy PDSharp