setup 0.1.0

Sets up the Aptosis faucet.
Documentation 
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
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

use std::collections::BTreeMap;

use anyhow::*;
use coinlist::{CoinInfo, CoinList};
use move_deps::move_core_types::{
    account_address::AccountAddress, ident_str, identifier::Identifier, language_storage::StructTag,
};
use serde::{Deserialize, Serialize};
use tera::Tera;
use url::Url;

/// Simplified Move manifest.
#[derive(Deserialize)]
pub struct MoveManifestSimple {
    pub addresses: BTreeMap<String, String>,
}

/// Test coin as defined in the configuration.
#[derive(Deserialize)]
pub struct DevCoin {
    pub name: String,
    pub decimals: u8,
}

#[derive(Serialize, Deserialize)]
pub struct DevCoinInfo {
    #[serde(flatten)]
    pub coin: CoinInfo,
    pub hard_cap: u64,
}

impl From<CoinInfo> for DevCoinInfo {
    fn from(coin: CoinInfo) -> Self {
        Self {
            hard_cap: coin.decimals as u64 * 1_000_000_000,
            coin,
        }
    }
}

pub fn make_coin_info(
    address: &AccountAddress,
    symbol: &str,
    DevCoin { name, decimals }: &DevCoin,
) -> Result<CoinInfo> {
    Ok(CoinInfo {
        chain_id: coinlist::ChainID::AptosDevnet as u32,
        address: StructTag {
            address: *address,
            module: ident_str!("Faucet").to_owned(),
            name: Identifier::new(symbol)?,
            type_params: vec![],
        }
        .into(),
        name: name.into(),
        symbol: symbol.into(),
        decimals: *decimals,
        extensions: None,
        logo_uri: Some(Url::parse(&format!(
            "https://raw.githubusercontent.com/aptosis/aptosis-coin-list/master/assets/devnet/{}.svg",
            symbol.to_lowercase()
        ))?),
        tags: Some(vec!["aptosis-faucet".into()]),
    })
}

pub fn generate_coin_list<'a, I>(address: &AccountAddress, coins: I) -> Result<CoinList>
where
    I: IntoIterator<Item = (&'a String, &'a DevCoin)>,
{
    let tokens = coins
        .into_iter()
        .map(|(symbol, token)| make_coin_info(address, symbol, token))
        .collect::<Result<Vec<_>>>()?;
    let mut coin_list = CoinList::new("Aptosis Coin List");
    coin_list.tokens = tokens;
    Ok(coin_list)
}

pub struct Setup {
    pub tera: Tera,
    pub ctx: SetupContext,
}

impl Setup {
    pub fn init(
        addr: &AccountAddress,
        coin_list: &CoinList,
        aptosis_minter: AccountAddress,
    ) -> Result<Self> {
        let mut tera = Tera::default();
        tera.add_raw_template("DevCoin", include_str!("templates/DevCoin.tpl.move"))?;
        tera.add_raw_template("init_tokens", include_str!("templates/init_tokens.tpl.sh"))?;

        let coins = coin_list
            .tokens
            .iter()
            .map(|coin| DevCoinInfo::from(coin.clone()))
            .collect::<Vec<_>>();

        let ctx = SetupContext {
            faucet_address: addr.to_hex_literal(),
            coins,
            aptosis_minter_address: aptosis_minter.to_hex_literal(),
        };
        Ok(Self { tera, ctx })
    }

    pub fn generate_move(&self) -> Result<String> {
        let result = self
            .tera
            .render("DevCoin", &tera::Context::from_serialize(&self.ctx)?)?;
        Ok(result)
    }

    pub fn generate_init_script(&self) -> Result<String> {
        let result = self
            .tera
            .render("init_tokens", &tera::Context::from_serialize(&self.ctx)?)?;
        Ok(result)
    }
}

#[derive(Serialize)]
pub struct SetupContext {
    /// Address of the faucet.
    pub faucet_address: String,
    pub coins: Vec<DevCoinInfo>,
    pub aptosis_minter_address: String,
}