Host Loop Pseudocode
====================

**Constants**:

::

   ACCOUNT_ADDR_SIZE = 20
   SLOT_ID_SIZE = 32

**Data Encoding Functions**:

::

   write_byte_slice(arr):
     write_u32_le len(arr)
     write_bytes arr

   read_slice():
     len := read_u32_le
     data := read_bytes(len)
     return data

Protocol Loop
~~~~~~~~~~~~~

The :term:`host` processes requests in a loop until ``consume_result``:

::

   loop:
     method_id := read_byte
     match method_id
       json/methods/get_calldata:
         calldata, err := host_get_calldata()
         if err != json/errors/ok:
           write_byte err
         else:
           write_byte json/errors/ok
           write_byte_slice calldata

       json/methods/storage_read:
         read_type := read_byte as json/storage_type
         address := read_bytes(ACCOUNT_ADDR_SIZE)
         slot := read_bytes(SLOT_ID_SIZE)
         index := read_u32_le
         len := read_u32_le
         data, err := host_storage_read(read_type, address, slot, index, len)
         if err != json/errors/ok:
           write_byte err
         else:
           write_byte json/errors/ok
           write_bytes data # must be exactly len in size

       json/methods/storage_write:
         slot := read_bytes(SLOT_ID_SIZE)
         index := read_u32_le
         len := read_u32_le
         data := read_bytes(len)
         err := host_storage_write(slot, index, data)
         if err != json/errors/ok:
           write_byte err
         else:
           write_byte json/errors/ok

       json/methods/consume_result:
         host_result := read_slice()
         # this is needed to ensure that genvm doesn't close socket before all data is read
         write_byte 0x00
         break

       json/methods/get_leader_nondet_result:
         call_no := read_u32_le
         data, err := host_get_leader_nondet_result(call_no)
         if err != json/errors/ok:
           write_byte err
         else:
           write_byte json/errors/ok
           write_byte_slice data

       json/methods/post_nondet_result:
         call_no := read_u32_le
         result := read_slice()
         err := host_post_nondet_result(call_no, result)
         if err != json/errors/ok:
           write_byte err
         else:
           write_byte json/errors/ok

       json/methods/post_message:
         address := read_bytes(ACCOUNT_ADDR_SIZE)
         calldata := read_slice()
         message_data := read_slice() # JSON string
         err := host_post_message(address, calldata, message_data)
         if err != json/errors/ok:
           write_byte err
         else:
           write_byte json/errors/ok

       json/methods/consume_fuel:
         gas := read_u64_le
         host_consume_fuel(gas)
         # note: this method doesn't send any response

       json/methods/deploy_contract:
         calldata := read_slice()
         code := read_slice()
         message_data := read_slice() # JSON string
         err := host_deploy_contract(calldata, code, message_data)
         if err != json/errors/ok:
           write_byte err
         else:
           write_byte json/errors/ok

       json/methods/eth_call:
         address := read_bytes(ACCOUNT_ADDR_SIZE)
         calldata := read_slice()
         result, err := host_eth_call(address, calldata)
         if err != json/errors/ok:
           write_byte err
         else:
           write_byte json/errors/ok
           write_byte_slice result

       json/methods/eth_send:
         address := read_bytes(ACCOUNT_ADDR_SIZE)
         calldata := read_slice()
         message_data := read_slice() # JSON string
         err := host_eth_send(address, calldata, message_data)
         if err != json/errors/ok:
           write_byte err
         else:
           write_byte json/errors/ok

        json/methods/post_event:
          read_byte topics_len
          topics := []
          for i in range(topics_len):
            topic := read_bytes(32) # 32 bytes each
            topics.append(topic)
          blob := read_slice
          err := host_post_event(topics, blob)
          if err != json/errors/ok:
            write_byte err
          else:
            write_byte json/errors/ok

       json/methods/get_balance:
         address := read_bytes(ACCOUNT_ADDR_SIZE)
         balance, err := host_get_balance(address)
         if err != json/errors/ok:
           write_byte err
         else:
           write_byte json/errors/ok
           write_bytes balance.to_le_bytes(32) # 256-bit integer

       json/methods/remaining_fuel_as_gen:
         fuel, err := host_remaining_fuel_as_gen()
         if err != json/errors/ok:
           write_byte err
         else:
           write_byte json/errors/ok
           write_bytes fuel.to_le_bytes(8) # 64-bit integer, must be safe integer (fits in double)

       json/methods/notify_nondet_disagreement:
          call_no := read_u32_le
          host_notify_nondet_disagreement(call_no)