Function convert_response

src/response.rs:229–281

(res: hypersync_client::QueryResponse)

}

pub fn convert_response(res: hypersync_client::QueryResponse) -> Result<QueryResponse> {
    let blocks = res
        .data
        .blocks
        .iter()
        .flat_map(|b| b.iter().map(Block::from))
        .collect::<Vec<_>>();

    let transactions = res
        .data
        .transactions
        .iter()
        .flat_map(|b| b.iter().map(Transaction::from))
        .collect::<Vec<_>>();

    let logs = res
        .data
        .logs
        .iter()
        .flat_map(|b| b.iter().map(Log::from))
        .collect::<Vec<_>>();

    let traces = res
        .data
        .traces
        .iter()
        .flat_map(|b| b.iter().map(Trace::from))
        .collect::<Vec<_>>();

    Ok(QueryResponse {
        archive_height: res
            .archive_height
            .map(|h| h.try_into())
            .transpose()
            .context("convert height")?,
        next_block: res.next_block.try_into().context("convert next_block")?,
        total_execution_time: res
            .total_execution_time
            .try_into()
            .context("convert total_execution_time")?,
        data: QueryResponseData {
            blocks,
            transactions,
            logs,
            traces,
        },
        rollback_guard: res
            .rollback_guard
            .map(RollbackGuard::try_convert)
            .transpose()
            .context("convert rollback guard")?,
    })
}

pub fn convert_event_response(resp: hypersync_client::EventResponse) -> Result<EventResponse> {
    let data = resp