From 8bb649e37578397dda4c33cd8a52c1a6f6f374af Mon Sep 17 00:00:00 2001
From: mrmr1993 <mr_1993@hotmail.co.uk>
Date: Thu, 13 Jun 2024 19:17:05 +0100
Subject: [PATCH 1/2] Add structProvable

---
 lib/generic.ts | 76 ++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 76 insertions(+)

diff --git a/lib/generic.ts b/lib/generic.ts
index e9f83d4b..fcb6b14c 100644
--- a/lib/generic.ts
+++ b/lib/generic.ts
@@ -17,6 +17,8 @@ export {
   EmptyNull,
   EmptyUndefined,
   EmptyVoid,
+  StructProvable,
+  structProvable,
 };
 
 type GenericProvable<T, TValue, Field> = {
@@ -28,6 +30,80 @@ type GenericProvable<T, TValue, Field> = {
   toValue: (x: T) => TValue;
   fromValue: (x: T | TValue) => T;
 };
+
+type StructProvable<T extends {}, TValue extends {[K in keyof T]: any}, Field> = {
+    [K in keyof T]: GenericProvable<T[K], TValue[K], Field>;
+}
+
+function structProvable<T extends {}, TValue extends {[K in keyof T]: any}, Field>
+  (typ: StructProvable<T, TValue, Field>):
+      GenericProvable<
+        {[K in keyof T]: T[K]},
+        {[K in keyof TValue]: TValue[K]},
+        Field>
+{
+    return {
+        toFields: (x) => {
+            var fields: Field[] = [];
+            var field: keyof T;
+            for (field in typ) {
+                fields.concat(typ[field].toFields(x[field]));
+            }
+            return fields;
+        },
+        toAuxiliary: (x? /* Why is this nullable?! */) => {
+            if (x == undefined) {
+                return [];
+            }
+            var auxes: any[] = [];
+            var field: keyof T;
+            for (field in typ) {
+                auxes.concat(typ[field].toAuxiliary(x[field]));
+            }
+            return auxes;
+        },
+        fromFields: (x: Field[], aux: any[]) => {
+            var res: {[K in keyof T]?: T[K]} = {};
+            var offset = 0;
+            var idx = 0;
+            var field: keyof T;
+            for (field in typ) {
+                let end = offset + typ[field].sizeInFields();
+                let field_aux = aux[idx];
+                res[field] = typ[field].fromFields(x.slice(offset, end), field_aux);
+                offset = end;
+                idx += 1;
+            }
+            return (res as {[K in keyof T]: T[K]});
+        },
+        sizeInFields: () => {
+            var sum = 0;
+            var field: keyof T;
+            for (field in typ) {
+                sum += typ[field].sizeInFields();
+            }
+            return sum;
+        },
+        check: (x) => {
+            var field: keyof T;
+            for (field in typ) {
+                typ[field].check(x[field]);
+            }
+        },
+        toValue: (x) => { // Wtf?
+            throw new Error("TODO");
+        },
+        fromValue: (x) => {
+            var res: {[K in keyof T]?: T[K]} = {};
+            var field: keyof T;
+            for (field in typ) {
+                res[field] = typ[field].fromValue(x[field]);
+            }
+            return (res as {[K in keyof T]: T[K]});
+        },
+    }
+}
+
 type GenericProvablePure<T, TValue, Field> = Omit<
   GenericProvable<T, TValue, Field>,
   'fromFields'

From caf8fa58669603895310fbb73839f56adc67dc9e Mon Sep 17 00:00:00 2001
From: mrmr1993 <mr_1993@hotmail.co.uk>
Date: Fri, 14 Jun 2024 14:19:58 +0100
Subject: [PATCH 2/2] Fixup toValue

---
 lib/generic.ts | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/lib/generic.ts b/lib/generic.ts
index fcb6b14c..84ac918e 100644
--- a/lib/generic.ts
+++ b/lib/generic.ts
@@ -39,7 +39,7 @@ function structProvable<T extends {}, TValue extends {[K in keyof T]: any}, Fiel
   (typ: StructProvable<T, TValue, Field>):
       GenericProvable<
         {[K in keyof T]: T[K]},
-        {[K in keyof TValue]: TValue[K]},
+        {[K in keyof T]: TValue[K]},
         Field>
 {
     return {
@@ -90,8 +90,13 @@ function structProvable<T extends {}, TValue extends {[K in keyof T]: any}, Fiel
                 typ[field].check(x[field]);
             }
         },
-        toValue: (x) => { // Wtf?
-            throw new Error("TODO");
+        toValue: (x) => {
+            var res: {[K in keyof T]?: TValue[K]} = {};
+            var field: keyof T;
+            for (field in typ) {
+                res[field] = typ[field].toValue(x[field]);
+            }
+            return (res as {[K in keyof T]: TValue[K]});
         },
         fromValue: (x) => {
             var res: {[K in keyof T]?: T[K]} = {};