@leofcoin/chain 1.5.31 → 1.5.33

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1,5 +1,5 @@
1
- import { M as MultiWallet, e as encrypt, b as base58$1 } from './node-browser-ccafb3fc.js';
2
- import './index-055d5584.js';
1
+ import { M as MultiWallet, e as encrypt, b as base58$1 } from './node-browser-634c6b24.js';
2
+ import './index-3e3995e1.js';
3
3
 
4
4
  /**
5
5
  * @params {String} network
@@ -1,225 +1,215 @@
1
- import { F as FormatInterface } from './node-browser-ccafb3fc.js';
2
- import './index-055d5584.js';
3
-
4
- var proto$b = {
5
- data: new Uint8Array(),
6
- signature: new Uint8Array(),
7
- 'from?': String(),
8
- 'to?': String(),
9
- 'id?': String()
1
+ import { F as FormatInterface } from './node-browser-634c6b24.js';
2
+ import './index-3e3995e1.js';
3
+
4
+ var proto$b = {
5
+ data: new Uint8Array(),
6
+ signature: new Uint8Array(),
7
+ 'from?': String(),
8
+ 'to?': String(),
9
+ 'id?': String()
10
10
  };
11
11
 
12
- class PeernetMessage extends FormatInterface {
13
-
14
- get messageName() {
15
- return 'PeernetMessage'
16
- }
17
-
18
- constructor(buffer) {
19
- const name = 'peernet-message';
20
- super(buffer, proto$b, {name});
21
- }
12
+ class PeernetMessage extends FormatInterface {
13
+ get messageName() {
14
+ return 'PeernetMessage'
15
+ }
16
+
17
+ constructor(buffer) {
18
+ const name = 'peernet-message';
19
+ super(buffer, proto$b, { name });
20
+ }
22
21
  }
23
22
 
24
- var proto$a = {
25
- hash: String(),
26
- 'store?': String()
23
+ var proto$a = {
24
+ hash: String(),
25
+ 'store?': String()
27
26
  };
28
27
 
29
- /**
30
- * @example `
31
- new DHTMessage(hash, store)
32
- // store = optional if not set, peernet checks every store
33
- let message = new DHTMessage('hashmvbs124xcfd...', 'transaction')
34
- message = new DHTMessage('hashmvbs124xcfd...', 'block')
35
- `
36
- */
37
- class DHTMessage extends FormatInterface {
38
-
39
- get messageName() {
40
- return 'PeernetDHTMessage'
41
- }
42
-
43
- constructor(data) {
44
- const name = 'peernet-dht';
45
- super(data, proto$a, {name});
46
- }
28
+ /**
29
+ * @example `
30
+ new DHTMessage(hash, store)
31
+ // store = optional if not set, peernet checks every store
32
+ let message = new DHTMessage('hashmvbs124xcfd...', 'transaction')
33
+ message = new DHTMessage('hashmvbs124xcfd...', 'block')
34
+ `
35
+ */
36
+ class DHTMessage extends FormatInterface {
37
+ get messageName() {
38
+ return 'PeernetDHTMessage'
39
+ }
40
+
41
+ constructor(data) {
42
+ const name = 'peernet-dht';
43
+ super(data, proto$a, { name });
44
+ }
47
45
  }
48
46
 
49
- var proto$9 = {
50
- hash: String(),
51
- has: Boolean()
47
+ var proto$9 = {
48
+ hash: String(),
49
+ has: Boolean()
52
50
  };
53
51
 
54
- class DHTMessageResponse extends FormatInterface {
55
-
56
- get messageName() {
57
- return 'PeernetDHTMessageResponse'
58
- }
59
-
60
- constructor(data) {
61
- const name = 'peernet-dht-response';
62
- super(data, proto$9, {name});
63
- }
52
+ class DHTMessageResponse extends FormatInterface {
53
+ get messageName() {
54
+ return 'PeernetDHTMessageResponse'
55
+ }
56
+
57
+ constructor(data) {
58
+ const name = 'peernet-dht-response';
59
+ super(data, proto$9, { name });
60
+ }
64
61
  }
65
62
 
66
- var proto$8 = {
67
- hash: String(),
68
- 'store?': String()
63
+ var proto$8 = {
64
+ hash: String(),
65
+ 'store?': String()
69
66
  };
70
67
 
71
- /**
72
- * @extends {CodecFormat}
73
- */
74
- class DataMessage extends FormatInterface {
75
-
76
- get messageName() {
77
- return 'PeernetDataMessage'
78
- }
79
- /**
80
- * @param {Buffer|String|Object|DataMessage} data - The data needed to create the DataMessage
81
- */
82
- constructor(data) {
83
- super(data, proto$8, {name: 'peernet-data'});
84
- }
68
+ /**
69
+ * @extends {CodecFormat}
70
+ */
71
+ class DataMessage extends FormatInterface {
72
+ get messageName() {
73
+ return 'PeernetDataMessage'
74
+ }
75
+ /**
76
+ * @param {Buffer|String|Object|DataMessage} data - The data needed to create the DataMessage
77
+ */
78
+ constructor(data) {
79
+ super(data, proto$8, { name: 'peernet-data' });
80
+ }
85
81
  }
86
82
 
87
- var proto$7 = {
88
- data: new Uint8Array(),
89
- topic: new Uint8Array()
83
+ var proto$7 = {
84
+ data: new Uint8Array(),
85
+ topic: new Uint8Array()
90
86
  };
91
87
 
92
- class PsMessage extends FormatInterface {
93
- get messageName() {
94
- return 'PsMessage'
95
- }
96
-
97
- constructor(buffer) {
98
- const name = 'peernet-ps';
99
- super(buffer, proto$7, {name});
100
- }
88
+ class PsMessage extends FormatInterface {
89
+ get messageName() {
90
+ return 'PsMessage'
91
+ }
92
+
93
+ constructor(buffer) {
94
+ const name = 'peernet-ps';
95
+ super(buffer, proto$7, { name });
96
+ }
101
97
  }
102
98
 
103
- var proto$6 = {
104
- id: String()
99
+ var proto$6 = {
100
+ id: String()
105
101
  };
106
102
 
107
- class PeerMessage extends FormatInterface {
108
- get messageName() {
109
- return 'PeernetPeerMessage'
110
- }
111
-
112
- constructor(data) {
113
- const name = 'peernet-peer';
114
- super(data, proto$6, {name});
115
- }
103
+ class PeerMessage extends FormatInterface {
104
+ get messageName() {
105
+ return 'PeernetPeerMessage'
106
+ }
107
+
108
+ constructor(data) {
109
+ const name = 'peernet-peer';
110
+ super(data, proto$6, { name });
111
+ }
116
112
  }
117
113
 
118
- var proto$5 = {
119
- request: String(),
120
- 'requested?': new Uint8Array()
114
+ var proto$5 = {
115
+ request: String(),
116
+ 'requested?': new Uint8Array()
121
117
  };
122
118
 
123
- class RequestMessage extends FormatInterface {
124
-
125
- get messageName() {
126
- return 'PeernetRequestMessage'
127
- }
128
-
129
- constructor(data) {
130
- const name = 'peernet-request';
131
- super(data, proto$5, {name});
132
- }
119
+ class RequestMessage extends FormatInterface {
120
+ get messageName() {
121
+ return 'PeernetRequestMessage'
122
+ }
123
+
124
+ constructor(data) {
125
+ const name = 'peernet-request';
126
+ super(data, proto$5, { name });
127
+ }
133
128
  }
134
129
 
135
- var proto$4 = {
136
- response: {}
130
+ var proto$4 = {
131
+ response: {}
137
132
  };
138
133
 
139
- class ResponseMessage extends FormatInterface {
140
-
141
- get messageName() {
142
- return 'PeernetResponseMessage'
143
- }
144
-
145
- constructor(data) {
146
- const name = 'peernet-response';
147
- super(data, proto$4, {name});
148
- }
134
+ class ResponseMessage extends FormatInterface {
135
+ get messageName() {
136
+ return 'PeernetResponseMessage'
137
+ }
138
+
139
+ constructor(data) {
140
+ const name = 'peernet-response';
141
+ super(data, proto$4, { name });
142
+ }
149
143
  }
150
144
 
151
- var proto$3 = {
152
- id: String()
145
+ var proto$3 = {
146
+ id: String()
153
147
  };
154
148
 
155
- class PeerMessageResponse extends FormatInterface {
156
-
157
- get messageName() {
158
- return 'PeernetPeerMessageResponse'
159
- }
160
-
161
- constructor(data) {
162
- const name = 'peernet-peer-response';
163
- super(data, proto$3, {name});
164
- }
149
+ class PeerMessageResponse extends FormatInterface {
150
+ get messageName() {
151
+ return 'PeernetPeerMessageResponse'
152
+ }
153
+
154
+ constructor(data) {
155
+ const name = 'peernet-peer-response';
156
+ super(data, proto$3, { name });
157
+ }
165
158
  }
166
159
 
167
- var proto$2 = {
168
- hash: String(),
169
- data: new Uint8Array(),
160
+ var proto$2 = {
161
+ hash: String(),
162
+ data: new Uint8Array()
170
163
  };
171
164
 
172
- class DataMessageResponse extends FormatInterface {
173
-
174
- get messageName() {
175
- return 'PeernetDataMessageResponse'
176
- }
177
-
178
- constructor(data) {
179
- const name = 'peernet-data-response';
180
- super(data, proto$2, {name});
181
- }
165
+ class DataMessageResponse extends FormatInterface {
166
+ get messageName() {
167
+ return 'PeernetDataMessageResponse'
168
+ }
169
+
170
+ constructor(data) {
171
+ const name = 'peernet-data-response';
172
+ super(data, proto$2, { name });
173
+ }
182
174
  }
183
175
 
184
- var proto$1 = {
185
- value: String(),
186
- author: String(),
187
- timestamp: Number(),
188
- files: [String()],
176
+ var proto$1 = {
177
+ value: String(),
178
+ author: String(),
179
+ timestamp: Number(),
180
+ files: [String()]
189
181
  };
190
182
 
191
- class ChatMessage extends FormatInterface {
192
-
193
- get messageName() {
194
- return 'ChatMessage'
195
- }
196
-
197
- constructor(buffer) {
198
- const name = 'chat-message';
199
- super(buffer, proto$1, {name});
200
- }
183
+ class ChatMessage extends FormatInterface {
184
+ get messageName() {
185
+ return 'ChatMessage'
186
+ }
187
+
188
+ constructor(buffer) {
189
+ const name = 'chat-message';
190
+ super(buffer, proto$1, { name });
191
+ }
201
192
  }
202
193
 
203
- var proto = {
204
- path: String(),
205
- 'content?': '',
206
- 'links?': []
194
+ var proto = {
195
+ path: String(),
196
+ 'content?': '',
197
+ 'links?': []
207
198
  };
208
199
 
209
- /**
210
- * @extends {CodecFormat}
211
- */
212
- class PeernetFile extends FormatInterface {
213
-
214
- get messageName() {
215
- return 'PeernetFile'
216
- }
217
- /**
218
- * @param {Buffer|String|Object|DataMessage} data - The data needed to create the DataMessage
219
- */
220
- constructor(data) {
221
- super(data, proto, {name: 'peernet-file'});
222
- }
200
+ /**
201
+ * @extends {CodecFormat}
202
+ */
203
+ class PeernetFile extends FormatInterface {
204
+ get messageName() {
205
+ return 'PeernetFile'
206
+ }
207
+ /**
208
+ * @param {Buffer|String|Object|DataMessage} data - The data needed to create the DataMessage
209
+ */
210
+ constructor(data) {
211
+ super(data, proto, { name: 'peernet-file' });
212
+ }
223
213
  }
224
214
 
225
215
  export { ChatMessage, DHTMessage, DHTMessageResponse, DataMessage, DataMessageResponse, PeerMessage, PeerMessageResponse, PeernetFile, PeernetMessage, PsMessage, RequestMessage, ResponseMessage };