Replace poseidon2 F type with int as temporary stand-in for verification hashes

Author: benbierens

codex/manifest/types.nim

@@ -10,13 +10,11 @@
 # This module defines Manifest and all related types
 
 import std/tables
+import std/strutils
 import pkg/libp2p
-import pkg/constantine/math/io/io_fields
-import pkg/poseidon2
 
 import ../units
 export units
-export curves # workaround for "undeclared identifier: 'getCurveOrder'" from constantine
 
 const
   BlockCodec* = multiCodec("raw")
@@ -25,21 +23,23 @@ const
 type
   ManifestCoderType*[codec: static MultiCodec] = object
   DagPBCoder* = ManifestCoderType[multiCodec("dag-pb")]
-  VerificationHash* = F
+  VerificationHash* = int
+  # TODO: Replace this with a wrapper type that supports Poseidon2
+  # and is can be encoded/decoded, AND is JSON-serializable
 
 const
   ManifestContainers* = {
     $DagPBCodec: DagPBCoder()
   }.toTable
 
-proc `==`*(a, b: VerificationHash): bool =
-  a.toHex() == b.toHex()
-
 proc fromInt*(T: type VerificationHash, value: SomeInteger | SomeUnsignedInt): VerificationHash =
-  toF(value)
+  value.int
 
 proc encode*(a: VerificationHash): string =
-  a.toHex()
+  $a
 
 proc decode*(T: type VerificationHash, str: string): VerificationHash =
-  F.fromHex(str)
+  try:
+    parseInt(str)
+  except ValueError:
+    0

tests/codex/testmanifest.nim

@@ -11,62 +11,37 @@ import ./helpers
 import ./examples
 
 checksuite "Manifest":
-  test "Should encode/decode to/from base manifest":
-    var
-      manifest = Manifest.new(
-        treeCid = Cid.example,
-        blockSize = 1.MiBs,
-        datasetSize = 100.MiBs)
-
-    let
-      e = manifest.encode().tryGet()
-      decoded = Manifest.decode(e).tryGet()
-
-    check:
-      decoded == manifest
-
-  test "Should encode/decode to/from protected manifest":
-    var
-      manifest = Manifest.new(
-        manifest = Manifest.new(
-          treeCid = Cid.example,
-          blockSize = 1.MiBs,
-          datasetSize = 100.MiBs),
-        treeCid = Cid.example,
-        datasetSize = 200.MiBs,
-        eck = 10,
-        ecM = 10
-      )
-
-    let
-      e = manifest.encode().tryGet()
-      decoded = Manifest.decode(e).tryGet()
-
-    check:
-      decoded == manifest
-
-  test "Should encode/decode to/from verifiable manifest":
-    let protectedManifest = Manifest.new(
-      manifest = Manifest.new(
-        treeCid = Cid.example,
-        blockSize = 1.MiBs,
-        datasetSize = 100.MiBs),
+  let
+    manifest = Manifest.new(
+      treeCid = Cid.example,
+      blockSize = 1.MiBs,
+      datasetSize = 100.MiBs
+    )
+    protectedManifest = Manifest.new(
+      manifest = manifest,
       treeCid = Cid.example,
       datasetSize = 200.MiBs,
       eck = 10,
       ecM = 10
     )
-
-    var manifest = Manifest.new(
+    verifiableManifest = Manifest.new(
       manifest = protectedManifest,
       verificationRoot = VerificationHash.fromInt(12),
       slotRoots = @[VerificationHash.fromInt(23), VerificationHash.fromInt(34)]
     ).tryGet()
 
-    let
-      e = manifest.encode().tryGet()
-      decoded = Manifest.decode(e).tryGet()
+  proc encodeDecode(manifest: Manifest): Manifest =
+    let e = manifest.encode().tryGet()
+    Manifest.decode(e).tryGet()
+
+  test "Should encode/decode to/from base manifest":
+    check:
+      encodeDecode(manifest) == manifest
 
+  test "Should encode/decode to/from protected manifest":
     check:
-      decoded == manifest
+      encodeDecode(protectedManifest) == protectedManifest
 
+  test "Should encode/decode to/from verifiable manifest":
+    check:
+      encodeDecode(verifiableManifest) == verifiableManifest