Type Alias trace_call_with_config

trace_call_with_config: RuntimeDescriptor<
    [
        tx: {
            access_list?: { address: SizedHex<20>; storage_keys: SizedHex<32>[] }[];
            authorization_list: {
                address: SizedHex<20>;
                chain_id: FixedSizeArray<4, bigint>;
                nonce: FixedSizeArray<4, bigint>;
                r: FixedSizeArray<4, bigint>;
                s: FixedSizeArray<4, bigint>;
                y_parity: FixedSizeArray<4, bigint>;
            }[];
            blob_versioned_hashes: SizedHex<32>[];
            blobs: Uint8Array[];
            chain_id?: FixedSizeArray<4, bigint>;
            from?: SizedHex<20>;
            gas?: FixedSizeArray<4, bigint>;
            gas_price?: FixedSizeArray<4, bigint>;
            input: { data?: Uint8Array; input?: Uint8Array };
            max_fee_per_blob_gas?: FixedSizeArray<4, bigint>;
            max_fee_per_gas?: FixedSizeArray<4, bigint>;
            max_priority_fee_per_gas?: FixedSizeArray<4, bigint>;
            nonce?: FixedSizeArray<4, bigint>;
            "r#type"?: number;
            to?: SizedHex<20>;
            value?: FixedSizeArray<4, bigint>;
        },
        tracer_type: Enum<
            {
                CallTracer?: { only_top_call: boolean; with_logs: boolean };
                ExecutionTracer?: {
                    disable_stack: boolean;
                    disable_storage: boolean;
                    disable_syscall_details: boolean;
                    enable_memory: boolean;
                    enable_return_data: boolean;
                    limit?: bigint;
                    memory_word_limit: number;
                };
                PrestateTracer?: {
                    diff_mode: boolean;
                    disable_code: boolean;
                    disable_storage: boolean;
                };
            },
        >,
        config: | [
            SizedHex<20>,
            {
                balance?: FixedSizeArray<(...), (...)>;
                code?: Uint8Array;
                move_precompile_to_address?: SizedHex<(...)>;
                nonce?: FixedSizeArray<(...), (...)>;
                storage?: Enum<(...)>;
            },
        ][]
        | undefined,
    ],
    ResultPayload<
        Enum<
            {
                Call: {
                    call_type: Enum<
                        {
                            Call: undefined;
                            Create: undefined;
                            Create2: undefined;
                            DelegateCall: undefined;
                            Selfdestruct: undefined;
                            StaticCall: undefined;
                        },
                    >;
                    calls: __Circular[];
                    child_call_count: number;
                    error?: string;
                    from: SizedHex<20>;
                    gas: bigint;
                    gas_used: bigint;
                    input: Uint8Array;
                    logs: {
                        address: SizedHex<20>;
                        data: Uint8Array;
                        position: number;
                        topics: SizedHex<32>[];
                    }[];
                    output: Uint8Array;
                    revert_reason?: string;
                    to: SizedHex<20>;
                    value?: FixedSizeArray<4, bigint>;
                };
                Execution: {
                    base_call_weight: { proof_size: bigint; ref_time: bigint };
                    failed: boolean;
                    gas: bigint;
                    return_value: Uint8Array;
                    struct_logs: {
                        depth: number;
                        error?: string;
                        gas: bigint;
                        gas_cost: bigint;
                        kind: Enum<
                            {
                                EVMOpcode: {
                                    memory: (...)[];
                                    op: number;
                                    pc: number;
                                    stack: (...)[];
                                    storage?: (...) | (...);
                                };
                                PVMSyscall: { args: (...)[]; op: number; returned?: (...) | (...) };
                            },
                        >;
                        return_data: Uint8Array;
                        weight_cost: { proof_size: bigint; ref_time: bigint };
                    }[];
                    weight_consumed: { proof_size: bigint; ref_time: bigint };
                };
                Prestate: Enum<
                    {
                        DiffMode: {
                            post: [
                                SizedHex<20>,
                                {
                                    balance?: (...) | (...);
                                    code?: (...) | (...);
                                    nonce?: (...) | (...);
                                    storage: (...)[];
                                },
                            ][];
                            pre: [
                                SizedHex<20>,
                                {
                                    balance?: (...) | (...);
                                    code?: (...) | (...);
                                    nonce?: (...) | (...);
                                    storage: (...)[];
                                },
                            ][];
                        };
                        Prestate: [
                            SizedHex<20>,
                            { balance?: ...; code?: ...; nonce?: ...; storage: [(...), (...)][] },
                        ][];
                    },
                >;
            },
        >,
        Enum<{ Data: Uint8Array; Message: string }>,
    >,
>