lisk-framework/dist-node/modules/random/schemas.d.ts

Lisk blockchain application platform

import { UsedHashOnion } from './stores/used_hash_onions';
interface AddressRequest {
    address: string;
}
export interface SetHashOnionRequest extends AddressRequest {
    seed?: string | undefined;
    count?: number | undefined;
    distance?: number | undefined;
    hashes?: string[] | undefined;
}
export declare const hashOnionSchema: {
    $id: string;
    type: string;
    title: string;
    required: string[];
    properties: {
        address: {
            type: string;
            format: string;
        };
        seed: {
            type: string;
            format: string;
            minLength: number;
            maxLength: number;
        };
        count: {
            type: string;
            minimum: number;
            maximum: number;
        };
        distance: {
            type: string;
            minimum: number;
        };
        hashes: {
            type: string;
            minItems: number;
            items: {
                type: string;
                format: string;
                minLength: number;
                maxLength: number;
            };
        };
    };
};
interface Seeds extends AddressRequest {
    seed: string;
    count: number;
    distance: number;
}
export interface GetSeedsResponse {
    seeds: Seeds[];
}
export type HasHashOnionRequest = AddressRequest;
export interface HasHashOnionResponse {
    hasSeed: boolean;
    remaining: number;
}
export declare const addressSchema: {
    $id: string;
    type: string;
    required: string[];
    properties: {
        address: {
            type: string;
            format: string;
        };
    };
};
export declare const hasHashOnionResponseSchema: {
    $id: string;
    type: string;
    required: string[];
    properties: {
        hasSeed: {
            type: string;
        };
        remaining: {
            type: string;
            format: string;
        };
    };
};
export interface GetHashOnionUsageResponse {
    readonly usedHashOnions: UsedHashOnion[];
    seed: string;
}
export type GetHashOnionUsageRequest = AddressRequest;
export declare const getHashOnionUsageResponse: {
    $id: string;
    type: string;
    required: string[];
    properties: {
        usedHashOnions: {
            type: string;
            items: {
                type: string;
                required: string[];
                properties: {
                    count: {
                        type: string;
                        format: string;
                    };
                    height: {
                        type: string;
                        format: string;
                    };
                };
            };
        };
        seed: {
            type: string;
            format: string;
        };
    };
};
export interface SetHashOnionUsageRequest extends AddressRequest {
    usedHashOnions: UsedHashOnion[];
}
export declare const setHashOnionUsageRequest: {
    $id: string;
    type: string;
    required: string[];
    properties: {
        address: {
            type: string;
            format: string;
        };
        usedHashOnions: {
            type: string;
            items: {
                type: string;
                required: string[];
                properties: {
                    count: {
                        type: string;
                        format: string;
                    };
                    height: {
                        type: string;
                        format: string;
                    };
                };
            };
        };
    };
};
export declare const randomModuleConfig: {
    $id: string;
    type: string;
    required: string[];
    properties: {
        maxLengthReveals: {
            type: string;
            format: string;
        };
    };
};
export declare const randomModuleGeneratorConfig: {
    $id: string;
    type: string;
    required: never[];
    properties: {
        hashOnions: {
            type: string;
            items: {
                type: string;
                required: string[];
                properties: {
                    address: {
                        type: string;
                        format: string;
                    };
                    hashOnion: {
                        type: string;
                        required: string[];
                        properties: {
                            count: {
                                type: string;
                            };
                            distance: {
                                type: string;
                            };
                            hashes: {
                                type: string;
                                items: {
                                    type: string;
                                    format: string;
                                };
                            };
                        };
                    };
                };
            };
        };
    };
};
export declare const blockHeaderAssetRandomModule: {
    $id: string;
    type: string;
    properties: {
        seedReveal: {
            dataType: string;
            fieldNumber: number;
            minLength: number;
            maxLength: number;
        };
    };
    required: string[];
};
export declare const registeredHashOnionsStoreSchema: {
    title: string;
    $id: string;
    type: string;
    required: string[];
    properties: {
        registeredHashOnions: {
            type: string;
            fieldNumber: number;
            items: {
                type: string;
                required: string[];
                properties: {
                    address: {
                        dataType: string;
                        format: string;
                        fieldNumber: number;
                    };
                    seedHash: {
                        dataType: string;
                        fieldNumber: number;
                    };
                };
            };
        };
    };
};
export declare const isSeedRevealValidRequestSchema: {
    $id: string;
    type: string;
    required: string[];
    properties: {
        generatorAddress: {
            type: string;
            format: string;
        };
        seedReveal: {
            type: string;
            format: string;
        };
    };
};
export declare const isSeedRevealValidResponseSchema: {
    $id: string;
    type: string;
    required: string[];
    properties: {
        valid: {
            type: string;
        };
    };
};
export {};