bitcoinwallet-library 0.1.16-alpha.0

a wallet maintains a set of transactions and balances, and provides the ability to create new transactions
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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

crate::ix!();

/**
  | A wrapper to reserve an address from
  | a wallet
  | 
  | ReserveDestination is used to reserve
  | an address.
  | 
  | It is currently only used inside of CreateTransaction.
  | 
  | Instantiating a ReserveDestination
  | does not reserve an address. To do so,
  | 
  | GetReservedDestination() needs to
  | be called on the object. Once an address
  | has been reserved, call KeepDestination()
  | on the ReserveDestination object to
  | make sure it is not returned. Call ReturnDestination()
  | to return the address so it can be re-used
  | (for example, if the address was used
  | in a new transaction and that transaction
  | was not completed and needed to be aborted).
  | 
  | If an address is reserved and KeepDestination()
  | is not called, then the address will
  | be returned when the ReserveDestination
  | goes out of scope.
  |
  */
pub struct ReserveDestination {

    /**
      | The wallet to reserve from
      |
      */
    pwallet:  *const Wallet,

    /**
      | The ScriptPubKeyMan to reserve from.
      | Based on type when GetReservedDestination
      | is called
      |
      */
    spk_man:  *mut ScriptPubKeyMan, // default = { nullptr }

    ty:       OutputType,

    /**
      | The index of the address's key in the
      | keypool
      |
      */
    n_index:  i64, // default = { -1 }

    /**
      | The destination
      |
      */
    address:  TxDestination,

    /**
      | Whether this is from the internal (change
      | output) keypool
      |
      */
    internal: bool, // default = { false }

}

impl Drop for ReserveDestination {

    /**
      | Destructor. If a key has been reserved
      | and not KeepKey'ed, it will be returned
      | to the keypool
      |
      */
    fn drop(&mut self) {
        todo!();
        /*
            ReturnDestination();
        */
    }
}

impl ReserveDestination {

    /**
      | Construct a ReserveDestination object.
      | This does NOT reserve an address yet
      |
      */
    pub fn new(
        pwallet: *mut Wallet,
        ty:      OutputType) -> Self {
    
        todo!();
        /*
        : pwallet(pwallet),
        : ty(type),

        
        */
    }

    /**
      | Reserve an address
      |
      */
    pub fn get_reserved_destination(&mut self, 
        pubkey:   &mut TxDestination,
        internal: bool,
        error:    &mut BilingualStr) -> bool {
        
        todo!();
        /*
        
        */
    }

    /**
      | Return reserved address
      |
      */
    pub fn return_destination(&mut self)  {
        
        todo!();
        /*
        
        */
    }

    /**
      | Keep the address. Do not return it's
      | key to the keypool when this object goes
      | out of scope
      |
      */
    pub fn keep_destination(&mut self)  {
        
        todo!();
        /*
        
        */
    }
}