Services (octez-evm-node-libs.Evm_node_lib

module G = Gas_price

val version_service : 
  ([ `GET ], unit, unit, unit, unit, string) Tezos_rpc.Service.service

val configuration_service : 
  ([ `GET ],
    unit,
    unit,
    unit,
    unit,
    Tezos_base.TzPervasives.Data_encoding.Json.json)
    Tezos_rpc.Service.service

type health_check_query = {

drift_threshold : Z.t;

}

val health_check_service : 
  ([ `GET ], unit, unit, health_check_query, unit, unit)
    Tezos_rpc.Service.service

type Tezos_base.TzPervasives.error +=

| Node_is_bootstrapping
| Node_is_lagging
| Stalled_database

val client_version : string

val configuration_handler : 
  Evm_node_config.Configuration.t ->
  Tezos_base.TzPervasives.Data_encoding.Json.json

val health_check_handler : 
  ?delegate_to:Uri.t ->
  (unit ->
    ('a, Tezos_base.TzPervasives.error Tezos_base.TzPervasives.TzTrace.trace)
      Stdlib.result
      Lwt.t) ->
  health_check_query ->
  unit Tezos_base.TzPervasives.tzresult Lwt.t

val version : Evm_directory.t -> Evm_directory.t

val configuration : 
  Evm_node_config.Configuration.t ->
  Evm_directory.t ->
  Evm_directory.t

val health_check : 
  ?delegate_to:Uri.t ->
  (unit ->
    ('a, Tezos_base.TzPervasives.error Tezos_base.TzPervasives.TzTrace.trace)
      Stdlib.result
      Lwt.t) ->
  Evm_directory.t ->
  Evm_directory.t

val get_block_by_number : 
  full_transaction_object:bool ->
  Evm_node_lib_dev_encoding.Ethereum_types.Block_parameter.t ->
  (module Services_backend_sig.S) ->
  (Transaction_object.t Evm_node_lib_dev_encoding.Ethereum_types.block,
    Tezos_base.TzPervasives.tztrace)
    Stdlib.result
    Lwt.t

val get_block_receipts : 
  Evm_node_lib_dev_encoding.Ethereum_types.Block_parameter.t ->
  (module Services_backend_sig.S) ->
  (Evm_node_lib_dev_encoding.Transaction_receipt.t list,
    Tezos_base.TzPervasives.tztrace)
    Stdlib.result
    Lwt.t

val get_transaction_from_index : 
  Transaction_object.t Evm_node_lib_dev_encoding.Ethereum_types.block ->
  int ->
  (module Services_backend_sig.S) ->
  Transaction_object.t option Tezos_base.TzPervasives.tzresult Lwt.t

val block_transaction_count : 
  'a Evm_node_lib_dev_encoding.Ethereum_types.block ->
  Evm_node_lib_dev_encoding.Ethereum_types.quantity

type sub_stream = {

kind : Evm_node_lib_dev_encoding.Ethereum_types.Subscription.kind;
stream : Transaction_object.t Evm_node_lib_dev_encoding.Ethereum_types.Subscription.output Lwt_stream.t;
stopper : unit -> unit;

}

val subscriptions : 
  (Evm_node_lib_dev_encoding.Ethereum_types.Subscription.id, sub_stream)
    Stdlib.Hashtbl.t

val encode_id : bytes -> string

val make_id : 
  id:string ->
  Evm_node_lib_dev_encoding.Ethereum_types.Subscription.id

val generate_id : unit -> string

val logs_of_filter : 
  Evm_node_lib_dev_encoding.Ethereum_types.Filter.changes ->
  'a Evm_node_lib_dev_encoding.Ethereum_types.Subscription.output option

val filter_from : 
  address:Evm_node_lib_dev_encoding.Ethereum_types.Filter.filter_address option ->
  topics:
    Evm_node_lib_dev_encoding.Ethereum_types.Filter.topic option list option ->
  Evm_node_lib_dev_encoding.Ethereum_types.Filter.t

val filter_logs : 
  bloom_filter:Filter_helpers.bloom_filter ->
  receipt:Evm_node_lib_dev_encoding.Transaction_receipt.t ->
  'a Evm_node_lib_dev_encoding.Ethereum_types.Subscription.output list

val produce_logs_stream : 
  bloom_filter:Filter_helpers.bloom_filter ->
  Evm_node_lib_dev_encoding.Transaction_receipt.t Lwt_stream.t ->
  'a Evm_node_lib_dev_encoding.Ethereum_types.Subscription.output Lwt_stream.t

val eth_subscribe : 
  kind:Evm_node_lib_dev_encoding.Ethereum_types.Subscription.kind ->
  (module Services_backend_sig.S) ->
  (Evm_node_lib_dev_encoding.Ethereum_types.Subscription.id
   * (Transaction_object.t
        Evm_node_lib_dev_encoding.Ethereum_types.Subscription.output
        Lwt_stream.t
      * (unit ->
      unit)),
    Tezos_base.TzPervasives.error list)
    Stdlib.result
    Lwt.t

val eth_unsubscribe : 
  id:Evm_node_lib_dev_encoding.Ethereum_types.Subscription.id ->
  bool

val decode : 
  'a. (module Rpc_encodings.METHOD with type input = 'a) ->
  Tezos_base.TzPervasives.Data_encoding.json ->
  'a

val encode : 
  'a. (module Rpc_encodings.METHOD with type output = 'a) ->
  'a ->
  Tezos_base.TzPervasives.Data_encoding.json

val build : 
  'input 'output. (module Rpc_encodings.METHOD
                    with type input = 'input
                     and type output = 'output) ->
  f:
    ('input option ->
      ('output, Rpc_errors.t) Tezos_base.TzPervasives.Result.t
        Tezos_base.TzPervasives.tzresult
        Lwt.t) ->
  Tezos_base.TzPervasives.Data_encoding.json option ->
  Rpc_encodings.JSONRPC.value Lwt.t

val rpc_ok : 'a -> (('a, 'b) Stdlib.result, 'c) Lwt_result.t

val rpc_error : 'a -> (('b, 'a) Stdlib.result, 'c) Lwt_result.t

val missing_parameter : 
  unit ->
  (('a, Rpc_encodings.JSONRPC.error) Stdlib.result, 'b) Lwt_result.t

val expect_input : 
  'a option ->
  ('a -> (('b, Rpc_encodings.JSONRPC.error) Stdlib.result, 'c) Lwt_result.t) ->
  (('b, Rpc_encodings.JSONRPC.error) Stdlib.result, 'c) Lwt_result.t

val build_with_input : 
  (module Rpc_encodings.METHOD with type input = 'a and type output = 'b) ->
  f:
    ('a ->
      (('b, Rpc_errors.t) Tezos_base.TzPervasives.Result.t,
        Tezos_base.TzPervasives.tztrace)
        Lwt_result.t) ->
  Tezos_base.TzPervasives.Data_encoding.json option ->
  Rpc_encodings.JSONRPC.value Lwt.t

val get_fee_history : 
  Z.t ->
  Evm_node_lib_dev_encoding.Ethereum_types.Block_parameter.t ->
  Evm_node_config.Configuration.t ->
  (module Services_backend_sig.S) ->
  (Evm_node_lib_dev_encoding.Fee_history.t, Tezos_base.TzPervasives.tztrace)
    Stdlib.result
    Lwt.t

val process_trace_result : 
  ('a, Tezos_base.TzPervasives.tztrace) Stdlib.result ->
  (('a, Rpc_encodings.JSONRPC.error) Stdlib.result, 'b) Lwt_result.t

val dispatch_request : 
  is_sequencer:bool ->
  websocket:bool ->
  'f Rpc_types.rpc_server_family ->
  Evm_node_config.Configuration.rpc ->
  Validate.validation_mode ->
  Evm_node_config.Configuration.t ->
  'f Services_backend_sig.tx_container ->
  ((module Services_backend_sig.S) * 'a) ->
  Rpc_encodings.JSONRPC.request ->
  Rpc_encodings.JSONRPC.response Lwt.t

val dispatch_private_request : 
  websocket:bool ->
  'f Rpc_types.rpc_server_family ->
  Evm_node_config.Configuration.rpc ->
  Evm_node_config.Configuration.t ->
  'f Services_backend_sig.tx_container ->
  ((module Services_backend_sig.S) * 'a) ->
  block_production:[> `Single_node ] ->
  Rpc_encodings.JSONRPC.request ->
  Rpc_encodings.JSONRPC.response Lwt.t

val can_process_batch : int -> Evm_node_config.Configuration.limit -> bool

val dispatch_handler : 
  service_name:string ->
  Evm_node_config.Configuration.rpc ->
  'a ->
  'b ->
  'c ->
  ('a ->
    'b ->
    'c ->
    Rpc_encodings.JSONRPC.request ->
    Rpc_encodings.JSONRPC.response Lwt.t) ->
  Rpc_encodings.JSONRPC.request Batch.batched_request ->
  Rpc_encodings.JSONRPC.response Batch.batched_request Lwt.t

val websocket_response_of_response : 
  Rpc_encodings.JSONRPC.response ->
  Rpc_encodings.websocket_response

val encode_subscription_response : 
  Evm_node_lib_dev_encoding.Ethereum_types.Subscription.id ->
  Transaction_object.t
    Evm_node_lib_dev_encoding.Ethereum_types.Subscription.output ->
  Rpc_encodings.Subscription.notification

val empty_stream : 
  Transaction_object.t
    Evm_node_lib_dev_encoding.Ethereum_types.Subscription.output
    Lwt_stream.t
  * (unit ->
  unit)

val empty_sid : Evm_node_lib_dev_encoding.Ethereum_types.Subscription.id

val dispatch_websocket : 
  is_sequencer:bool ->
  'a Rpc_types.rpc_server_family ->
  Evm_node_config.Configuration.rpc ->
  Validate.validation_mode ->
  Evm_node_config.Configuration.t ->
  'a Services_backend_sig.tx_container ->
  ((module Services_backend_sig.S) * 'b) ->
  Rpc_encodings.JSONRPC.request ->
  Rpc_encodings.websocket_response Lwt.t

val dispatch_private_websocket : 
  'a Rpc_types.rpc_server_family ->
  block_production:[> `Single_node ] ->
  Evm_node_config.Configuration.rpc ->
  Evm_node_config.Configuration.t ->
  'a Services_backend_sig.tx_container ->
  ((module Services_backend_sig.S) * 'b) ->
  Rpc_encodings.JSONRPC.request ->
  Rpc_encodings.websocket_response Lwt.t

val generic_dispatch : 
  service_name:string ->
  Evm_node_config.Configuration.rpc ->
  'a ->
  'b ->
  'c ->
  Evm_directory.t ->
  (unit, unit) Resto.Path.t ->
  ('a ->
    'b ->
    'c ->
    Rpc_encodings.JSONRPC.request ->
    Rpc_encodings.JSONRPC.response Lwt.t) ->
  Evm_directory.t

val dispatch_public : 
  is_sequencer:bool ->
  'f Rpc_types.rpc_server_family ->
  Evm_node_config.Configuration.rpc ->
  Validate.validation_mode ->
  Evm_node_config.Configuration.t ->
  'f Services_backend_sig.tx_container ->
  ((module Services_backend_sig.S) * 'a) ->
  Evm_directory.t ->
  Evm_directory.t

val dispatch_private : 
  'f Rpc_types.rpc_server_family ->
  Evm_node_config.Configuration.rpc ->
  block_production:[> `Single_node ] ->
  Evm_node_config.Configuration.t ->
  'f Services_backend_sig.tx_container ->
  ((module Services_backend_sig.S) * 'a) ->
  Evm_directory.t ->
  Evm_directory.t

val generic_websocket_dispatch : 
  Evm_node_config.Configuration.t ->
  'a ->
  'b ->
  Evm_directory.t ->
  string ->
  (Evm_node_config.Configuration.t ->
    'a ->
    'b ->
    Rpc_encodings.websocket_handler) ->
  Evm_directory.t

val dispatch_websocket_public : 
  is_sequencer:bool ->
  'f Rpc_types.rpc_server_family ->
  Evm_node_config.Configuration.rpc ->
  Validate.validation_mode ->
  Evm_node_config.Configuration.t ->
  'f Services_backend_sig.tx_container ->
  ((module Services_backend_sig.S) * 'a) ->
  Evm_directory.t ->
  Evm_directory.t

val dispatch_websocket_private : 
  'f Rpc_types.rpc_server_family ->
  Evm_node_config.Configuration.rpc ->
  block_production:[> `Single_node ] ->
  Evm_node_config.Configuration.t ->
  'f Services_backend_sig.tx_container ->
  ((module Services_backend_sig.S) * 'a) ->
  Evm_directory.t ->
  Evm_directory.t

val directory : 
  is_sequencer:bool ->
  rpc_server_family:'f Rpc_types.rpc_server_family ->
  ?delegate_health_check_to:Uri.t ->
  Evm_node_config.Configuration.rpc ->
  Validate.validation_mode ->
  Evm_node_config.Configuration.t ->
  'f Services_backend_sig.tx_container ->
  ((module Services_backend_sig.S) * 'a) ->
  Evm_directory.t ->
  Evm_directory.t

val private_directory : 
  rpc_server_family:'a Rpc_types.rpc_server_family ->
  Evm_node_config.Configuration.rpc ->
  Evm_node_config.Configuration.t ->
  'a Services_backend_sig.tx_container ->
  ((module Services_backend_sig.S) * 'b) ->
  block_production:[> `Single_node ] ->
  Evm_directory.t