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

val mode_service : 
  ([ `GET ], unit, unit, unit, unit, string) 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 : 
  Evm_node_config.Configuration.t ->
  'a Mode.t ->
  (unit ->
    ('b, Tezos_base.TzPervasives.error Tezos_base.TzPervasives.TzTrace.trace)
      Stdlib.result
      Lwt.t) ->
  health_check_query ->
  (unit, Tezos_base.TzPervasives.error list) Stdlib.result Lwt.t

val evm_mode_handler : 
  Evm_node_config.Configuration.t ->
  'a Mode.t ->
  (string, Tezos_base.TzPervasives.tztrace) Stdlib.result Lwt.t

val version : Evm_directory.t -> Evm_directory.t

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

val evm_mode : 
  Evm_node_config.Configuration.t ->
  'a Mode.t ->
  Evm_directory.t ->
  Evm_directory.t

val health_check : 
  Evm_node_config.Configuration.t ->
  'a Mode.t ->
  (unit ->
    ('b, 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.Transaction_receipt.t) Evm_node_lib_dev_encoding.Ethereum_types.Subscription.output Tezos_base.TzPervasives.tzresult Lwt_stream.t;
stopper : unit -> bool Tezos_base.TzPervasives.tzresult Lwt.t;

}

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 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 ->
  Evm_node_lib_dev_encoding.Ethereum_types.transaction_log list

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

val eth_subscribe_direct : 
  kind:Evm_node_lib_dev_encoding.Ethereum_types.Subscription.kind ->
  (module Services_backend_sig.S) ->
  (((Transaction_object.t, Evm_node_lib_dev_encoding.Transaction_receipt.t)
      Evm_node_lib_dev_encoding.Ethereum_types.Subscription.output,
     'a)
     Stdlib.result
     Lwt_stream.t
   * (unit ->
   (bool, 'b) Stdlib.result Lwt.t),
    Tezos_base.TzPervasives.error list)
    Stdlib.result
    Lwt.t

type 'a proxied_subscription = {

watcher : 'a Lwt_watcher.input;
unsubscribe : unit -> bool Tezos_base.TzPervasives.tzresult Lwt.t;
mutable subscribers : int;

}

module WsClientTable : sig ... end

val proxied_subscriptions : 
  (Transaction_object.t, Evm_node_lib_dev_encoding.Transaction_receipt.t)
    Evm_node_lib_dev_encoding.Ethereum_types.Subscription.output
    Tezos_base.TzPervasives.tzresult
    proxied_subscription
    WsClientTable.t

val create_proxied_subscription : 
  Websocket_client.t ->
  timeout:float ->
  Evm_node_lib_dev_encoding.Ethereum_types.Subscription.kind ->
  ((Transaction_object.t, Evm_node_lib_dev_encoding.Transaction_receipt.t)
     Evm_node_lib_dev_encoding.Ethereum_types.Subscription.output
     Tezos_base.TzPervasives.tzresult
     proxied_subscription,
    Tezos_base.TzPervasives.tztrace)
    Stdlib.result
    Lwt.t

val get_proxied_subscription : 
  Websocket_client.t ->
  timeout:float ->
  Evm_node_lib_dev_encoding.Ethereum_types.Subscription.kind ->
  ((Transaction_object.t, Evm_node_lib_dev_encoding.Transaction_receipt.t)
     Evm_node_lib_dev_encoding.Ethereum_types.Subscription.output
     Tezos_base.TzPervasives.tzresult
     proxied_subscription,
    Tezos_base.TzPervasives.tztrace)
    Stdlib.result
    Lwt.t

val eth_subscribe_rpc_mode : 
  timeout:float ->
  kind:Evm_node_lib_dev_encoding.Ethereum_types.Subscription.kind ->
  Websocket_client.t ->
  (module Services_backend_sig.S) ->
  ((Transaction_object.t, Evm_node_lib_dev_encoding.Transaction_receipt.t)
     Evm_node_lib_dev_encoding.Ethereum_types.Subscription.output
     Tezos_base.TzPervasives.tzresult
     Lwt_stream.t
   * (unit ->
   bool Tezos_base.TzPervasives.tzresult Lwt.t),
    Tezos_base.TzPervasives.tztrace)
    Stdlib.result
    Lwt.t

val eth_subscribe : 
  Evm_node_config.Configuration.t ->
  'f Mode.t ->
  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.Transaction_receipt.t)
        Evm_node_lib_dev_encoding.Ethereum_types.Subscription.output
        Tezos_base.TzPervasives.tzresult
        Lwt_stream.t
      * (unit ->
      bool Tezos_base.TzPervasives.tzresult Lwt.t)),
    Tezos_base.TzPervasives.tztrace)
    Stdlib.result
    Lwt.t

val eth_unsubscribe : 
  id:Evm_node_lib_dev_encoding.Ethereum_types.Subscription.id ->
  bool Tezos_base.TzPervasives.tzresult Lwt.t

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 direct_rpc_value : 
  Rpc_encodings.JSONRPC.value ->
  Rpc_encodings.JSONRPC.return_value

val lazy_rpc_value : 
  Rpc_encodings.JSONRPC.value Lwt.t ->
  Rpc_encodings.JSONRPC.return_value

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.return_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.return_value Lwt.t

val build_with_lazy_output : 
  '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.tzresult
        Lwt.t) ->
  Tezos_base.TzPervasives.Data_encoding.json option ->
  Rpc_encodings.JSONRPC.return_value Lwt.t

val build_with_input_and_lazy_output : 
  (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.tzresult
         Lwt.t,
        Tezos_base.TzPervasives.tztrace)
        Lwt_result.t) ->
  Tezos_base.TzPervasives.Data_encoding.json option ->
  Rpc_encodings.JSONRPC.return_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 inject_rpc_call : 
  Evm_node_config.Configuration.t ->
  Rpc_encodings.JSONRPC.request ->
  (module Rpc_encodings.METHOD with type input = 'a and type output = 'b) ->
  Mode.local_node_info ->
  (('b, Rpc_encodings.JSONRPC.error) Stdlib.result,
    Tezos_base.TzPervasives.tztrace)
    Stdlib.result
    Lwt.t

val process_based_on_mode : 
  'f Mode.t ->
  on_rpc:(Mode.local_node_info -> 'a) ->
  on_stateful_evm:
    ((module Services_backend_sig.Tx_container
       with type address = Evm_node_lib_dev_encoding.Ethereum_types.address
        and type transaction_object = Transaction_object.t) ->
      'a) ->
  on_stateful_michelson:
    ((module Services_backend_sig.Tx_container
       with type transaction_object =
         Evm_node_lib_dev_tezlink.Tezos_types.Operation.t) ->
      'a) ->
  'a

val wait_confirmation_callback : 
  ((unit, string) Stdlib.result, 'a) Stdlib.result Lwt.u ->
  [< `Accepted | `Confirmed | `Dropped | `Refused ] ->
  unit Lwt.t

val send_raw_transaction : 
  Evm_node_config.Configuration.t ->
  'f Mode.t ->
  ?wait_confirmation_wakener:
    (unit, string) Stdlib.result Tezos_base.TzPervasives.tzresult Lwt.u ->
  Evm_node_lib_dev_encoding.Ethereum_types.hex ->
  ((Evm_node_lib_dev_encoding.Ethereum_types.hash, Rpc_encodings.JSONRPC.error)
     Stdlib.result,
    Tezos_base.TzPervasives.tztrace)
    Stdlib.result
    Lwt.t

val dispatch_request : 
  websocket:bool ->
  'f Rpc_types.rpc_server_family ->
  Evm_node_config.Configuration.rpc ->
  Evm_node_config.Configuration.t ->
  'f Mode.t ->
  ((module Services_backend_sig.S) * 'a) ->
  Rpc_encodings.JSONRPC.request ->
  Rpc_encodings.JSONRPC.return_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 Mode.t ->
  ((module Services_backend_sig.S) * 'a) ->
  block_production:[> `Single_node ] ->
  Rpc_encodings.JSONRPC.request ->
  Rpc_encodings.JSONRPC.return_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 ->
  tick:(unit -> 'b Lwt.t) ->
  ('a ->
    Rpc_encodings.JSONRPC.request ->
    Rpc_encodings.JSONRPC.return_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.Transaction_receipt.t)
     Evm_node_lib_dev_encoding.Ethereum_types.Subscription.output,
    Tezos_base.TzPervasives.tztrace)
    Stdlib.result ->
  Rpc_encodings.Subscription.notification

val empty_stream : 
  (Transaction_object.t, Evm_node_lib_dev_encoding.Transaction_receipt.t)
    Evm_node_lib_dev_encoding.Ethereum_types.Subscription.output
    Tezos_base.TzPervasives.tzresult
    Lwt_stream.t
  * (unit ->
  (bool, 'a) Stdlib.result Lwt.t)

val empty_sid : Evm_node_lib_dev_encoding.Ethereum_types.Subscription.id

val dispatch_websocket : 
  'a Rpc_types.rpc_server_family ->
  Evm_node_config.Configuration.rpc ->
  Evm_node_config.Configuration.t ->
  'a Mode.t ->
  ((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 Mode.t ->
  ((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 ->
  Evm_directory.t ->
  (unit, unit) Resto.Path.t ->
  tick:(unit -> 'b Lwt.t) ->
  ('a ->
    Rpc_encodings.JSONRPC.request ->
    Rpc_encodings.JSONRPC.return_response Lwt.t) ->
  Evm_directory.t

val dispatch_public : 
  'f Rpc_types.rpc_server_family ->
  Evm_node_config.Configuration.rpc ->
  Evm_node_config.Configuration.t ->
  'f Mode.t ->
  ((module Services_backend_sig.S) * 'a) ->
  Evm_directory.t ->
  tick:(unit -> 'b Lwt.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 Mode.t ->
  ((module Services_backend_sig.S) * 'a) ->
  Evm_directory.t ->
  tick:(unit -> 'b Lwt.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 : 
  'a Rpc_types.rpc_server_family ->
  Evm_node_config.Configuration.rpc ->
  Evm_node_config.Configuration.t ->
  'a Mode.t ->
  ((module Services_backend_sig.S) * 'b) ->
  Evm_directory.t ->
  Evm_directory.t

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

val directory : 
  rpc_server_family:'f Rpc_types.rpc_server_family ->
  'f Mode.t ->
  Evm_node_config.Configuration.rpc ->
  Evm_node_config.Configuration.t ->
  ((module Services_backend_sig.S) * 'a) ->
  Evm_directory.t ->
  tick:(unit -> 'b Lwt.t) ->
  Evm_directory.t

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