ergo-lib-c-core 0.28.0

Common code for ergo-lib C and JNI bindings
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

//! Simple box selection algorithms
use ergo_lib::wallet::{self, box_selector::BoxSelector};

use crate::{
    collections::{Collection, CollectionPtr, ConstCollectionPtr},
    ergo_box::{ConstBoxValuePtr, ErgoBox, ErgoBoxAssetsData},
    token::Token,
    util::{const_ptr_as_ref, mut_ptr_as_mut},
    Error,
};

/// Selected boxes with change boxes (by [`BoxSelector`])
#[derive(PartialEq, Eq, Debug, Clone)]
pub struct BoxSelection(
    pub(crate) wallet::box_selector::BoxSelection<ergo_lib::ergotree_ir::chain::ergo_box::ErgoBox>,
);
pub type BoxSelectionPtr = *mut BoxSelection;
pub type ConstBoxSelectionPtr = *const BoxSelection;

/// Create a selection to easily inject custom selection algorithms
pub unsafe fn box_selection_new(
    ergo_boxes_ptr: ConstCollectionPtr<ErgoBox>,
    change_ergo_boxes_ptr: ConstCollectionPtr<ErgoBoxAssetsData>,
    box_selection_out: *mut BoxSelectionPtr,
) -> Result<(), Error> {
    let ergo_boxes = const_ptr_as_ref(ergo_boxes_ptr, "ergo_boxes_ptr")?;
    let change_ergo_boxes = const_ptr_as_ref(change_ergo_boxes_ptr, "change_ergo_boxes_ptr")?;
    let box_selection_out = mut_ptr_as_mut(box_selection_out, "box_selection_out")?;
    let boxes = wallet::box_selector::SelectedBoxes::from_vec(
        ergo_boxes.0.clone().into_iter().map(|b| b.0).collect(),
    )?;
    *box_selection_out = Box::into_raw(Box::new(BoxSelection(
        wallet::box_selector::BoxSelection::<ergo_lib::ergotree_ir::chain::ergo_box::ErgoBox> {
            boxes,
            change_boxes: change_ergo_boxes
                .0
                .clone()
                .into_iter()
                .map(|b| b.0)
                .collect(),
        },
    )));
    Ok(())
}

/// Selected boxes to spend as transaction inputs
pub unsafe fn box_selection_boxes(
    box_selection_ptr: ConstBoxSelectionPtr,
    ergo_boxes_out: *mut CollectionPtr<ErgoBox>,
) -> Result<(), Error> {
    let box_selection = const_ptr_as_ref(box_selection_ptr, "box_selection_ptr")?;
    let ergo_boxes_out = mut_ptr_as_mut(ergo_boxes_out, "ergo_boxes_out")?;
    *ergo_boxes_out = Box::into_raw(Box::new(Collection(
        box_selection
            .0
            .boxes
            .clone()
            .into_iter()
            .map(ErgoBox)
            .collect(),
    )));
    Ok(())
}

/// Selected boxes to use as change
pub unsafe fn box_selection_change(
    box_selection_ptr: ConstBoxSelectionPtr,
    change_ergo_boxes_out: *mut CollectionPtr<ErgoBoxAssetsData>,
) -> Result<(), Error> {
    let box_selection = const_ptr_as_ref(box_selection_ptr, "box_selection_ptr")?;
    let change_ergo_boxes_out = mut_ptr_as_mut(change_ergo_boxes_out, "change_ergo_boxes_out")?;
    *change_ergo_boxes_out = Box::into_raw(Box::new(Collection(
        box_selection
            .0
            .change_boxes
            .clone()
            .into_iter()
            .map(ErgoBoxAssetsData)
            .collect(),
    )));
    Ok(())
}

/// Naive box selector, collects inputs until target balance is reached
pub struct SimpleBoxSelector(wallet::box_selector::SimpleBoxSelector);
pub type SimpleBoxSelectorPtr = *mut SimpleBoxSelector;
pub type ConstSimpleBoxSelectorPtr = *const SimpleBoxSelector;

pub unsafe fn simple_box_selector_new(
    simple_box_selector_out: *mut SimpleBoxSelectorPtr,
) -> Result<(), Error> {
    let simple_box_selector_out =
        mut_ptr_as_mut(simple_box_selector_out, "simple_box_selector_out")?;
    *simple_box_selector_out = Box::into_raw(Box::new(SimpleBoxSelector(
        wallet::box_selector::SimpleBoxSelector::new(),
    )));
    Ok(())
}

/// Selects inputs to satisfy target balance and tokens.
/// `inputs` - available inputs (returns an error, if empty),
/// `target_balance` - coins (in nanoERGs) needed,
/// `target_tokens` - amount of tokens needed.
/// Returns selected inputs and box assets(value+tokens) with change.
pub unsafe fn simple_box_selector_select(
    simple_box_selector_ptr: ConstSimpleBoxSelectorPtr,
    inputs_ptr: ConstCollectionPtr<ErgoBox>,
    target_balance_ptr: ConstBoxValuePtr,
    target_tokens_ptr: ConstCollectionPtr<Token>,
    box_selection_out: *mut BoxSelectionPtr,
) -> Result<(), Error> {
    let inputs = const_ptr_as_ref(inputs_ptr, "inputs_ptr")?;
    let target_balance = const_ptr_as_ref(target_balance_ptr, "target_balance_ptr")?;
    let target_tokens = const_ptr_as_ref(target_tokens_ptr, "target_tokens_ptr")?;
    let simple_box_selector = const_ptr_as_ref(simple_box_selector_ptr, "simple_box_selector_ptr")?;
    let box_selection_out = mut_ptr_as_mut(box_selection_out, "box_selection_out")?;
    let box_selection = simple_box_selector.0.select(
        inputs.0.clone().into_iter().map(|b| b.0).collect(),
        target_balance.0,
        target_tokens
            .0
            .clone()
            .into_iter()
            .map(|b| b.0)
            .collect::<Vec<ergo_lib::ergotree_ir::chain::token::Token>>()
            .as_slice(),
    )?;
    *box_selection_out = Box::into_raw(Box::new(BoxSelection(box_selection)));
    Ok(())
}