keymaster-multisig-rust 3.0.0

Rust implementation of Keymaster Multisig using bsv-wasm
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

use serde::{Deserialize, Serialize};
use wasm_bindgen::prelude::*;

#[wasm_bindgen]
#[derive(Serialize, Deserialize, Clone, Debug)]
pub struct PublicKey {
    #[wasm_bindgen(skip)]
    pub key: Vec<u8>,
}

#[wasm_bindgen]
impl PublicKey {
    #[wasm_bindgen(constructor)]
    pub fn new(key: Vec<u8>) -> PublicKey {
        PublicKey { key }
    }

    pub fn to_bytes(&self) -> Vec<u8> {
        self.key.clone()
    }
}

#[wasm_bindgen]
#[derive(Serialize, Deserialize, Clone, Debug)]
pub struct PrivateKey {
    #[wasm_bindgen(skip)]
    pub key: Vec<u8>,
}

#[wasm_bindgen]
impl PrivateKey {
    #[wasm_bindgen(constructor)]
    pub fn new(key: Vec<u8>) -> PrivateKey {
        PrivateKey { key }
    }

    pub fn to_bytes(&self) -> Vec<u8> {
        self.key.clone()
    }
}

#[wasm_bindgen]
#[derive(Serialize, Deserialize, Debug)]
pub struct TransactionInput {
    #[wasm_bindgen(skip)]
    pub source_txid: String,
    pub source_output_index: u32,
    pub sequence: u32,
}

#[wasm_bindgen]
impl TransactionInput {
    #[wasm_bindgen(constructor)]
    pub fn new(source_txid: String, source_output_index: u32, sequence: u32) -> TransactionInput {
        TransactionInput {
            source_txid,
            source_output_index,
            sequence,
        }
    }
}

#[wasm_bindgen]
#[derive(Serialize, Deserialize, Debug)]
pub struct TransactionOutput {
    pub satoshis: u64,
    #[wasm_bindgen(skip)]
    pub locking_script: Vec<u8>,
}

#[wasm_bindgen]
impl TransactionOutput {
    #[wasm_bindgen(constructor)]
    pub fn new(satoshis: u64, locking_script: Vec<u8>) -> TransactionOutput {
        TransactionOutput {
            satoshis,
            locking_script,
        }
    }
}

#[wasm_bindgen]
#[derive(Serialize, Deserialize, Debug)]
pub struct Transaction {
    pub version: u32,
    #[wasm_bindgen(skip)]
    pub inputs: Vec<TransactionInput>,
    #[wasm_bindgen(skip)]
    pub outputs: Vec<TransactionOutput>,
    pub lock_time: u32,
}

#[wasm_bindgen]
impl Transaction {
    #[wasm_bindgen(constructor)]
    pub fn new(
        version: u32,
        inputs: Vec<TransactionInput>,
        outputs: Vec<TransactionOutput>,
        lock_time: u32,
    ) -> Transaction {
        Transaction {
            version,
            inputs,
            outputs,
            lock_time,
        }
    }
}

#[derive(Serialize, Deserialize, Debug)]
pub struct MultisigConfig {
    pub public_keys: Vec<PublicKey>,
    pub m: usize,
    pub sig_hash_type: u8,
}

#[derive(Serialize, Deserialize, Debug)]
pub struct Signature {
    pub r: Vec<u8>,
    pub s: Vec<u8>,
    pub sighash_type: u8,
}