@typeberry/lib 0.5.0-2b5df1a → 0.5.0-3439612

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;
@@ -2723,35 +2767,35 @@ declare class Header extends WithDebug {
      *
      * In case of the genesis block, the hash will be zero.
      */
-    parentHeaderHash: HeaderHash;
+    readonly parentHeaderHash: HeaderHash;
     /** `H_r`: The state trie root hash before executing that block. */
-    priorStateRoot: StateRootHash;
+    readonly priorStateRoot: StateRootHash;
     /** `H_x`: The hash of block extrinsic. */
-    extrinsicHash: ExtrinsicHash;
+    readonly extrinsicHash: ExtrinsicHash;
     /** `H_t`: JAM time-slot index. */
-    timeSlotIndex: TimeSlot;
+    readonly timeSlotIndex: TimeSlot;
     /**
      * `H_e`: Key and entropy relevant to the following epoch in case the ticket
      *        contest does not complete adequately.
      */
-    epochMarker: EpochMarker | null;
+    readonly epochMarker: EpochMarker | null;
     /**
      * `H_w`: Winning tickets provides the series of 600 slot sealing "tickets"
      *        for the next epoch.
      */
-    ticketsMarker: TicketsMarker | null;
+    readonly ticketsMarker: TicketsMarker | null;
     /** `H_i`: Block author's index in the current validator set. */
-    bandersnatchBlockAuthorIndex: ValidatorIndex;
+    readonly bandersnatchBlockAuthorIndex: ValidatorIndex;
     /** `H_v`: Entropy-yielding VRF signature. */
-    entropySource: BandersnatchVrfSignature;
+    readonly entropySource: BandersnatchVrfSignature;
     /** `H_o`: Sequence of keys of newly misbehaving validators. */
-    offendersMarker: Ed25519Key[];
+    readonly offendersMarker: Ed25519Key[];
     /**
      * `H_s`: Block seal.
      *
      * https://graypaper.fluffylabs.dev/#/579bd12/0d0c010d1101
      */
-    seal: BandersnatchVrfSignature;
+    readonly seal: BandersnatchVrfSignature;
     private constructor();
     /** Create an empty header with some dummy values. */
     static empty(): Header;
@@ -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();
 }