Skip to content

packages.valory.connections.abci.connection

Connection to interact with an ABCI server.

DecodeVarintError Objects

class DecodeVarintError(Exception)

This exception is raised when an error occurs while decoding a varint.

EncodeVarintError Objects

class EncodeVarintError(Exception)

This exception is raised when an error occurs while encoding a varint.

TooLargeVarint Objects

class TooLargeVarint(Exception)

This exception is raised when a message with varint exceeding the max size is received.

__init__

def __init__(received_size: int, max_size: int = MAX_READ_IN_BYTES)

Initialize the exception object.

Arguments:

  • received_size: the received size.
  • max_size: the maximum amount the connection supports.

ShortBufferLengthError Objects

class ShortBufferLengthError(Exception)

This exception is raised when the buffer length is shorter than expected.

__init__

def __init__(expected_length: int, data: bytes)

Initialize the exception object.

Arguments:

  • expected_length: the expected length to be read
  • data: the data actually read

_TendermintABCISerializer Objects

class _TendermintABCISerializer()

(stateless) utility class to encode/decode messages for the communication with Tendermint.

encode_varint

@classmethod
def encode_varint(cls, number: int) -> bytes

Encode a number in varint coding.

decode_varint

@classmethod
async def decode_varint(cls, buffer: asyncio.StreamReader, max_length: int = MAX_VARINT_BYTES) -> int

Decode a number from its varint coding.

Arguments:

  • buffer: the buffer to read from.
  • max_length: the max number of bytes that can be read.

Returns:

the decoded int.

write_message

@classmethod
def write_message(cls, message: Response) -> bytes

Write a message in a buffer.

VarintMessageReader Objects

class VarintMessageReader()

Varint message reader.

__init__

def __init__(reader: asyncio.StreamReader) -> None

Initialize the reader.

read_next_message

async def read_next_message() -> bytes

Read next message.

read_until

async def read_until(n: int) -> bytes

Wait until n bytes are read from the stream.

ABCIApplicationServicer Objects

class ABCIApplicationServicer(types_pb2_grpc.ABCIApplicationServicer)

Implements the gRPC servicer (handler)

__init__

def __init__(request_queue: asyncio.Queue, dialogues: AbciDialogues, target_skill: str)

Initializes the abci handler.

Arguments:

  • request_queue: queue holding translated abci messages.
  • dialogues: dialogues
  • target_skill: target skill of messages

send

async def send(envelope: Envelope) -> Response

Returns response to the waiting request

:param: envelope: Envelope to be returned

Echo

async def Echo(request: RequestEcho, context: grpc.ServicerContext) -> ResponseEcho

Handles "Echo" gRPC requests

:param: request: The request from the Tendermint node :param: context: The request context

Returns:

the Echo response

Flush

async def Flush(request: RequestFlush, context: grpc.ServicerContext) -> ResponseFlush

Handles "Flush" gRPC requests

:param: request: The request from the Tendermint node :param: context: The request context

Returns:

the Echo response

Info

async def Info(request: RequestInfo, context: grpc.ServicerContext) -> ResponseInfo

Handles "Info" gRPC requests

:param: request: The request from the Tendermint node :param: context: The request context

Returns:

the Echo response

SetOption

async def SetOption(request: RequestSetOption, context: grpc.ServicerContext) -> ResponseSetOption

Handles "SetOption" gRPC requests

:param: request: The request from the Tendermint node :param: context: The request context

Returns:

the Echo response

DeliverTx

async def DeliverTx(request: RequestDeliverTx, context: grpc.ServicerContext) -> ResponseDeliverTx

Handles "DeliverTx" gRPC requests

:param: request: The request from the Tendermint node :param: context: The request context

Returns:

the Echo response

CheckTx

async def CheckTx(request: RequestCheckTx, context: grpc.ServicerContext) -> ResponseCheckTx

Handles "CheckTx" gRPC requests

:param: request: The request from the Tendermint node :param: context: The request context

Returns:

the Echo response

Query

async def Query(request: RequestQuery, context: grpc.ServicerContext) -> ResponseQuery

Handles "Query" gRPC requests

:param: request: The request from the Tendermint node :param: context: The request context

Returns:

the Echo response

Commit

async def Commit(request: RequestCommit, context: grpc.ServicerContext) -> ResponseCommit

Handles "Commit" gRPC requests

:param: request: The request from the Tendermint node :param: context: The request context

Returns:

the Echo response

InitChain

async def InitChain(request: RequestInitChain, context: grpc.ServicerContext) -> ResponseInitChain

Handles "InitChain" gRPC requests

:param: request: The request from the Tendermint node :param: context: The request context

Returns:

the Echo response

BeginBlock

async def BeginBlock(request: RequestBeginBlock, context: grpc.ServicerContext) -> ResponseBeginBlock

Handles "BeginBlock" gRPC requests

:param: request: The request from the Tendermint node :param: context: The request context

Returns:

the Echo response

EndBlock

async def EndBlock(request: RequestEndBlock, context: grpc.ServicerContext) -> ResponseEndBlock

Handles "EndBlock" gRPC requests

:param: request: The request from the Tendermint node :param: context: The request context

Returns:

the Echo response

ListSnapshots

async def ListSnapshots(request: RequestListSnapshots, context: grpc.ServicerContext) -> ResponseListSnapshots

Handles "ListSnapshots" gRPC requests

:param: request: The request from the Tendermint node :param: context: The request context

Returns:

the Echo response

OfferSnapshot

async def OfferSnapshot(request: RequestOfferSnapshot, context: grpc.ServicerContext) -> ResponseOfferSnapshot

Handles "OfferSnapshot" gRPC requests

:param: request: The request from the Tendermint node :param: context: The request context

Returns:

the Echo response

LoadSnapshotChunk

async def LoadSnapshotChunk(request: RequestLoadSnapshotChunk, context: grpc.ServicerContext) -> ResponseLoadSnapshotChunk

Handles "LoadSnapshotChunk" gRPC requests

:param: request: The request from the Tendermint node :param: context: The request context

Returns:

the Echo response

ApplySnapshotChunk

async def ApplySnapshotChunk(request: RequestApplySnapshotChunk, context: grpc.ServicerContext) -> ResponseApplySnapshotChunk

Handles "ApplySnapshotChunk" gRPC requests

:param: request: The request from the Tendermint node :param: context: The request context

Returns:

the Echo response

GrpcServerChannel Objects

class GrpcServerChannel()

gRPC server channel to handle incoming communication from the Tendermint node.

__init__

def __init__(target_skill_id: PublicId, address: str, port: int, logger: Optional[Logger] = None)

Initialize the gRPC server.

Arguments:

  • target_skill_id: the public id of the target skill.
  • address: the listen address.
  • port: the port to listen from.
  • logger: the logger.

is_stopped

@property
def is_stopped() -> bool

Check that the channel is stopped.

connect

async def connect(loop: AbstractEventLoop) -> None

Connect.

Arguments:

  • loop: asyncio event loop

disconnect

async def disconnect() -> None

Disconnect the channel

get_message

async def get_message() -> Envelope

Get a message from the queue.

send

async def send(envelope: Envelope) -> None

Send a message.

TcpServerChannel Objects

class TcpServerChannel()

TCP server channel to handle incoming communication from the Tendermint node.

__init__

def __init__(target_skill_id: PublicId, address: str, port: int, logger: Optional[Logger] = None)

Initialize the TCP server.

Arguments:

  • target_skill_id: the public id of the target skill.
  • address: the listen address.
  • port: the port to listen from.
  • logger: the logger.

is_stopped

@property
def is_stopped() -> bool

Check that the channel is stopped.

connect

async def connect(loop: AbstractEventLoop) -> None

Connect.

Upon TCP Channel connection, start the TCP Server asynchronously.

Arguments:

  • loop: asyncio event loop

disconnect

async def disconnect() -> None

Disconnect the channel

receive_messages

async def receive_messages(reader: asyncio.StreamReader, writer: asyncio.StreamWriter) -> None

Receive incoming messages.

get_message

async def get_message() -> Envelope

Get a message from the queue.

send

async def send(envelope: Envelope) -> None

Send a message.

StoppableThread Objects

class StoppableThread(Thread)

Thread class with a stop() method.

__init__

def __init__(*args: Any, **kwargs: Any) -> None

Initialise the thread.

stop

def stop() -> None

Set the stop event.

stopped

def stopped() -> bool

Check if the thread is stopped.

TendermintParams Objects

class TendermintParams()

Tendermint node parameters.

__init__

def __init__(proxy_app: str, rpc_laddr: str = DEFAULT_RPC_LISTEN_ADDRESS, p2p_laddr: str = DEFAULT_P2P_LISTEN_ADDRESS, p2p_seeds: Optional[List[str]] = None, consensus_create_empty_blocks: bool = True, home: Optional[str] = None, use_grpc: bool = False)

Initialize the parameters to the Tendermint node.

Arguments:

  • proxy_app: ABCI address.
  • rpc_laddr: RPC address.
  • p2p_laddr: P2P address.
  • p2p_seeds: P2P seeds.
  • consensus_create_empty_blocks: if true, Tendermint node creates empty blocks.
  • home: Tendermint's home directory.
  • use_grpc: Wheter to use a gRPC server, or TSP

__str__

def __str__() -> str

Get the string representation.

build_node_command

def build_node_command(debug: bool = False) -> List[str]

Build the 'node' command.

get_node_command_kwargs

@staticmethod
def get_node_command_kwargs(monitoring: bool = False) -> Dict

Get the node command kwargs

TendermintNode Objects

class TendermintNode()

A class to manage a Tendermint node.

__init__

def __init__(params: TendermintParams, logger: Optional[Logger] = None)

Initialize a Tendermint node.

Arguments:

  • params: the parameters.
  • logger: the logger.

init

def init() -> None

Initialize Tendermint node.

start

def start(start_monitoring: bool = False, debug: bool = False) -> None

Start a Tendermint node process.

stop

def stop() -> None

Stop a Tendermint node process.

prune_blocks

def prune_blocks() -> int

Prune blocks from the Tendermint state

write_line

def write_line(line: str) -> None

Open and write a line to the log file.

check_server_status

def check_server_status() -> None

Check server status.

reset_genesis_file

def reset_genesis_file(genesis_time: str, initial_height: str) -> None

Reset genesis file.

ABCIServerConnection Objects

class ABCIServerConnection(Connection)

ABCI server.

__init__

def __init__(**kwargs: Any) -> None

Initialize the connection.

Arguments:

  • kwargs: keyword arguments passed to component base

connect

async def connect() -> None

Set up the connection.

In the implementation, remember to update 'connection_status' accordingly.

disconnect

async def disconnect() -> None

Tear down the connection.

In the implementation, remember to update 'connection_status' accordingly.

send

async def send(envelope: Envelope) -> None

Send an envelope.

Arguments:

  • envelope: the envelope to send.

receive

async def receive(*args: Any, **kwargs: Any) -> Optional[Envelope]

Receive an envelope. Blocking.

Arguments:

  • args: arguments to receive
  • kwargs: keyword arguments to receive

Returns:

the envelope received, if present. # noqa: DAR202

Back to top