redgold-schema 0.1.48

Decentralized Portfolio Contracts & Data Lake
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

use crate::structs::{Address, CurrencyAmount, DepositRequest, Output, PortfolioFulfillmentParams, PortfolioRequest, PortfolioWeighting, StakeDeposit, StakeRequest, StandardData, StandardRequest, SupportedCurrency, Weighting};
use crate::tx::tx_builder::TransactionBuilder;
use crate::structs;
use itertools::Itertools;

impl TransactionBuilder {

    pub fn with_portfolio_request(
        &mut self,
        weights: Vec<(SupportedCurrency, f64)>,
        redgold_to_party_payment_amount: &CurrencyAmount,
        party_address: &Address,
        name: &String
    ) -> Self {
        let updated = self.with_output(party_address, redgold_to_party_payment_amount);
        let mut pr = PortfolioRequest::default();
        let transformed_weights = weights.into_iter().map(|(c, w)| {
            let mut wee = PortfolioWeighting::default();
            let w2 = Weighting::from_float(w);
            wee.weight = Some(w2);
            wee.currency = Some(c as i32);
            wee
        }).collect_vec();
        let mut pi = crate::structs::PortfolioInfo::default();
        pi.portfolio_weightings = transformed_weights;
        pr.portfolio_info = Some(pi);
        let mut o = Output::default();
        o.address = updated.input_addresses.clone().get(0).cloned();
        let mut data = StandardData::default();
        let mut req = StandardRequest::default();

        let mut pid = structs::PortfolioId::default();
        pid.name = Some(name.clone());
        pr.portfolio_id = Some(pid);
        req.portfolio_request = Some(pr);
        data.standard_request = Some(req);
        o.data = Some(data);
        updated.transaction.outputs.push(o);
        updated.clone()
    }

    pub fn with_portfolio_stake_fullfillment(&mut self,
                                             stake_control_address: &Address,
                                             external_address: &Address,
                                             external_amount: &CurrencyAmount,
                                             pool_address: &Address,
                                             pool_fee: &CurrencyAmount,
    ) -> &mut Self {
        self.with_output(pool_address, pool_fee);
        self.with_last_output_stake();
        let mut o = Output::default();
        o.address = Some(stake_control_address.clone());
        let mut d = StandardData::default();
        let mut lq = StakeRequest::default();
        let mut deposit = StakeDeposit::default();
        deposit.portfolio_fulfillment_params = Some(PortfolioFulfillmentParams::default());
        let mut dr = DepositRequest::default();
        let mut external = external_address.clone();
        external.mark_external();
        dr.address = Some(external);
        dr.amount = Some(external_amount.clone());
        deposit.deposit = Some(dr);
        lq.deposit = Some(deposit);

        let mut sr = StandardRequest::default();
        sr.stake_request = Some(lq);
        d.standard_request = Some(sr);
        o.data = Some(d);
        self.transaction.outputs.push(o);
        self
    }

}