@typeberry/lib 0.5.0-2b5df1a → 0.5.0-4da816c

package/index.d.ts

@@ -2005,21 +2005,11 @@ declare namespace index$v {
 }
 
 declare namespace bandersnatch_d_exports {
-  export { batch_verify_tickets, __wbg_init$2 as default, derive_public_key, initSync$2 as initSync, ring_commitment, verify_seal };
+  export { batch_verify_tickets, __wbg_init$2 as default, derive_public_key, generate_seal, initSync$2 as initSync, ring_commitment, verify_seal, vrf_output_hash };
   export type { InitInput$2 as InitInput, InitOutput$2 as InitOutput, SyncInitInput$2 as SyncInitInput };
 }
 /* tslint:disable */
 /* eslint-disable */
-/**
- * Generate ring commitment given concatenation of ring keys.
- */
-declare function ring_commitment(keys: Uint8Array): Uint8Array;
-/**
- * Derive Private and Public Key from Seed
- *
- * returns: `Vec<u8>` containing the exit (1 byte) status followed by the (32 bytes) public key
- */
-declare function derive_public_key(seed: Uint8Array): Uint8Array;
 /**
  * Seal verification as defined in:
  * https://graypaper.fluffylabs.dev/#/68eaa1f/0eff000eff00?v=0.6.4
@@ -2034,13 +2024,67 @@ declare function verify_seal(signer_key: Uint8Array, seal_data: Uint8Array, payl
  * NOTE: the aux_data of VRF function is empty!
  */
 declare function batch_verify_tickets(ring_size: number, commitment: Uint8Array, tickets_data: Uint8Array, vrf_input_data_len: number): Uint8Array;
+/**
+ * Generate seal that is verifiable using `verify_seal` function.
+ *
+ * # Arguments
+ * * `secret_seed` - Seed used to derive the secret key
+ * * `input` - VRF input data
+ * * `aux_data` - Auxiliary data for the VRF proof
+ *
+ * # Returns
+ * A byte vector with the following format:
+ * - On success (97 bytes):
+ *   - Byte 0: Status code `0` (RESULT_OK)
+ *   - Bytes 1-32: Serialized VRF output (32 bytes, compressed) NOTE: not output hash!
+ *   - Bytes 33-96: Serialized IETF VRF proof (64 bytes, compressed)
+ * - On error (1 byte):
+ *   - Byte 0: Status code `1` (RESULT_ERR)
+ *
+ * Returns an error if the input cannot be converted to a valid VRF input point
+ * or if serialization of the output or proof fails.
+ */
+declare function generate_seal(secret_seed: Uint8Array, input: Uint8Array, aux_data: Uint8Array): Uint8Array;
+/**
+ * Derive Private and Public Key from Seed
+ *
+ * returns: `Vec<u8>` containing the exit (1 byte) status followed by the (32 bytes) public key
+ */
+declare function derive_public_key(seed: Uint8Array): Uint8Array;
+/**
+ * Compute VRF output hash from a secret seed and input data.
+ *
+ * This function derives a deterministic VRF output hash without generating a proof.
+ * Unlike `generate_seal`, this produces only the output hash, not a verifiable signature.
+ *
+ * # Arguments
+ * * `secret_seed` - Seed used to derive the secret key
+ * * `input` - VRF input data to be hashed
+ *
+ * # Returns
+ * A byte vector with the following format:
+ * - On success (33 bytes):
+ *   - Byte 0: Status code `0` (RESULT_OK)
+ *   - Bytes 1-32: VRF output hash (32 bytes)
+ * - On error (1 byte):
+ *   - Byte 0: Status code `1` (RESULT_ERR)
+ *
+ * Returns an error if the input cannot be converted to a valid VRF input point.
+ */
+declare function vrf_output_hash(secret_seed: Uint8Array, input: Uint8Array): Uint8Array;
+/**
+ * Generate ring commitment given concatenation of ring keys.
+ */
+declare function ring_commitment(keys: Uint8Array): Uint8Array;
 type InitInput$2 = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
 interface InitOutput$2 {
   readonly memory: WebAssembly.Memory;
-  readonly ring_commitment: (a: number, b: number) => [number, number];
+  readonly batch_verify_tickets: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
   readonly derive_public_key: (a: number, b: number) => [number, number];
+  readonly generate_seal: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
+  readonly ring_commitment: (a: number, b: number) => [number, number];
   readonly verify_seal: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => [number, number];
-  readonly batch_verify_tickets: (a: number, b: number, c: number, d: number, e: number, f: number) => [number, number];
+  readonly vrf_output_hash: (a: number, b: number, c: number, d: number) => [number, number];
   readonly __wbindgen_export_0: WebAssembly.Table;
   readonly __wbindgen_malloc: (a: number, b: number) => number;
   readonly __wbindgen_free: (a: number, b: number, c: number) => void;
@@ -4264,10 +4308,8 @@ declare class JipChainSpec extends WithDebug {
 
 /** Block authorship options. */
 declare class AuthorshipOptions {
-    /** Use fake seal verification instead of running bandersnatch. */
-    readonly omitSealVerification: boolean;
     static fromJson: FromJsonWithParser<unknown, AuthorshipOptions>;
-    static new({ omit_seal_verification }: JsonObject<AuthorshipOptions>): AuthorshipOptions;
+    static new(): AuthorshipOptions;
     private constructor();
 }
 
@@ -9804,7 +9846,7 @@ declare class OnChain {
     /** Pre-populate things worth caching for the next epoch. */
     prepareForNextEpoch(): Promise<void>;
     private verifySeal;
-    transition(block: BlockView, headerHash: HeaderHash, omitSealVerification?: boolean): Promise<Result<Ok, StfError>>;
+    transition(block: BlockView, headerHash: HeaderHash): Promise<Result<Ok, StfError>>;
     private getUsedAuthorizerHashes;
 }
 
@@ -10084,8 +10126,8 @@ declare class Importer {
     constructor(spec: ChainSpec, pvm: PvmBackend, hasher: TransitionHasher, logger: Logger, blocks: BlocksDb, states: StatesDb<SerializedState<LeafDb>>);
     /** Do some extra work for preparation for the next epoch. */
     prepareForNextEpoch(): Promise<void>;
-    importBlockWithStateRoot(block: BlockView, omitSealVerification: boolean): Promise<Result<StateRootHash, ImporterError>>;
-    importBlock(block: BlockView, omitSealVerification: boolean): Promise<Result<WithHash<HeaderHash, HeaderView>, ImporterError>>;
+    importBlockWithStateRoot(block: BlockView): Promise<Result<StateRootHash, ImporterError>>;
+    importBlock(block: BlockView): Promise<Result<WithHash<HeaderHash, HeaderView>, ImporterError>>;
     private importBlockInternal;
     getBestStateRootHash(): (OpaqueHash & WithOpaque<"StateRootHash">) | null;
     getBestBlockHash(): OpaqueHash & WithOpaque<"HeaderHash">;
@@ -10432,13 +10474,11 @@ declare const protocol: LousyProtocol<{
 type ImporterInternal = Internal<typeof protocol>;
 type ImporterApi = Api<typeof protocol>;
 declare class ImporterConfig {
-    readonly omitSealVerification: boolean;
     readonly pvm: PvmBackend;
     static Codec: Descriptor<ImporterConfig, ViewOf<ImporterConfig, {
-        omitSealVerification: Descriptor<boolean, boolean>;
         pvm: Descriptor<PvmBackend, U8>;
     }>>;
-    static create({ omitSealVerification, pvm }: CodecRecord<ImporterConfig>): ImporterConfig;
+    static create({ pvm }: CodecRecord<ImporterConfig>): ImporterConfig;
     private constructor();
 }