abi.rs

//! Contract ABI helpers.

use ethabi::{Bytes, RawLog, TopicFilter};
use ethereum_types::Address;
use failure::Error;
use linker::Linker;
use std::collections::HashMap;
use std::path::PathBuf;
use {call, evm};

#[derive(Debug)]
pub struct FileSource {
    pub ast: &'static str,
}

/// Context for all loaded contracts.
#[derive(Debug)]
pub struct ContractContext {
    /// List of sources, as indexed by a source map.
    pub source_list: Option<Vec<PathBuf>>,
    /// AST of sources.
    pub sources: HashMap<&'static str, FileSource>,
}

/// Contract functions generated by parables_build.
pub trait ContractFunction {
    /// Output types of the function.
    type Output;

    /// Encodes the input for the function.
    fn encoded(&self, linker: &Linker) -> Result<Bytes, Error>;

    /// Decodes the given bytes output for the contract function.
    fn output(&self, output_bytes: Bytes) -> Result<Self::Output, Error>;
}

/// Helpers for building log filters.
pub trait LogFilter {
    fn wildcard_filter(&self) -> TopicFilter;
}

/// Log parsing implementation.
pub trait ParseLog {
    /// Type of the parsed log.
    type Log;

    /// Function to parse log.
    fn parse_log(&self, log: RawLog) -> Result<Self::Log, Error>;
}

pub trait Constructor {
    /// Name of the constructor item, used for linking.
    const ITEM: &'static str;

    /// Path that this contract belongs to.
    const PATH: &'static str;

    /// Access the code to deploy for this constructor.
    const BIN: &'static str;

    /// Access the source map for the type this constructor is associated with.
    const SOURCE_MAP: Option<&'static str>;

    /// Access the runtime code being deployed.
    const RUNTIME_BIN: Option<&'static str>;

    /// Access the runtime source map for the type this constructor is associated with.
    const RUNTIME_SOURCE_MAP: Option<&'static str>;
}

/// Virtual machine abstraction.
pub trait Vm {
    /// Perform a call against the given contract function.
    fn call<F>(
        &self,
        address: Address,
        f: F,
        call: call::Call,
    ) -> Result<evm::Call<F::Output>, Error>
    where
        F: ContractFunction;
}