darkfi/bin/darkfid2/src/utils.rs

/* This file is part of DarkFi (https://dark.fi)
 *
 * Copyright (C) 2020-2023 Dyne.org foundation
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

use std::{collections::HashMap, sync::Arc};

use log::info;
use smol::Executor;

use darkfi::{
    error::TxVerifyFailed,
    net::{P2p, P2pPtr, Settings, SESSION_ALL},
    rpc::jsonrpc::JsonSubscriber,
    tx::Transaction,
    validator::ValidatorPtr,
    Result,
};
use darkfi_consensus_contract::{
    model::ConsensusGenesisStakeParamsV1, ConsensusFunction::GenesisStakeV1,
};
use darkfi_money_contract::{model::MoneyTokenMintParamsV1, MoneyFunction::GenesisMintV1};
use darkfi_sdk::crypto::{CONSENSUS_CONTRACT_ID, MONEY_CONTRACT_ID};
use darkfi_serial::deserialize;

use crate::proto::{ProtocolBlock, ProtocolProposal, ProtocolSync, ProtocolTx};

/// Auxiliary function to calculate the total amount of minted tokens in provided
/// genesis transactions set. This includes both staked and normal tokens.
/// If a non-genesis transaction is found, execution fails.
/// Set must also include the genesis transaction(empty) at last position.
pub fn genesis_txs_total(txs: &[Transaction]) -> Result<u64> {
    let mut total = 0;

    if txs.is_empty() {
        return Ok(total)
    }

    // Iterate transactions, exluding producer(last) one
    for tx in &txs[..txs.len() - 1] {
        // Transaction must contain a single Consensus::GenesisStake or Money::GenesisMint call
        if tx.calls.len() != 1 {
            return Err(TxVerifyFailed::ErroneousTxs(vec![tx.clone()]).into())
        }
        let call = &tx.calls[0];
        let function = call.data[0];
        if !(call.contract_id == *CONSENSUS_CONTRACT_ID || call.contract_id == *MONEY_CONTRACT_ID) ||
            (call.contract_id == *CONSENSUS_CONTRACT_ID && function != GenesisStakeV1 as u8) ||
            (call.contract_id == *MONEY_CONTRACT_ID && function != GenesisMintV1 as u8)
        {
            return Err(TxVerifyFailed::ErroneousTxs(vec![tx.clone()]).into())
        }

        let value = if function == GenesisStakeV1 as u8 {
            let params: ConsensusGenesisStakeParamsV1 = deserialize(&call.data[1..])?;
            params.input.value
        } else {
            let params: MoneyTokenMintParamsV1 = deserialize(&call.data[1..])?;
            params.input.value
        };

        total += value;
    }

    let tx = txs.last().unwrap();
    if tx != &Transaction::default() {
        return Err(TxVerifyFailed::ErroneousTxs(vec![tx.clone()]).into())
    }

    Ok(total)
}

/// Auxiliary function to generate the sync P2P network and register all its protocols.
pub async fn spawn_sync_p2p(
    settings: &Settings,
    validator: &ValidatorPtr,
    subscribers: &HashMap<&'static str, JsonSubscriber>,
    executor: Arc<Executor<'static>>,
) -> P2pPtr {
    info!(target: "darkfid", "Registering sync network P2P protocols...");
    let p2p = P2p::new(settings.clone(), executor.clone()).await;
    let registry = p2p.protocol_registry();

    let _validator = validator.clone();
    let _subscriber = subscribers.get("blocks").unwrap().clone();
    registry
        .register(SESSION_ALL, move |channel, p2p| {
            let validator = _validator.clone();
            let subscriber = _subscriber.clone();
            async move { ProtocolBlock::init(channel, validator, p2p, subscriber).await.unwrap() }
        })
        .await;

    let _validator = validator.clone();
    registry
        .register(SESSION_ALL, move |channel, _p2p| {
            let validator = _validator.clone();
            async move { ProtocolSync::init(channel, validator).await.unwrap() }
        })
        .await;

    let _validator = validator.clone();
    let _subscriber = subscribers.get("txs").unwrap().clone();
    registry
        .register(SESSION_ALL, move |channel, p2p| {
            let validator = _validator.clone();
            let subscriber = _subscriber.clone();
            async move { ProtocolTx::init(channel, validator, p2p, subscriber).await.unwrap() }
        })
        .await;

    p2p
}

/// Auxiliary function to generate the consensus P2P network and register all its protocols.
pub async fn spawn_consensus_p2p(
    settings: &Settings,
    validator: &ValidatorPtr,
    subscribers: &HashMap<&'static str, JsonSubscriber>,
    executor: Arc<Executor<'static>>,
) -> P2pPtr {
    info!(target: "darkfid", "Registering consensus network P2P protocols...");
    let p2p = P2p::new(settings.clone(), executor.clone()).await;
    let registry = p2p.protocol_registry();

    let _validator = validator.clone();
    let _subscriber = subscribers.get("proposals").unwrap().clone();
    registry
        .register(SESSION_ALL, move |channel, p2p| {
            let validator = _validator.clone();
            let subscriber = _subscriber.clone();
            async move { ProtocolProposal::init(channel, validator, p2p, subscriber).await.unwrap() }
        })
        .await;

    p2p
}