1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

use std::{collections::BTreeMap, path::PathBuf};

use serde::{Deserialize, Serialize};

use crate::{EventName, FunctionName, Target};

/// Metadata about bridging events
#[derive(Debug, Serialize, Deserialize)]
pub struct Bridge {
    /// The generated contract interfaces file. This is a path relative to the root directory.
    file: PathBuf,
    /// Source chain (i.e., the chain where the contract interface is deployed)
    sender: Target,
    /// Destination chain (i.e., the chain where the original contract is deployed)
    receiver: Target,
    /// Shim contracts defined in this interface file
    contracts: Vec<ContractBridge>,
}

/// Metadata about bridging events from a particular contract
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct ContractBridge {
    /// The name of the contract
    name: String,
    /// Mapping from a function name to the name of the event it raises
    functions: BTreeMap<FunctionName, EventName>,
}

impl Bridge {
    /// Initializes a struct that holds the information about a bridge
    pub fn new(
        file: PathBuf,
        sender: Target,
        receiver: Target,
        contracts: Vec<ContractBridge>,
    ) -> Bridge {
        Bridge {
            file,
            sender,
            receiver,
            contracts,
        }
    }

    /// The chain on the receiving end of this bridge.
    pub fn receiver_target(&self) -> Target {
        self.receiver
    }

    /// Map from function name to the name of the event it raises.
    pub fn bridges(
        &self,
        contract_name: &str,
    ) -> impl Iterator<Item = (&FunctionName, &EventName)> {
        self.contracts
            .iter()
            .find(|c| c.name == contract_name)
            .map(|c| c.functions.iter())
            .unwrap()
    }
}

impl ContractBridge {
    /// Initializes a struct that holds the information about a contract bridge
    pub fn new(name: String, functions: BTreeMap<FunctionName, EventName>) -> ContractBridge {
        ContractBridge { name, functions }
    }
}