@layr-labs/hourglass-performer/dist/worker/solidityWorker.d.ts

TypeScript SDK for building Hourglass AVS performers

import { TaskRequest, TaskResponse } from '../types/performer';
import { BaseWorker } from './iWorker';
import { AbiCodec } from '../utils/abiUtils';
/**
 * Configuration for SolidityWorker
 */
export interface SolidityWorkerConfig {
    /** Contract ABI JSON */
    abi: any[];
    /** Function name to decode/encode */
    functionName: string;
    /** Auto-detect payload format (default: true) */
    autoDetectPayload?: boolean;
    /** Strict mode - throw on decoding errors (default: false) */
    strictMode?: boolean;
}
/**
 * Type helper for extracting function parameters from TypeChain-generated types
 */
export type ExtractFunctionParams<T, K extends keyof T> = T[K] extends (...args: infer P) => any ? P : never;
/**
 * Type helper for extracting function return type from TypeChain-generated types
 */
export type ExtractFunctionReturn<T, K extends keyof T> = T[K] extends (...args: any[]) => Promise<infer R> ? R : never;
/**
 * SolidityWorker base class with TypeChain integration
 *
 * Generic parameters:
 * - TContract: TypeChain-generated contract interface
 * - TFunction: Function name from the contract
 */
export declare abstract class SolidityWorker<TContract = any, TFunction extends keyof TContract = keyof TContract> extends BaseWorker {
    protected abiCodec: AbiCodec | undefined;
    protected config: Required<SolidityWorkerConfig>;
    constructor(config?: SolidityWorkerConfig);
    /**
     * Validate task with ABI decoding
     */
    validateTask(task: TaskRequest): Promise<void>;
    /**
     * Handle task with automatic ABI decoding/encoding
     */
    handleTask(task: TaskRequest): Promise<TaskResponse>;
    /**
     * Abstract method for handling decoded Solidity parameters
     * Override this method in your implementation
     */
    abstract handleSolidityTask(params: any): Promise<any>;
    /**
     * Simple start method for one-line usage
     */
    start(port?: number): Promise<void>;
    /**
     * Decode task payload using ABI
     */
    protected decodeTaskPayload(payload: Uint8Array): any;
    /**
     * Encode task result using ABI
     */
    protected encodeTaskResult(result: any): Uint8Array;
    /**
     * Map JSON data to ABI function parameters
     */
    protected mapJsonToAbiParams(jsonData: any): any;
    /**
     * Get function information from ABI
     */
    protected getFunctionInfo(): import("../utils/abiUtils").AbiFunctionInfo | undefined;
    /**
     * Get all available functions from ABI
     */
    protected getAllFunctions(): import("../utils/abiUtils").AbiFunctionInfo[];
    /**
     * Manually decode payload (for advanced use cases)
     */
    protected manualDecode(payload: Uint8Array): any;
    /**
     * Manually encode result (for advanced use cases)
     */
    protected manualEncode(result: any): Uint8Array;
}
/**
 * Simplified SolidityWorker for JSON-based configuration
 */
export declare abstract class JsonSolidityWorker extends BaseWorker {
    private abiCodec;
    private functionName;
    constructor(abi: any[], functionName: string);
    handleTask(task: TaskRequest): Promise<TaskResponse>;
    /**
     * Abstract method for handling decoded parameters
     */
    abstract handleDecodedTask(params: any): Promise<any>;
}
/**
 * Utility functions for SolidityWorker
 */
export declare class SolidityWorkerUtils {
    /**
     * Create a simple worker from ABI and handler function
     */
    static createFromAbi<T = any>(abi: any[], functionName: string, handler: (params: T) => Promise<any>): JsonSolidityWorker;
    /**
     * Create a worker with automatic TypeChain integration
     */
    static createTyped<TContract, TFunction extends keyof TContract>(config: SolidityWorkerConfig, handler: (params: ExtractFunctionParams<TContract, TFunction>[0]) => Promise<ExtractFunctionReturn<TContract, TFunction>>): SolidityWorker<TContract, TFunction>;
}
//# sourceMappingURL=solidityWorker.d.ts.map