@typeberry/lib 0.5.2 → 0.5.3-aa4626d

package/packages/jam/rpc-validation/validation.d.ts

@@ -3,6 +3,7 @@ export declare const JSON_RPC_VERSION = "2.0";
 export declare namespace validation {
     const hash: z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>;
     const slot: z.ZodNumber;
+    const coreIndex: z.ZodNumber;
     const blobArray: z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>;
     const serviceId: z.ZodNumber;
     const preimageLength: z.ZodNumber;
@@ -11,6 +12,10 @@ export declare namespace validation {
         header_hash: z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>;
         slot: z.ZodNumber;
     }, z.z.core.$strip>;
+    const refineResult: z.ZodObject<{
+        report: z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>;
+        exports: z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>;
+    }, z.z.core.$strip>;
     const parameters: z.ZodObject<{
         V1: z.ZodObject<{
             deposit_per_account: z.ZodNumber;
@@ -60,6 +65,212 @@ export declare namespace validation {
         input: z.ZodTuple<[z.ZodString], null>;
         output: z.ZodBoolean;
     };
+    /** Non-standard typeberry extension methods. */
+    const customSchemas: {
+        typeberry_refineWorkPackage: {
+            input: z.ZodTuple<[z.ZodNumber, z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>, z.ZodArray<z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>>], null>;
+            output: z.ZodObject<{
+                report: z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>;
+                exports: z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>;
+            }, z.z.core.$strip>;
+        };
+    };
+    /** JIP-2 (standardized) methods */
+    const jip2Schemas: {
+        beefyRoot: {
+            input: z.ZodTuple<[], null>;
+            output: z.ZodAny;
+        };
+        submitPreimage: {
+            input: z.ZodTuple<[], null>;
+            output: z.ZodAny;
+        };
+        submitWorkPackage: {
+            input: z.ZodTuple<[], null>;
+            output: z.ZodAny;
+        };
+        workReport: {
+            input: z.ZodTuple<[], null>;
+            output: z.ZodAny;
+        };
+        submitWorkPackageBundle: {
+            input: z.ZodTuple<[], null>;
+            output: z.ZodAny;
+        };
+        workPackageStatus: {
+            input: z.ZodTuple<[], null>;
+            output: z.ZodAny;
+        };
+        subscribeWorkPackageStatus: {
+            input: z.ZodTuple<[], null>;
+            output: z.ZodAny;
+        };
+        fetchWorkPackageSegments: {
+            input: z.ZodTuple<[], null>;
+            output: z.ZodAny;
+        };
+        fetchSegments: {
+            input: z.ZodTuple<[], null>;
+            output: z.ZodAny;
+        };
+        syncState: {
+            input: z.ZodTuple<[], null>;
+            output: z.ZodAny;
+        };
+        subscribeSyncStatus: {
+            input: z.ZodTuple<[], null>;
+            output: z.ZodAny;
+        };
+        bestBlock: {
+            input: z.ZodTuple<[], null>;
+            output: z.ZodObject<{
+                header_hash: z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>;
+                slot: z.ZodNumber;
+            }, z.z.core.$strip>;
+        };
+        finalizedBlock: {
+            input: z.ZodTuple<[], null>;
+            output: z.ZodObject<{
+                header_hash: z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>;
+                slot: z.ZodNumber;
+            }, z.z.core.$strip>;
+        };
+        listServices: {
+            input: z.ZodTuple<[z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>], null>;
+            output: z.ZodArray<z.ZodNumber>;
+        };
+        parameters: {
+            input: z.ZodTuple<[], null>;
+            output: z.ZodObject<{
+                V1: z.ZodObject<{
+                    deposit_per_account: z.ZodNumber;
+                    deposit_per_item: z.ZodNumber;
+                    deposit_per_byte: z.ZodNumber;
+                    min_turnaround_period: z.ZodNumber;
+                    epoch_period: z.ZodNumber;
+                    max_accumulate_gas: z.ZodNumber;
+                    max_is_authorized_gas: z.ZodNumber;
+                    max_refine_gas: z.ZodNumber;
+                    block_gas_limit: z.ZodNumber;
+                    recent_block_count: z.ZodNumber;
+                    max_work_items: z.ZodNumber;
+                    max_dependencies: z.ZodNumber;
+                    max_tickets_per_block: z.ZodNumber;
+                    max_lookup_anchor_age: z.ZodNumber;
+                    tickets_attempts_number: z.ZodNumber;
+                    auth_window: z.ZodNumber;
+                    auth_queue_len: z.ZodNumber;
+                    rotation_period: z.ZodNumber;
+                    max_extrinsics: z.ZodNumber;
+                    availability_timeout: z.ZodNumber;
+                    val_count: z.ZodNumber;
+                    max_input: z.ZodNumber;
+                    max_refine_code_size: z.ZodNumber;
+                    basic_piece_len: z.ZodNumber;
+                    max_imports: z.ZodNumber;
+                    max_is_authorized_code_size: z.ZodNumber;
+                    max_exports: z.ZodNumber;
+                    max_refine_memory: z.ZodNumber;
+                    max_is_authorized_memory: z.ZodNumber;
+                    segment_piece_count: z.ZodNumber;
+                    max_report_elective_data: z.ZodNumber;
+                    transfer_memo_size: z.ZodNumber;
+                    epoch_tail_start: z.ZodNumber;
+                    core_count: z.ZodNumber;
+                    slot_period_sec: z.ZodNumber;
+                    max_authorizer_code_size: z.ZodNumber;
+                    max_service_code_size: z.ZodNumber;
+                }, z.z.core.$strip>;
+            }, z.z.core.$strip>;
+        };
+        parent: {
+            input: z.ZodTuple<[z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>], null>;
+            output: z.ZodObject<{
+                header_hash: z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>;
+                slot: z.ZodNumber;
+            }, z.z.core.$strip>;
+        };
+        serviceData: {
+            input: z.ZodTuple<[z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>, z.ZodNumber], null>;
+            output: z.ZodUnion<readonly [z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>, z.ZodNull]>;
+        };
+        servicePreimage: {
+            input: z.ZodTuple<[z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>, z.ZodNumber, z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>], null>;
+            output: z.ZodUnion<readonly [z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>, z.ZodNull]>;
+        };
+        serviceRequest: {
+            input: z.ZodTuple<[z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>, z.ZodNumber, z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>, z.ZodNumber], null>;
+            output: z.ZodUnion<readonly [z.ZodReadonly<z.ZodArray<z.ZodNumber>>, z.ZodNull]>;
+        };
+        serviceValue: {
+            input: z.ZodTuple<[z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>, z.ZodNumber, z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>], null>;
+            output: z.ZodUnion<readonly [z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>, z.ZodNull]>;
+        };
+        stateRoot: {
+            input: z.ZodTuple<[z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>], null>;
+            output: z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>;
+        };
+        statistics: {
+            input: z.ZodTuple<[z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>], null>;
+            output: z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>;
+        };
+        subscribeBestBlock: {
+            input: z.ZodTuple<[], null>;
+            output: z.ZodString;
+        };
+        subscribeFinalizedBlock: {
+            input: z.ZodTuple<[], null>;
+            output: z.ZodString;
+        };
+        subscribeServiceData: {
+            input: z.ZodTuple<[z.ZodNumber, z.ZodBoolean], null>;
+            output: z.ZodString;
+        };
+        subscribeServicePreimage: {
+            input: z.ZodTuple<[z.ZodNumber, z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>, z.ZodBoolean], null>;
+            output: z.ZodString;
+        };
+        subscribeServiceRequest: {
+            input: z.ZodTuple<[z.ZodNumber, z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>, z.ZodNumber, z.ZodBoolean], null>;
+            output: z.ZodString;
+        };
+        subscribeServiceValue: {
+            input: z.ZodTuple<[z.ZodNumber, z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>, z.ZodBoolean], null>;
+            output: z.ZodString;
+        };
+        subscribeStatistics: {
+            input: z.ZodTuple<[z.ZodBoolean], null>;
+            output: z.ZodString;
+        };
+        unsubscribeBestBlock: {
+            input: z.ZodTuple<[z.ZodString], null>;
+            output: z.ZodBoolean;
+        };
+        unsubscribeFinalizedBlock: {
+            input: z.ZodTuple<[z.ZodString], null>;
+            output: z.ZodBoolean;
+        };
+        unsubscribeServiceData: {
+            input: z.ZodTuple<[z.ZodString], null>;
+            output: z.ZodBoolean;
+        };
+        unsubscribeServicePreimage: {
+            input: z.ZodTuple<[z.ZodString], null>;
+            output: z.ZodBoolean;
+        };
+        unsubscribeServiceRequest: {
+            input: z.ZodTuple<[z.ZodString], null>;
+            output: z.ZodBoolean;
+        };
+        unsubscribeServiceValue: {
+            input: z.ZodTuple<[z.ZodString], null>;
+            output: z.ZodBoolean;
+        };
+        unsubscribeStatistics: {
+            input: z.ZodTuple<[z.ZodString], null>;
+            output: z.ZodBoolean;
+        };
+    };
     const schemas: {
         readonly beefyRoot: {
             input: z.ZodTuple<[], null>;
@@ -106,26 +317,26 @@ export declare namespace validation {
             output: z.ZodAny;
         };
         readonly bestBlock: {
-            readonly input: z.ZodTuple<[], null>;
-            readonly output: z.ZodObject<{
+            input: z.ZodTuple<[], null>;
+            output: z.ZodObject<{
                 header_hash: z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>;
                 slot: z.ZodNumber;
             }, z.z.core.$strip>;
         };
         readonly finalizedBlock: {
-            readonly input: z.ZodTuple<[], null>;
-            readonly output: z.ZodObject<{
+            input: z.ZodTuple<[], null>;
+            output: z.ZodObject<{
                 header_hash: z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>;
                 slot: z.ZodNumber;
             }, z.z.core.$strip>;
         };
         readonly listServices: {
-            readonly input: z.ZodTuple<[z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>], null>;
-            readonly output: z.ZodArray<z.ZodNumber>;
+            input: z.ZodTuple<[z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>], null>;
+            output: z.ZodArray<z.ZodNumber>;
         };
         readonly parameters: {
-            readonly input: z.ZodTuple<[], null>;
-            readonly output: z.ZodObject<{
+            input: z.ZodTuple<[], null>;
+            output: z.ZodObject<{
                 V1: z.ZodObject<{
                     deposit_per_account: z.ZodNumber;
                     deposit_per_item: z.ZodNumber;
@@ -168,63 +379,63 @@ export declare namespace validation {
             }, z.z.core.$strip>;
         };
         readonly parent: {
-            readonly input: z.ZodTuple<[z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>], null>;
-            readonly output: z.ZodObject<{
+            input: z.ZodTuple<[z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>], null>;
+            output: z.ZodObject<{
                 header_hash: z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>;
                 slot: z.ZodNumber;
             }, z.z.core.$strip>;
         };
         readonly serviceData: {
-            readonly input: z.ZodTuple<[z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>, z.ZodNumber], null>;
-            readonly output: z.ZodUnion<readonly [z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>, z.ZodNull]>;
+            input: z.ZodTuple<[z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>, z.ZodNumber], null>;
+            output: z.ZodUnion<readonly [z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>, z.ZodNull]>;
         };
         readonly servicePreimage: {
-            readonly input: z.ZodTuple<[z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>, z.ZodNumber, z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>], null>;
-            readonly output: z.ZodUnion<readonly [z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>, z.ZodNull]>;
+            input: z.ZodTuple<[z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>, z.ZodNumber, z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>], null>;
+            output: z.ZodUnion<readonly [z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>, z.ZodNull]>;
         };
         readonly serviceRequest: {
-            readonly input: z.ZodTuple<[z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>, z.ZodNumber, z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>, z.ZodNumber], null>;
-            readonly output: z.ZodUnion<readonly [z.ZodReadonly<z.ZodArray<z.ZodNumber>>, z.ZodNull]>;
+            input: z.ZodTuple<[z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>, z.ZodNumber, z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>, z.ZodNumber], null>;
+            output: z.ZodUnion<readonly [z.ZodReadonly<z.ZodArray<z.ZodNumber>>, z.ZodNull]>;
         };
         readonly serviceValue: {
-            readonly input: z.ZodTuple<[z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>, z.ZodNumber, z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>], null>;
-            readonly output: z.ZodUnion<readonly [z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>, z.ZodNull]>;
+            input: z.ZodTuple<[z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>, z.ZodNumber, z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>], null>;
+            output: z.ZodUnion<readonly [z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>, z.ZodNull]>;
         };
         readonly stateRoot: {
-            readonly input: z.ZodTuple<[z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>], null>;
-            readonly output: z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>;
+            input: z.ZodTuple<[z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>], null>;
+            output: z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>;
         };
         readonly statistics: {
-            readonly input: z.ZodTuple<[z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>], null>;
-            readonly output: z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>;
+            input: z.ZodTuple<[z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>], null>;
+            output: z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>;
         };
         readonly subscribeBestBlock: {
-            readonly input: z.ZodTuple<[], null>;
-            readonly output: z.ZodString;
+            input: z.ZodTuple<[], null>;
+            output: z.ZodString;
         };
         readonly subscribeFinalizedBlock: {
-            readonly input: z.ZodTuple<[], null>;
-            readonly output: z.ZodString;
+            input: z.ZodTuple<[], null>;
+            output: z.ZodString;
         };
         readonly subscribeServiceData: {
-            readonly input: z.ZodTuple<[z.ZodNumber, z.ZodBoolean], null>;
-            readonly output: z.ZodString;
+            input: z.ZodTuple<[z.ZodNumber, z.ZodBoolean], null>;
+            output: z.ZodString;
         };
         readonly subscribeServicePreimage: {
-            readonly input: z.ZodTuple<[z.ZodNumber, z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>, z.ZodBoolean], null>;
-            readonly output: z.ZodString;
+            input: z.ZodTuple<[z.ZodNumber, z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>, z.ZodBoolean], null>;
+            output: z.ZodString;
         };
         readonly subscribeServiceRequest: {
-            readonly input: z.ZodTuple<[z.ZodNumber, z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>, z.ZodNumber, z.ZodBoolean], null>;
-            readonly output: z.ZodString;
+            input: z.ZodTuple<[z.ZodNumber, z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>, z.ZodNumber, z.ZodBoolean], null>;
+            output: z.ZodString;
         };
         readonly subscribeServiceValue: {
-            readonly input: z.ZodTuple<[z.ZodNumber, z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>, z.ZodBoolean], null>;
-            readonly output: z.ZodString;
+            input: z.ZodTuple<[z.ZodNumber, z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>, z.ZodBoolean], null>;
+            output: z.ZodString;
         };
         readonly subscribeStatistics: {
-            readonly input: z.ZodTuple<[z.ZodBoolean], null>;
-            readonly output: z.ZodString;
+            input: z.ZodTuple<[z.ZodBoolean], null>;
+            output: z.ZodString;
         };
         readonly unsubscribeBestBlock: {
             input: z.ZodTuple<[z.ZodString], null>;
@@ -254,6 +465,13 @@ export declare namespace validation {
             input: z.ZodTuple<[z.ZodString], null>;
             output: z.ZodBoolean;
         };
+        readonly typeberry_refineWorkPackage: {
+            input: z.ZodTuple<[z.ZodNumber, z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>, z.ZodArray<z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>>], null>;
+            output: z.ZodObject<{
+                report: z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>;
+                exports: z.ZodCodec<z.ZodBase64, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>;
+            }, z.z.core.$strip>;
+        };
     };
     const jsonRpcRequest: z.ZodObject<{
         jsonrpc: z.ZodLiteral<"2.0">;

package/packages/jam/rpc-validation/validation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/rpc-validation/validation.ts"],"names":[],"mappings":"AACA,OAAO,CAAC,MAAM,KAAK,CAAC;AAEpB,eAAO,MAAM,gBAAgB,QAAQ,CAAC;AACtC,yBAAiB,UAAU,CAAC;IAInB,MAAM,IAAI,gGAOhB,CAAC;IACK,MAAM,IAAI,aAAM,CAAC;IACjB,MAAM,SAAS,gGAGpB,CAAC;IACI,MAAM,SAAS,aAAM,CAAC;IACtB,MAAM,cAAc,aAAM,CAAC;IAC3B,MAAM,MAAM,sBAAc,CAAC;IAC3B,MAAM,eAAe;;;uBAG1B,CAAC;IAEI,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAwCrB,CAAC;IAEI,MAAM,oBAAoB;;;KAGhC,CAAC;IAEK,MAAM,iBAAiB;;;KAG7B,CAAC;IAEK,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA2F8D,CAAC;IAE5E,MAAM,cAAc;;;;;uBAKzB,CAAC;IAEI,MAAM,mBAAmB;;;;uBAAoC,CAAC;CACtE;AAED,eAAO,MAAM,oBAAoB;;;;;;;;CAQqE,CAAC"}
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/rpc-validation/validation.ts"],"names":[],"mappings":"AACA,OAAO,CAAC,MAAM,KAAK,CAAC;AAEpB,eAAO,MAAM,gBAAgB,QAAQ,CAAC;AACtC,yBAAiB,UAAU,CAAC;IAMnB,MAAM,IAAI,gGAOhB,CAAC;IACK,MAAM,IAAI,aAAM,CAAC;IACjB,MAAM,SAAS,aAAM,CAAC;IACtB,MAAM,SAAS,gGAGpB,CAAC;IACI,MAAM,SAAS,aAAM,CAAC;IACtB,MAAM,cAAc,aAAM,CAAC;IAC3B,MAAM,MAAM,sBAAc,CAAC;IAC3B,MAAM,eAAe;;;uBAG1B,CAAC;IAEI,MAAM,YAAY;;;uBAGvB,CAAC;IAEI,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAwCrB,CAAC;IAEI,MAAM,oBAAoB;;;KAGhC,CAAC;IAEK,MAAM,iBAAiB;;;KAG7B,CAAC;IAEF,gDAAgD;IACzC,MAAM,aAAa;;;;;;;;KAKzB,CAAC;IAEF,mCAAmC;IAC5B,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA2FvB,CAAC;IAEK,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAG8D,CAAC;IAE5E,MAAM,cAAc;;;;;uBAKzB,CAAC;IAEI,MAAM,mBAAmB;;;;uBAAoC,CAAC;CACtE;AAED,eAAO,MAAM,oBAAoB;;;;;;;;CAQqE,CAAC"}

package/packages/jam/rpc-validation/validation.js

@@ -3,13 +3,15 @@ import z from "zod";
 export const JSON_RPC_VERSION = "2.0";
 export var validation;
 (function (validation) {
-    const u32 = z.number().int().min(0).max(0xffffffff);
+    const u16 = z.number().int().min(0).max(0xffff);
+    const u32 = z.number().int().min(0).max(0xffff_ffff);
     const uint8Array = z.custom((v) => v instanceof Uint8Array); // this is needed because a simple z.instanceof(Uint8Array) automatically narrows the type down to Uint8Array<ArrayBuffer> whereas our Bytes.raw are effectively Uint8Array<ArrayBufferLike>
     validation.hash = z.codec(z.base64(), uint8Array.refine((v) => v.length === HASH_SIZE, "Invalid hash length."), {
         decode: (v) => Uint8Array.from(Buffer.from(v, "base64")),
         encode: (v) => Buffer.from(v).toString("base64"),
     });
     validation.slot = u32;
+    validation.coreIndex = u16;
     validation.blobArray = z.codec(z.base64(), uint8Array, {
         decode: (v) => Uint8Array.from(Buffer.from(v, "base64")),
         encode: (v) => Buffer.from(v).toString("base64"),
@@ -21,6 +23,10 @@ export var validation;
         header_hash: validation.hash,
         slot: validation.slot,
     });
+    validation.refineResult = z.object({
+        report: validation.blobArray,
+        exports: validation.blobArray,
+    });
     validation.parameters = z.object({
         V1: z.object({
             deposit_per_account: z.number(),
@@ -70,7 +76,15 @@ export var validation;
         input: z.tuple([z.string()]),
         output: z.boolean(),
     };
-    validation.schemas = {
+    /** Non-standard typeberry extension methods. */
+    validation.customSchemas = {
+        typeberry_refineWorkPackage: {
+            input: z.tuple([validation.coreIndex, validation.blobArray, z.array(validation.blobArray)]),
+            output: validation.refineResult,
+        },
+    };
+    /** JIP-2 (standardized) methods */
+    validation.jip2Schemas = {
         beefyRoot: validation.notImplementedSchema,
         submitPreimage: validation.notImplementedSchema,
         submitWorkPackage: validation.notImplementedSchema,
@@ -162,6 +176,10 @@ export var validation;
         unsubscribeServiceValue: validation.unsubscribeSchema,
         unsubscribeStatistics: validation.unsubscribeSchema,
     };
+    validation.schemas = {
+        ...validation.customSchemas,
+        ...validation.jip2Schemas,
+    };
     validation.jsonRpcRequest = z.object({
         jsonrpc: z.literal(JSON_RPC_VERSION),
         method: z.string(),

package/packages/jam/safrole/bandersnatch-vrf.d.ts

@@ -8,12 +8,14 @@ import { type Opaque, Result } from "#@typeberry/utils";
 import type { BandernsatchWasm } from "./bandersnatch-wasm.js";
 declare const FUNCTIONS: {
     verifySeal: typeof verifySeal;
+    verifyHeaderSeals: typeof verifyHeaderSeals;
     verifyTickets: typeof verifyTickets;
     getRingCommitment: typeof getRingCommitment;
     generateSeal: typeof generateSeal;
     getVrfOutputHash: typeof getVrfOutputHash;
 };
 export default FUNCTIONS;
+declare function verifyHeaderSeals(bandersnatch: BandernsatchWasm, authorKey: BandersnatchKey, signature: BandersnatchVrfSignature, payload: BytesBlob, encodedUnsealedHeader: BytesBlob, entropySignature: BandersnatchVrfSignature, entropyPayloadPrefix: BytesBlob): Promise<Result<[EntropyHash, EntropyHash], null>>;
 declare function verifySeal(bandersnatch: BandernsatchWasm, authorKey: BandersnatchKey, signature: BandersnatchVrfSignature, payload: BytesBlob, encodedUnsealedHeader: BytesBlob): Promise<Result<EntropyHash, null>>;
 declare function getRingCommitment(bandersnatch: BandernsatchWasm, validators: BandersnatchKey[]): Promise<Result<BandersnatchRingRoot, null>>;
 declare function verifyTickets(bandersnatch: BandernsatchWasm, numberOfValidators: number, epochRoot: BandersnatchRingRoot, tickets: readonly SignedTicket[], entropy: EntropyHash): Promise<{

package/packages/jam/safrole/bandersnatch-vrf.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bandersnatch-vrf.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/safrole/bandersnatch-vrf.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,EAAS,SAAS,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,KAAK,EAAE,eAAe,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AACjF,OAAO,EAGL,KAAK,oBAAoB,EACzB,KAAK,wBAAwB,EAC9B,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EAAa,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7D,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAwB/D,QAAA,MAAM,SAAS;;;;;;CAMd,CAAC;AAKF,eAAe,SAAS,CAAC;AAEzB,iBAAe,UAAU,CACvB,YAAY,EAAE,gBAAgB,EAC9B,SAAS,EAAE,eAAe,EAC1B,SAAS,EAAE,wBAAwB,EACnC,OAAO,EAAE,SAAS,EAClB,qBAAqB,EAAE,SAAS,GAC/B,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,IAAI,CAAC,CAAC,CAapC;AAED,iBAAS,iBAAiB,CACxB,YAAY,EAAE,gBAAgB,EAC9B,UAAU,EAAE,eAAe,EAAE,GAC5B,OAAO,CAAC,MAAM,CAAC,oBAAoB,EAAE,IAAI,CAAC,CAAC,CAmB7C;AAkBD,iBAAe,aAAa,CAC1B,YAAY,EAAE,gBAAgB,EAC9B,kBAAkB,EAAE,MAAM,EAC1B,SAAS,EAAE,oBAAoB,EAC/B,OAAO,EAAE,SAAS,YAAY,EAAE,EAChC,OAAO,EAAE,WAAW,GACnB,OAAO,CAAC;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,WAAW,EAAE,WAAW,CAAA;CAAE,EAAE,CAAC,CAqB3D;AAED,iBAAe,YAAY,CACzB,YAAY,EAAE,gBAAgB,EAC9B,SAAS,EAAE,sBAAsB,EACjC,KAAK,EAAE,SAAS,EAChB,OAAO,EAAE,SAAS,GACjB,OAAO,CAAC,MAAM,CAAC,wBAAwB,EAAE,IAAI,CAAC,CAAC,CAQjD;AAED,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,UAAU,EAAE,iBAAiB,CAAC,CAAC;AAElE,iBAAe,gBAAgB,CAC7B,YAAY,EAAE,gBAAgB,EAC9B,SAAS,EAAE,sBAAsB,EACjC,KAAK,EAAE,SAAS,GACf,OAAO,CAAC,MAAM,CAAC,aAAa,EAAE,IAAI,CAAC,CAAC,CAQtC"}
+{"version":3,"file":"bandersnatch-vrf.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/safrole/bandersnatch-vrf.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,EAAS,SAAS,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,KAAK,EAAE,eAAe,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AACjF,OAAO,EAGL,KAAK,oBAAoB,EACzB,KAAK,wBAAwB,EAC9B,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EAAa,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7D,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAwB/D,QAAA,MAAM,SAAS;;;;;;;CAOd,CAAC;AAKF,eAAe,SAAS,CAAC;AAEzB,iBAAe,iBAAiB,CAC9B,YAAY,EAAE,gBAAgB,EAC9B,SAAS,EAAE,eAAe,EAC1B,SAAS,EAAE,wBAAwB,EACnC,OAAO,EAAE,SAAS,EAClB,qBAAqB,EAAE,SAAS,EAChC,gBAAgB,EAAE,wBAAwB,EAC1C,oBAAoB,EAAE,SAAS,GAC9B,OAAO,CAAC,MAAM,CAAC,CAAC,WAAW,EAAE,WAAW,CAAC,EAAE,IAAI,CAAC,CAAC,CAkBnD;AAED,iBAAe,UAAU,CACvB,YAAY,EAAE,gBAAgB,EAC9B,SAAS,EAAE,eAAe,EAC1B,SAAS,EAAE,wBAAwB,EACnC,OAAO,EAAE,SAAS,EAClB,qBAAqB,EAAE,SAAS,GAC/B,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,IAAI,CAAC,CAAC,CAapC;AAED,iBAAS,iBAAiB,CACxB,YAAY,EAAE,gBAAgB,EAC9B,UAAU,EAAE,eAAe,EAAE,GAC5B,OAAO,CAAC,MAAM,CAAC,oBAAoB,EAAE,IAAI,CAAC,CAAC,CAmB7C;AAkBD,iBAAe,aAAa,CAC1B,YAAY,EAAE,gBAAgB,EAC9B,kBAAkB,EAAE,MAAM,EAC1B,SAAS,EAAE,oBAAoB,EAC/B,OAAO,EAAE,SAAS,YAAY,EAAE,EAChC,OAAO,EAAE,WAAW,GACnB,OAAO,CAAC;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,WAAW,EAAE,WAAW,CAAA;CAAE,EAAE,CAAC,CAqB3D;AAED,iBAAe,YAAY,CACzB,YAAY,EAAE,gBAAgB,EAC9B,SAAS,EAAE,sBAAsB,EACjC,KAAK,EAAE,SAAS,EAChB,OAAO,EAAE,SAAS,GACjB,OAAO,CAAC,MAAM,CAAC,wBAAwB,EAAE,IAAI,CAAC,CAAC,CAQjD;AAED,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,UAAU,EAAE,iBAAiB,CAAC,CAAC;AAElE,iBAAe,gBAAgB,CAC7B,YAAY,EAAE,gBAAgB,EAC9B,SAAS,EAAE,sBAAsB,EACjC,KAAK,EAAE,SAAS,GACf,OAAO,CAAC,MAAM,CAAC,aAAa,EAAE,IAAI,CAAC,CAAC,CAQtC"}

package/packages/jam/safrole/bandersnatch-vrf.js

@@ -20,6 +20,7 @@ var ResultValues;
 const ringCommitmentCache = [];
 const FUNCTIONS = {
     verifySeal,
+    verifyHeaderSeals,
     verifyTickets,
     getRingCommitment,
     generateSeal,
@@ -29,6 +30,16 @@ const FUNCTIONS = {
 // Ideally we would just export functions and figure out how to mock
 // properly in ESM.
 export default FUNCTIONS;
+async function verifyHeaderSeals(bandersnatch, authorKey, signature, payload, encodedUnsealedHeader, entropySignature, entropyPayloadPrefix) {
+    const sealResult = await bandersnatch.verifyHeaderSeals(authorKey.raw, signature.raw, payload.raw, encodedUnsealedHeader.raw, entropySignature.raw, entropyPayloadPrefix.raw);
+    if (sealResult[RESULT_INDEX] === ResultValues.Error) {
+        return Result.error(null, () => "Bandersnatch VRF seal verification failed");
+    }
+    return Result.ok([
+        Bytes.fromBlob(sealResult.subarray(1, 33), HASH_SIZE).asOpaque(),
+        Bytes.fromBlob(sealResult.subarray(33), HASH_SIZE).asOpaque(),
+    ]);
+}
 async function verifySeal(bandersnatch, authorKey, signature, payload, encodedUnsealedHeader) {
     const sealResult = await bandersnatch.verifySeal(authorKey.raw, signature.raw, payload.raw, encodedUnsealedHeader.raw);
     if (sealResult[RESULT_INDEX] === ResultValues.Error) {

package/packages/jam/safrole/bandersnatch-vrf.test.js

@@ -27,7 +27,7 @@ describe("Bandersnatch verification", () => {
             const result = await bandersnatchVrf.getRingCommitment(await bandersnatchWasm, bandersnatchKeys);
             const expectedCommitment = Bytes.parseBytes("0x8387a131593447e4e1c3d4e220c322e42d33207fa77cd0fedb39fc3491479ca47a2d82295252e278fa3eec78185982ed82ae0c8fd691335e703d663fb5be02b3def15380789320636b2479beab5a03ccb3f0909ffea59d859fcdc7e187e45a8c92e630ae2b14e758ab0960e372172203f4c9a41777dadd529971d7ab9d23ab29fe0e9c85ec450505dde7f5ac038274cf", BANDERSNATCH_RING_ROOT_BYTES);
             assert.strictEqual(result.isOk, true);
-            assert.deepStrictEqual(result.ok, expectedCommitment);
+            assert.strictEqual(result.ok.toString(), expectedCommitment.toString());
         });
     });
     describe("verifyTickets", () => {
@@ -72,7 +72,7 @@ describe("Bandersnatch verification", () => {
             ].map((x) => Bytes.parseBytes(x, HASH_SIZE));
             const result = await bandersnatchVrf.verifyTickets(await bandersnatchWasm, bandersnatchKeys.length, commitment, tickets, entropy);
             assert.strictEqual(result.every((x) => x.isValid), true);
-            assert.deepStrictEqual(result.map((x) => x.entropyHash), expectedIds);
+            assert.deepStrictEqual(result.map((x) => x.entropyHash.toString()), expectedIds.map((x) => x.toString()));
         });
         it("should detect that one signature is incorrect", async () => {
             const tickets = [
@@ -97,7 +97,7 @@ describe("Bandersnatch verification", () => {
             ].map((x) => Bytes.parseBytes(x, HASH_SIZE));
             const result = await bandersnatchVrf.verifyTickets(await bandersnatchWasm, bandersnatchKeys.length, commitment, tickets, entropy);
             assert.deepStrictEqual(result.map((x) => x.isValid), [false, true, true]);
-            assert.deepStrictEqual(result.map((x) => x.entropyHash), expectedIds);
+            assert.deepStrictEqual(result.map((x) => x.entropyHash.toString()), expectedIds.map((x) => x.toString()));
         });
     });
     describe("verifySeal", () => {

package/packages/jam/safrole/bandersnatch-wasm.d.ts

@@ -2,6 +2,7 @@ export declare class BandernsatchWasm {
     private constructor();
     static new(): Promise<BandernsatchWasm>;
     verifySeal(authorKey: Uint8Array, signature: Uint8Array, payload: Uint8Array, auxData: Uint8Array): Promise<Uint8Array<ArrayBufferLike>>;
+    verifyHeaderSeals(authorKey: Uint8Array, headerSeal: Uint8Array, headerSealPayload: Uint8Array, unsealedHeader: Uint8Array, entropySeal: Uint8Array, entropyPayloadPrefix: Uint8Array): Promise<Uint8Array<ArrayBufferLike>>;
     getRingCommitment(keys: Uint8Array): Promise<Uint8Array<ArrayBufferLike>>;
     batchVerifyTicket(ringSize: number, commitment: Uint8Array, ticketsData: Uint8Array, contextLength: number): Promise<Uint8Array<ArrayBufferLike>>;
     generateSeal(authorKey: Uint8Array, input: Uint8Array, auxData: Uint8Array): Promise<Uint8Array<ArrayBufferLike>>;

package/packages/jam/safrole/bandersnatch-wasm.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bandersnatch-wasm.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/safrole/bandersnatch-wasm.ts"],"names":[],"mappings":"AAEA,qBAAa,gBAAgB;IAC3B,OAAO;WAEM,GAAG;IAKV,UAAU,CAAC,SAAS,EAAE,UAAU,EAAE,SAAS,EAAE,UAAU,EAAE,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,UAAU;IAIjG,iBAAiB,CAAC,IAAI,EAAE,UAAU;IAIlC,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,EAAE,WAAW,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM;IAI1G,YAAY,CAAC,SAAS,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,UAAU;IAI1E,gBAAgB,CAAC,SAAS,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU;CAGhE"}
+{"version":3,"file":"bandersnatch-wasm.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/safrole/bandersnatch-wasm.ts"],"names":[],"mappings":"AAEA,qBAAa,gBAAgB;IAC3B,OAAO;WAEM,GAAG;IAKV,UAAU,CAAC,SAAS,EAAE,UAAU,EAAE,SAAS,EAAE,UAAU,EAAE,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,UAAU;IAIjG,iBAAiB,CACrB,SAAS,EAAE,UAAU,EACrB,UAAU,EAAE,UAAU,EACtB,iBAAiB,EAAE,UAAU,EAC7B,cAAc,EAAE,UAAU,EAC1B,WAAW,EAAE,UAAU,EACvB,oBAAoB,EAAE,UAAU;IAY5B,iBAAiB,CAAC,IAAI,EAAE,UAAU;IAIlC,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,EAAE,WAAW,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM;IAI1G,YAAY,CAAC,SAAS,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,UAAU;IAI1E,gBAAgB,CAAC,SAAS,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU;CAGhE"}

package/packages/jam/safrole/bandersnatch-wasm.js

@@ -6,18 +6,21 @@ export class BandernsatchWasm {
         return new BandernsatchWasm();
     }
     async verifySeal(authorKey, signature, payload, auxData) {
-        return bandersnatchWasm.verify_seal(authorKey, signature, payload, auxData);
+        return bandersnatchWasm.verifySeal(authorKey, signature, payload, auxData);
+    }
+    async verifyHeaderSeals(authorKey, headerSeal, headerSealPayload, unsealedHeader, entropySeal, entropyPayloadPrefix) {
+        return bandersnatchWasm.verifyHeaderSeals(authorKey, headerSeal, headerSealPayload, unsealedHeader, entropySeal, entropyPayloadPrefix);
     }
     async getRingCommitment(keys) {
-        return bandersnatchWasm.ring_commitment(keys);
+        return bandersnatchWasm.ringCommitment(keys);
     }
     async batchVerifyTicket(ringSize, commitment, ticketsData, contextLength) {
-        return bandersnatchWasm.batch_verify_tickets(ringSize, commitment, ticketsData, contextLength);
+        return bandersnatchWasm.batchVerifyTickets(ringSize, commitment, ticketsData, contextLength);
     }
     async generateSeal(authorKey, input, auxData) {
-        return bandersnatchWasm.generate_seal(authorKey, input, auxData);
+        return bandersnatchWasm.generateSeal(authorKey, input, auxData);
     }
     async getVrfOutputHash(authorKey, input) {
-        return bandersnatchWasm.vrf_output_hash(authorKey, input);
+        return bandersnatchWasm.vrfOutputHash(authorKey, input);
     }
 }

package/packages/jam/safrole/safrole-seal.d.ts

@@ -8,8 +8,7 @@ export declare enum SafroleSealError {
     InvalidValidatorIndex = 0,
     InvalidValidator = 1,
     InvalidTicket = 2,
-    IncorrectSeal = 3,
-    IncorrectEntropySource = 4
+    IncorrectSeal = 3
 }
 export type SafroleSealState = Pick<State, "currentValidatorData" | "sealingKeySeries"> & {
     currentEntropy: EntropyHash;
@@ -22,7 +21,6 @@ export declare class SafroleSeal {
      * hence the state is passed as an argument for more control.
      */
     verifyHeaderSeal(headerView: HeaderView, state: SafroleSealState): Promise<Result<EntropyHash, SafroleSealError>>;
-    private verifySeal;
     /** Regular (non-fallback) mode of Safrole. */
     verifySealWithTicket(tickets: PerEpochBlock<Ticket>, timeSlot: TimeSlot, entropy: EntropyHash, validatorData: ValidatorData, headerView: HeaderView): Promise<Result<EntropyHash, SafroleSealError>>;
     /** Fallback mode of Safrole. */

package/packages/jam/safrole/safrole-seal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"safrole-seal.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/safrole/safrole-seal.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,WAAW,EAEhB,KAAK,UAAU,EACf,KAAK,aAAa,EAClB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,6BAA6B,CAAC;AAE1D,OAAO,EAA0B,KAAK,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACjF,OAAO,KAAK,EAAE,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAE7D,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAE1C,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAG1D,oBAAY,gBAAgB;IAC1B,qBAAqB,IAAI;IACzB,gBAAgB,IAAI;IACpB,aAAa,IAAI;IACjB,aAAa,IAAI;IACjB,sBAAsB,IAAI;CAC3B;AAED,MAAM,MAAM,gBAAgB,GAAG,IAAI,CAAC,KAAK,EAAE,sBAAsB,GAAG,kBAAkB,CAAC,GAAG;IACxF,cAAc,EAAE,WAAW,CAAC;CAC7B,CAAC;AAIF,qBAAa,WAAW;IACV,OAAO,CAAC,QAAQ,CAAC,YAAY;gBAAZ,YAAY,GAAE,OAAO,CAAC,gBAAgB,CAA0B;IAC7F;;;OAGG;IACG,gBAAgB,CACpB,UAAU,EAAE,UAAU,EACtB,KAAK,EAAE,gBAAgB,GACtB,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,gBAAgB,CAAC,CAAC;YA6BnC,UAAU;IA0BxB,8CAA8C;IACxC,oBAAoB,CACxB,OAAO,EAAE,aAAa,CAAC,MAAM,CAAC,EAC9B,QAAQ,EAAE,QAAQ,EAClB,OAAO,EAAE,WAAW,EACpB,aAAa,EAAE,aAAa,EAC5B,UAAU,EAAE,UAAU,GACrB,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,gBAAgB,CAAC,CAAC;IA4BjD,gCAAgC;IAC1B,kBAAkB,CACtB,IAAI,EAAE,aAAa,CAAC,eAAe,CAAC,EACpC,QAAQ,EAAE,QAAQ,EAClB,OAAO,EAAE,WAAW,EACpB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,UAAU,GACrB,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,gBAAgB,CAAC,CAAC;CA2BlD"}
+{"version":3,"file":"safrole-seal.d.ts","sourceRoot":"","sources":["../../../../../packages/jam/safrole/safrole-seal.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,WAAW,EAEhB,KAAK,UAAU,EACf,KAAK,aAAa,EAClB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,6BAA6B,CAAC;AAE1D,OAAO,EAA0B,KAAK,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACjF,OAAO,KAAK,EAAE,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAE7D,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAE1C,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAG1D,oBAAY,gBAAgB;IAC1B,qBAAqB,IAAI;IACzB,gBAAgB,IAAI;IACpB,aAAa,IAAI;IACjB,aAAa,IAAI;CAClB;AAED,MAAM,MAAM,gBAAgB,GAAG,IAAI,CAAC,KAAK,EAAE,sBAAsB,GAAG,kBAAkB,CAAC,GAAG;IACxF,cAAc,EAAE,WAAW,CAAC;CAC7B,CAAC;AAIF,qBAAa,WAAW;IACV,OAAO,CAAC,QAAQ,CAAC,YAAY;gBAAZ,YAAY,GAAE,OAAO,CAAC,gBAAgB,CAA0B;IAC7F;;;OAGG;IACG,gBAAgB,CACpB,UAAU,EAAE,UAAU,EACtB,KAAK,EAAE,gBAAgB,GACtB,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,gBAAgB,CAAC,CAAC;IAuBjD,8CAA8C;IACxC,oBAAoB,CACxB,OAAO,EAAE,aAAa,CAAC,MAAM,CAAC,EAC9B,QAAQ,EAAE,QAAQ,EAClB,OAAO,EAAE,WAAW,EACpB,aAAa,EAAE,aAAa,EAC5B,UAAU,EAAE,UAAU,GACrB,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,gBAAgB,CAAC,CAAC;IAmCjD,gCAAgC;IAC1B,kBAAkB,CACtB,IAAI,EAAE,aAAa,CAAC,eAAe,CAAC,EACpC,QAAQ,EAAE,QAAQ,EAClB,OAAO,EAAE,WAAW,EACpB,SAAS,EAAE,aAAa,EACxB,UAAU,EAAE,UAAU,GACrB,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,gBAAgB,CAAC,CAAC;CA8BlD"}