lisk-framework/dist-node/state_machine/types.d.ts

Lisk blockchain application platform

/// <reference types="node" />
import { Transaction } from '@liskhq/lisk-chain';
import { Schema } from '@liskhq/lisk-codec';
import { IterateOptions } from '@liskhq/lisk-db';
import { Logger } from '../logger';
import { EventQueue } from './event_queue';
export interface ImmutableSubStore {
    get(key: Buffer): Promise<Buffer>;
    getWithSchema<T>(key: Buffer, schema: Schema): Promise<T>;
    has(key: Buffer): Promise<boolean>;
    iterate(input: IterateOptions): Promise<{
        key: Buffer;
        value: Buffer;
    }[]>;
    iterateWithSchema<T>(input: IterateOptions, schema: Schema): Promise<{
        key: Buffer;
        value: T;
    }[]>;
}
export interface SubStore extends ImmutableSubStore {
    del(key: Buffer): Promise<void>;
    set(key: Buffer, value: Buffer): Promise<void>;
    setWithSchema(key: Buffer, value: object, schema: Schema): Promise<void>;
    createSnapshot(): number;
    restoreSnapshot(snapshotID: number): void;
}
export interface ImmutableStateStore {
    getStore: (moduleID: Buffer, storePrefix: Buffer) => ImmutableSubStore;
}
export interface StateStore {
    getStore: (moduleID: Buffer, storePrefix: Buffer) => SubStore;
    createSnapshot(): number;
    restoreSnapshot(snapshotID: number): void;
}
export interface ImmutableMethodContext {
    getStore: (moduleID: Buffer, storePrefix: Buffer) => ImmutableSubStore;
}
export interface MethodContext {
    getStore: (moduleID: Buffer, storePrefix: Buffer) => SubStore;
    eventQueue: EventQueue;
    contextStore: Map<string, unknown>;
}
export declare enum VerifyStatus {
    FAIL = -1,
    OK = 1,
    PENDING = 0
}
export interface BlockHeader {
    version: number;
    height: number;
    timestamp: number;
    previousBlockID: Buffer;
    generatorAddress: Buffer;
    maxHeightPrevoted: number;
    maxHeightGenerated: number;
    impliesMaxPrevotes: boolean;
    aggregateCommit: {
        height: number;
        aggregationBits: Buffer;
        certificateSignature: Buffer;
    };
}
export interface BlockAssets {
    getAsset: (module: string) => Buffer | undefined;
}
export interface WritableBlockAssets extends BlockAssets {
    setAsset: (module: string, value: Buffer) => void;
}
export interface VerificationResult {
    status: VerifyStatus;
    error?: Error;
}
export interface TransactionVerifyContext {
    chainID: Buffer;
    logger: Logger;
    header: {
        timestamp: number;
        height: number;
    };
    transaction: Transaction;
    stateStore: ImmutableStateStore;
    contextStore: Map<string, unknown>;
    getMethodContext: () => ImmutableMethodContext;
    getStore: (moduleID: Buffer, storePrefix: Buffer) => ImmutableSubStore;
}
export interface CommandVerifyContext<T = undefined> {
    logger: Logger;
    chainID: Buffer;
    header: {
        timestamp: number;
        height: number;
    };
    transaction: Transaction;
    params: T;
    getMethodContext: () => ImmutableMethodContext;
    getStore: (moduleID: Buffer, storePrefix: Buffer) => ImmutableSubStore;
    stateStore: ImmutableStateStore;
    contextStore: Map<string, unknown>;
}
export interface CommandExecuteContext<T = undefined> {
    logger: Logger;
    chainID: Buffer;
    eventQueue: EventQueue;
    stateStore: StateStore;
    contextStore: Map<string, unknown>;
    header: BlockHeader;
    assets: BlockAssets;
    transaction: Transaction;
    params: T;
    getMethodContext: () => MethodContext;
    getStore: (moduleID: Buffer, storePrefix: Buffer) => SubStore;
}
export interface GenesisBlockExecuteContext {
    logger: Logger;
    eventQueue: EventQueue;
    stateStore: StateStore;
    getMethodContext: () => MethodContext;
    getStore: (moduleID: Buffer, storePrefix: Buffer) => SubStore;
    header: BlockHeader;
    assets: BlockAssets;
    setNextValidators: (preCommitThreshold: bigint, certificateThreshold: bigint, validators: Validator[]) => void;
    chainID: Buffer;
}
export interface TransactionExecuteContext {
    logger: Logger;
    chainID: Buffer;
    eventQueue: EventQueue;
    stateStore: StateStore;
    contextStore: Map<string, unknown>;
    getMethodContext: () => MethodContext;
    getStore: (moduleID: Buffer, storePrefix: Buffer) => SubStore;
    header: BlockHeader;
    assets: BlockAssets;
    transaction: Transaction;
}
export interface BlockVerifyContext {
    logger: Logger;
    chainID: Buffer;
    stateStore: ImmutableStateStore;
    contextStore: Map<string, unknown>;
    getMethodContext: () => ImmutableMethodContext;
    getStore: (moduleID: Buffer, storePrefix: Buffer) => ImmutableSubStore;
    header: BlockHeader;
    assets: BlockAssets;
}
export interface BlockExecuteContext {
    logger: Logger;
    chainID: Buffer;
    eventQueue: EventQueue;
    stateStore: StateStore;
    getMethodContext: () => MethodContext;
    getStore: (moduleID: Buffer, storePrefix: Buffer) => SubStore;
    contextStore: Map<string, unknown>;
    header: BlockHeader;
    assets: BlockAssets;
}
export interface Validator {
    address: Buffer;
    bftWeight: bigint;
    generatorKey: Buffer;
    blsKey: Buffer;
}
export interface NextValidatorsSetter {
    setNextValidators: (preCommitThreshold: bigint, certificateThreshold: bigint, validators: Validator[]) => void;
}
export type BlockAfterExecuteContext = BlockExecuteContext & NextValidatorsSetter & {
    transactions: ReadonlyArray<Transaction>;
};
export interface InsertAssetContext {
    logger: Logger;
    chainID: Buffer;
    getMethodContext: () => MethodContext;
    stateStore: ImmutableStateStore;
    contextStore: Map<string, unknown>;
    getStore: (moduleID: Buffer, storePrefix: Buffer) => ImmutableSubStore;
    header: BlockHeader;
    assets: WritableBlockAssets;
    getOffchainStore: (moduleID: Buffer, storePrefix: Buffer) => SubStore;
    getFinalizedHeight(): number;
}