Struct adapter::primitives::Config

pub struct Config {
    pub worker: ValidatorWorkerConfig,
    pub sentry: SentryConfig,
    pub creators_whitelist: Vec<Address, Global>,
    pub validators_whitelist: Vec<ValidatorId, Global>,
    pub chains: HashMap<String, ChainInfo, RandomState>,
    pub limits: Limits,
}

Examples:

use primitives::{config::GANACHE_CONFIG, Config};
use serde_json::{from_value, json};

fn main() {
    let json = json!({
      "creators_whitelist": [
        "0xaCBaDA2d5830d1875ae3D2de207A1363B316Df2F",
        "0xDd589B43793934EF6Ad266067A0d1D4896b0dff0",
        "0xE882ebF439207a70dDcCb39E13CA8506c9F45fD9",
        "0x541b401362Ea1D489D322579552B099e801F3632"
      ],
      "validators_whitelist": [
        "0x80690751969B234697e9059e04ed72195c3507fa",
        "0xf3f583AEC5f7C030722Fe992A5688557e1B86ef7",
        "0x6B83e7D6B72c098d48968441e0d05658dc17Adb9"
      ],
      "chain": {
        "Ganache #1337": {
          "chain_id": 1337,
          "rpc": "http://localhost:1337/",
          "outpace": "0xAbc27d46a458E2e49DaBfEf45ca74dEDBAc3DD06",
          "token": {
            "Mocked TOKEN 1337": {
              "min_campaign_budget": "1000000000000000000",
              "min_validator_fee": "1000000000000",
              "precision": 18,
              "address": "0x2BCaf6968aEC8A3b5126FBfAb5Fd419da6E8AD8E"
            }
          }
        },
        "Ganache #1": {
          "chain_id": 1,
          "rpc": "http://localhost:8545/",
          "outpace": "0x26CBc2eAAe377f6Ac4b73a982CD1125eF4CEC96f",
          "token": {
            "Mocked TOKEN 1": {
              "min_campaign_budget": "1000000000000000000",
              "min_validator_fee": "1000000000000",
              "precision": 18,
              "address": "0x12a28f2bfBFfDf5842657235cC058242f40fDEa6"
            }
          }
        }
      },
      "limits": {
        "units_for_slot": {
          "max_campaigns_earning_from": 25,
          "global_min_impression_price": "10"
        },
        "channels_find": 200,
        "campaigns_find": 200,
        "spendable_find": 200,
        "msgs_find": 10,
        "analytics_find": 5000,
        "ip_rate_limit": {
          "type": "ip",
          "timeframe": 1200000
        }
      },
      "sentry": {
        "analytics_maxtime": 20000,
        "admins": [
          "0x80690751969B234697e9059e04ed72195c3507fa"
        ],
        "platform": {
          "url": "https://platform.adex.network/",
          "keep_alive_interval": 1200000
        },
      },
      "worker": {
        "max_channels": 512,
        "wait_time": 500,
        "heartbeat_time": 30000,
        "health_threshold_promilles": 950,
        "health_unsignable_promilles": 750,
        "timeouts": {
          "propagation": 2000,
          "fetch": 5000,
          "all_campaigns": 5000,
          "channel_tick": 8000,
        }
      }
    });
    assert_eq!(
        from_value::<Config>(json).expect("Should deserialize"),
        GANACHE_CONFIG.clone()
    );
}

Fields

worker: ValidatorWorkerConfig

Values used for the validator worker

sentry: SentryConfig

Values used for the sentry

creators_whitelist: Vec<Address, Global>

An optional whitelisted addresses for Campaign.creators.

If empty, any address will be allowed to create a Campaign.

validators_whitelist: Vec<ValidatorId, Global>

An optional whitelisted Validator addresses for Campaign.validators.

If empty, any address will be allowed to be a validator in a Campaign.

chains: HashMap<String, ChainInfo, RandomState>

The key of this map is a human-readable text of the Chain name for readability in the configuration file.

• To get the chain of a token address use Config::find_chain_of().

• To get a ChainInfo only by a ChainId use Config::find_chain().

NOTE: Make sure that a Token Address is unique across all Chains, otherwise Config::find_chain_of() will fetch only one of them and cause unexpected problems.

limits: Limits

Any limits applied to Sentry or Validator.

Implementations

impl Config

pub fn try_toml(toml: &str) -> Result<Config, Error>

Utility method that will deserialize a Toml file content into a Config.

Rather than relying on the toml crate directly, use this method instead.

pub fn find_chain(&self, chain_id: ChainId) -> Option<&ChainInfo>

Finds a Chain based on the ChainId.

pub fn find_chain_of(&self, token: Address) -> Option<ChainOf<()>>

Finds the pair of Chain & Token, given only a token Address.

Trait Implementations

impl Clone for Config

fn clone(&self) -> Config

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Config

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Config

fn deserialize<__D>(
    __deserializer: __D
) -> Result<Config, <__D as Deserializer<'de>>::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq<Config> for Config

fn eq(&self, other: &Config) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Config

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Config

impl StructuralEq for Config

impl StructuralPartialEq for Config