@canton-network/core-splice-client 0.16.2 → 0.16.3
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.
- package/dist/generated-clients/scan-proxy.d.ts +309 -37
- package/dist/generated-clients/scan-proxy.d.ts.map +1 -1
- package/dist/generated-clients/scan.d.ts +1754 -474
- package/dist/generated-clients/scan.d.ts.map +1 -1
- package/dist/generated-clients/validator-internal.d.ts +533 -161
- package/dist/generated-clients/validator-internal.d.ts.map +1 -1
- package/package.json +3 -3
|
@@ -1,420 +1,1304 @@
|
|
|
1
1
|
export interface paths {
|
|
2
2
|
'/readyz': {
|
|
3
|
+
parameters: {
|
|
4
|
+
query?: never;
|
|
5
|
+
header?: never;
|
|
6
|
+
path?: never;
|
|
7
|
+
cookie?: never;
|
|
8
|
+
};
|
|
3
9
|
get: operations['isReady'];
|
|
10
|
+
put?: never;
|
|
11
|
+
post?: never;
|
|
12
|
+
delete?: never;
|
|
13
|
+
options?: never;
|
|
14
|
+
head?: never;
|
|
15
|
+
patch?: never;
|
|
16
|
+
trace?: never;
|
|
4
17
|
};
|
|
5
18
|
'/livez': {
|
|
19
|
+
parameters: {
|
|
20
|
+
query?: never;
|
|
21
|
+
header?: never;
|
|
22
|
+
path?: never;
|
|
23
|
+
cookie?: never;
|
|
24
|
+
};
|
|
6
25
|
get: operations['isLive'];
|
|
26
|
+
put?: never;
|
|
27
|
+
post?: never;
|
|
28
|
+
delete?: never;
|
|
29
|
+
options?: never;
|
|
30
|
+
head?: never;
|
|
31
|
+
patch?: never;
|
|
32
|
+
trace?: never;
|
|
7
33
|
};
|
|
8
34
|
'/status': {
|
|
35
|
+
parameters: {
|
|
36
|
+
query?: never;
|
|
37
|
+
header?: never;
|
|
38
|
+
path?: never;
|
|
39
|
+
cookie?: never;
|
|
40
|
+
};
|
|
9
41
|
get: operations['getHealthStatus'];
|
|
42
|
+
put?: never;
|
|
43
|
+
post?: never;
|
|
44
|
+
delete?: never;
|
|
45
|
+
options?: never;
|
|
46
|
+
head?: never;
|
|
47
|
+
patch?: never;
|
|
48
|
+
trace?: never;
|
|
10
49
|
};
|
|
11
50
|
'/version': {
|
|
51
|
+
parameters: {
|
|
52
|
+
query?: never;
|
|
53
|
+
header?: never;
|
|
54
|
+
path?: never;
|
|
55
|
+
cookie?: never;
|
|
56
|
+
};
|
|
12
57
|
get: operations['getVersion'];
|
|
58
|
+
put?: never;
|
|
59
|
+
post?: never;
|
|
60
|
+
delete?: never;
|
|
61
|
+
options?: never;
|
|
62
|
+
head?: never;
|
|
63
|
+
patch?: never;
|
|
64
|
+
trace?: never;
|
|
13
65
|
};
|
|
14
66
|
'/v0/dso': {
|
|
67
|
+
parameters: {
|
|
68
|
+
query?: never;
|
|
69
|
+
header?: never;
|
|
70
|
+
path?: never;
|
|
71
|
+
cookie?: never;
|
|
72
|
+
};
|
|
15
73
|
get: operations['getDsoInfo'];
|
|
74
|
+
put?: never;
|
|
75
|
+
post?: never;
|
|
76
|
+
delete?: never;
|
|
77
|
+
options?: never;
|
|
78
|
+
head?: never;
|
|
79
|
+
patch?: never;
|
|
80
|
+
trace?: never;
|
|
16
81
|
};
|
|
17
82
|
'/v0/validators/validator-faucets': {
|
|
83
|
+
parameters: {
|
|
84
|
+
query?: never;
|
|
85
|
+
header?: never;
|
|
86
|
+
path?: never;
|
|
87
|
+
cookie?: never;
|
|
88
|
+
};
|
|
18
89
|
/**
|
|
19
90
|
* @description For every argument that is a valid onboarded validator, return
|
|
20
|
-
*
|
|
21
|
-
*
|
|
91
|
+
* statistics on its liveness activity, according to on-ledger state at the
|
|
92
|
+
* time of the request.
|
|
22
93
|
*/
|
|
23
94
|
get: operations['getValidatorFaucetsByValidator'];
|
|
95
|
+
put?: never;
|
|
96
|
+
post?: never;
|
|
97
|
+
delete?: never;
|
|
98
|
+
options?: never;
|
|
99
|
+
head?: never;
|
|
100
|
+
patch?: never;
|
|
101
|
+
trace?: never;
|
|
24
102
|
};
|
|
25
103
|
'/v0/scans': {
|
|
104
|
+
parameters: {
|
|
105
|
+
query?: never;
|
|
106
|
+
header?: never;
|
|
107
|
+
path?: never;
|
|
108
|
+
cookie?: never;
|
|
109
|
+
};
|
|
26
110
|
/**
|
|
27
111
|
* @description Retrieve Canton scan configuration for all SVs, grouped by
|
|
28
|
-
*
|
|
112
|
+
* connected synchronizer ID
|
|
29
113
|
*/
|
|
30
114
|
get: operations['listDsoScans'];
|
|
115
|
+
put?: never;
|
|
116
|
+
post?: never;
|
|
117
|
+
delete?: never;
|
|
118
|
+
options?: never;
|
|
119
|
+
head?: never;
|
|
120
|
+
patch?: never;
|
|
121
|
+
trace?: never;
|
|
31
122
|
};
|
|
32
123
|
'/v0/admin/validator/licenses': {
|
|
124
|
+
parameters: {
|
|
125
|
+
query?: never;
|
|
126
|
+
header?: never;
|
|
127
|
+
path?: never;
|
|
128
|
+
cookie?: never;
|
|
129
|
+
};
|
|
33
130
|
/**
|
|
34
131
|
* @description List all validators currently approved by members of the DSO, paginated,
|
|
35
|
-
*
|
|
132
|
+
* sorted newest-first.
|
|
36
133
|
*/
|
|
37
134
|
get: operations['listValidatorLicenses'];
|
|
135
|
+
put?: never;
|
|
136
|
+
post?: never;
|
|
137
|
+
delete?: never;
|
|
138
|
+
options?: never;
|
|
139
|
+
head?: never;
|
|
140
|
+
patch?: never;
|
|
141
|
+
trace?: never;
|
|
38
142
|
};
|
|
39
143
|
'/v0/dso-sequencers': {
|
|
144
|
+
parameters: {
|
|
145
|
+
query?: never;
|
|
146
|
+
header?: never;
|
|
147
|
+
path?: never;
|
|
148
|
+
cookie?: never;
|
|
149
|
+
};
|
|
40
150
|
/**
|
|
41
151
|
* @description Retrieve Canton sequencer configuration for all SVs, grouped by
|
|
42
|
-
*
|
|
152
|
+
* connected synchronizer ID
|
|
43
153
|
*/
|
|
44
154
|
get: operations['listDsoSequencers'];
|
|
155
|
+
put?: never;
|
|
156
|
+
post?: never;
|
|
157
|
+
delete?: never;
|
|
158
|
+
options?: never;
|
|
159
|
+
head?: never;
|
|
160
|
+
patch?: never;
|
|
161
|
+
trace?: never;
|
|
45
162
|
};
|
|
46
163
|
'/v0/sv-bft-sequencers': {
|
|
164
|
+
parameters: {
|
|
165
|
+
query?: never;
|
|
166
|
+
header?: never;
|
|
167
|
+
path?: never;
|
|
168
|
+
cookie?: never;
|
|
169
|
+
};
|
|
47
170
|
/** @description Retrieve Canton BFT sequencer configuration for this SV, for each configured Synchronizer */
|
|
48
171
|
get: operations['listSvBftSequencers'];
|
|
172
|
+
put?: never;
|
|
173
|
+
post?: never;
|
|
174
|
+
delete?: never;
|
|
175
|
+
options?: never;
|
|
176
|
+
head?: never;
|
|
177
|
+
patch?: never;
|
|
178
|
+
trace?: never;
|
|
49
179
|
};
|
|
50
180
|
'/v0/domains/{domain_id}/parties/{party_id}/participant-id': {
|
|
181
|
+
parameters: {
|
|
182
|
+
query?: never;
|
|
183
|
+
header?: never;
|
|
184
|
+
path?: never;
|
|
185
|
+
cookie?: never;
|
|
186
|
+
};
|
|
51
187
|
/**
|
|
52
188
|
* @description Get the ID of the participant hosting a given party. This will fail if
|
|
53
|
-
*
|
|
54
|
-
*
|
|
189
|
+
* there are multiple party-to-participant mappings for the given
|
|
190
|
+
* synchronizer and party, which is not currently supported.
|
|
55
191
|
*/
|
|
56
192
|
get: operations['getPartyToParticipant'];
|
|
193
|
+
put?: never;
|
|
194
|
+
post?: never;
|
|
195
|
+
delete?: never;
|
|
196
|
+
options?: never;
|
|
197
|
+
head?: never;
|
|
198
|
+
patch?: never;
|
|
199
|
+
trace?: never;
|
|
57
200
|
};
|
|
58
201
|
'/v0/domains/{domain_id}/members/{member_id}/traffic-status': {
|
|
202
|
+
parameters: {
|
|
203
|
+
query?: never;
|
|
204
|
+
header?: never;
|
|
205
|
+
path?: never;
|
|
206
|
+
cookie?: never;
|
|
207
|
+
};
|
|
59
208
|
/**
|
|
60
209
|
* @description Get a member's traffic status as reported by the sequencer, according to
|
|
61
|
-
*
|
|
210
|
+
* ledger state at the time of the request.
|
|
62
211
|
*/
|
|
63
212
|
get: operations['getMemberTrafficStatus'];
|
|
213
|
+
put?: never;
|
|
214
|
+
post?: never;
|
|
215
|
+
delete?: never;
|
|
216
|
+
options?: never;
|
|
217
|
+
head?: never;
|
|
218
|
+
patch?: never;
|
|
219
|
+
trace?: never;
|
|
64
220
|
};
|
|
65
221
|
'/v0/closed-rounds': {
|
|
222
|
+
parameters: {
|
|
223
|
+
query?: never;
|
|
224
|
+
header?: never;
|
|
225
|
+
path?: never;
|
|
226
|
+
cookie?: never;
|
|
227
|
+
};
|
|
66
228
|
/**
|
|
67
229
|
* @description Every closed mining round on the ledger still in post-close process for
|
|
68
|
-
*
|
|
230
|
+
* the connected Splice network, in round number order, earliest-first.
|
|
69
231
|
*/
|
|
70
232
|
get: operations['getClosedRounds'];
|
|
233
|
+
put?: never;
|
|
234
|
+
post?: never;
|
|
235
|
+
delete?: never;
|
|
236
|
+
options?: never;
|
|
237
|
+
head?: never;
|
|
238
|
+
patch?: never;
|
|
239
|
+
trace?: never;
|
|
71
240
|
};
|
|
72
241
|
'/v0/open-and-issuing-mining-rounds': {
|
|
242
|
+
parameters: {
|
|
243
|
+
query?: never;
|
|
244
|
+
header?: never;
|
|
245
|
+
path?: never;
|
|
246
|
+
cookie?: never;
|
|
247
|
+
};
|
|
248
|
+
get?: never;
|
|
249
|
+
put?: never;
|
|
73
250
|
/**
|
|
74
251
|
* @description All current open and issuing mining rounds, if the request is empty;
|
|
75
|
-
*
|
|
76
|
-
*
|
|
252
|
+
* passing contract IDs in the request can reduce the response data for
|
|
253
|
+
* polling/client-cache-update efficiency.
|
|
77
254
|
*/
|
|
78
255
|
post: operations['getOpenAndIssuingMiningRounds'];
|
|
256
|
+
delete?: never;
|
|
257
|
+
options?: never;
|
|
258
|
+
head?: never;
|
|
259
|
+
patch?: never;
|
|
260
|
+
trace?: never;
|
|
79
261
|
};
|
|
80
262
|
'/v2/updates': {
|
|
263
|
+
parameters: {
|
|
264
|
+
query?: never;
|
|
265
|
+
header?: never;
|
|
266
|
+
path?: never;
|
|
267
|
+
cookie?: never;
|
|
268
|
+
};
|
|
269
|
+
get?: never;
|
|
270
|
+
put?: never;
|
|
81
271
|
/**
|
|
82
272
|
* @description Returns the update history in ascending order, paged, from ledger begin or optionally starting after a record time.
|
|
83
|
-
*
|
|
84
|
-
*
|
|
85
|
-
*
|
|
86
|
-
*
|
|
87
|
-
*
|
|
88
|
-
*
|
|
89
|
-
*
|
|
90
|
-
*
|
|
91
|
-
*
|
|
273
|
+
* Compared to `/v1/updates`, the `/v2/updates` removes the `offset` field in responses,
|
|
274
|
+
* which was hardcoded to 1 in `/v1/updates` for compatibility, and is now removed.
|
|
275
|
+
* `/v2/updates` sorts events lexicographically in `events_by_id` by `ID` for convenience, which should not be confused with the
|
|
276
|
+
* order of events in the transaction, for this you should rely on the order of `root_event_ids` and `child_event_ids`.
|
|
277
|
+
* Updates are ordered lexicographically by `(migration id, record time)`.
|
|
278
|
+
* For a given migration id, each update has a unique record time.
|
|
279
|
+
* The record time ranges of different migrations may overlap, i.e.,
|
|
280
|
+
* it is not guaranteed that the maximum record time of one migration is smaller than the minimum record time of the next migration,
|
|
281
|
+
* and there may be two updates with the same record time but different migration ids.
|
|
92
282
|
*/
|
|
93
283
|
post: operations['getUpdateHistoryV2'];
|
|
284
|
+
delete?: never;
|
|
285
|
+
options?: never;
|
|
286
|
+
head?: never;
|
|
287
|
+
patch?: never;
|
|
288
|
+
trace?: never;
|
|
94
289
|
};
|
|
95
290
|
'/v2/updates/{update_id}': {
|
|
291
|
+
parameters: {
|
|
292
|
+
query?: never;
|
|
293
|
+
header?: never;
|
|
294
|
+
path?: never;
|
|
295
|
+
cookie?: never;
|
|
296
|
+
};
|
|
96
297
|
/**
|
|
97
298
|
* @description Returns the update with the given update_id.
|
|
98
|
-
*
|
|
99
|
-
*
|
|
100
|
-
*
|
|
101
|
-
*
|
|
299
|
+
* Compared to `/v1/updates/{update_id}`, the `/v2/updates/{update_id}` removes the `offset` field in responses,
|
|
300
|
+
* which was hardcoded to 1 in `/v1/updates/{update_id}` for compatibility, and is now removed.
|
|
301
|
+
* `/v2/updates/{update_id}` sorts events lexicographically in `events_by_id` by `ID` for convenience, which should not be confused with the
|
|
302
|
+
* order of events in the transaction, for this you should rely on the order of `root_event_ids` and `child_event_ids`.
|
|
102
303
|
*/
|
|
103
304
|
get: operations['getUpdateByIdV2'];
|
|
305
|
+
put?: never;
|
|
306
|
+
post?: never;
|
|
307
|
+
delete?: never;
|
|
308
|
+
options?: never;
|
|
309
|
+
head?: never;
|
|
310
|
+
patch?: never;
|
|
311
|
+
trace?: never;
|
|
104
312
|
};
|
|
105
313
|
'/v1/updates': {
|
|
314
|
+
parameters: {
|
|
315
|
+
query?: never;
|
|
316
|
+
header?: never;
|
|
317
|
+
path?: never;
|
|
318
|
+
cookie?: never;
|
|
319
|
+
};
|
|
320
|
+
get?: never;
|
|
321
|
+
put?: never;
|
|
106
322
|
/**
|
|
107
323
|
* @deprecated
|
|
108
324
|
* @description Returns the update history in ascending order, paged, from ledger begin or optionally starting after a record time.
|
|
109
|
-
*
|
|
110
|
-
*
|
|
325
|
+
* Unlike /v0/updates, this endpoint returns responses that are consistent across different
|
|
326
|
+
* scan instances. Event ids returned by this endpoint are not comparable to event ids returned by /v0/updates.
|
|
111
327
|
*
|
|
112
|
-
*
|
|
113
|
-
*
|
|
114
|
-
*
|
|
115
|
-
*
|
|
116
|
-
*
|
|
117
|
-
*
|
|
328
|
+
* Updates are ordered lexicographically by `(migration id, record time)`.
|
|
329
|
+
* For a given migration id, each update has a unique record time.
|
|
330
|
+
* The record time ranges of different migrations may overlap, i.e.,
|
|
331
|
+
* it is not guaranteed that the maximum record time of one migration is smaller than the minimum record time of the next migration,
|
|
332
|
+
* and there may be two updates with the same record time but different migration ids.
|
|
333
|
+
* The order of items in events_by_id is not defined.
|
|
118
334
|
*/
|
|
119
335
|
post: operations['getUpdateHistoryV1'];
|
|
336
|
+
delete?: never;
|
|
337
|
+
options?: never;
|
|
338
|
+
head?: never;
|
|
339
|
+
patch?: never;
|
|
340
|
+
trace?: never;
|
|
120
341
|
};
|
|
121
342
|
'/v1/updates/{update_id}': {
|
|
343
|
+
parameters: {
|
|
344
|
+
query?: never;
|
|
345
|
+
header?: never;
|
|
346
|
+
path?: never;
|
|
347
|
+
cookie?: never;
|
|
348
|
+
};
|
|
122
349
|
/**
|
|
123
350
|
* @deprecated
|
|
124
351
|
* @description Returns the update with the given update_id.
|
|
125
|
-
*
|
|
126
|
-
*
|
|
127
|
-
*
|
|
352
|
+
* Unlike /v0/updates/{update_id}, this endpoint returns responses that are consistent across different
|
|
353
|
+
* scan instances. Event ids returned by this endpoint are not comparable to event ids returned by /v0/updates.
|
|
354
|
+
* The order of items in events_by_id is not defined.
|
|
128
355
|
*/
|
|
129
356
|
get: operations['getUpdateByIdV1'];
|
|
357
|
+
put?: never;
|
|
358
|
+
post?: never;
|
|
359
|
+
delete?: never;
|
|
360
|
+
options?: never;
|
|
361
|
+
head?: never;
|
|
362
|
+
patch?: never;
|
|
363
|
+
trace?: never;
|
|
130
364
|
};
|
|
131
365
|
'/v0/state/acs/snapshot-timestamp': {
|
|
366
|
+
parameters: {
|
|
367
|
+
query?: never;
|
|
368
|
+
header?: never;
|
|
369
|
+
path?: never;
|
|
370
|
+
cookie?: never;
|
|
371
|
+
};
|
|
132
372
|
/**
|
|
133
373
|
* @description Returns the timestamp of the most recent snapshot before the given date, for the given migration_id.
|
|
134
|
-
*
|
|
374
|
+
* This corresponds to the record time of the last transaction in the snapshot.
|
|
135
375
|
*/
|
|
136
376
|
get: operations['getDateOfMostRecentSnapshotBefore'];
|
|
377
|
+
put?: never;
|
|
378
|
+
post?: never;
|
|
379
|
+
delete?: never;
|
|
380
|
+
options?: never;
|
|
381
|
+
head?: never;
|
|
382
|
+
patch?: never;
|
|
383
|
+
trace?: never;
|
|
137
384
|
};
|
|
138
385
|
'/v0/state/acs': {
|
|
386
|
+
parameters: {
|
|
387
|
+
query?: never;
|
|
388
|
+
header?: never;
|
|
389
|
+
path?: never;
|
|
390
|
+
cookie?: never;
|
|
391
|
+
};
|
|
392
|
+
get?: never;
|
|
393
|
+
put?: never;
|
|
139
394
|
/** @description Returns the ACS in creation date ascending order, paged, for a given migration id and record time. */
|
|
140
395
|
post: operations['getAcsSnapshotAt'];
|
|
396
|
+
delete?: never;
|
|
397
|
+
options?: never;
|
|
398
|
+
head?: never;
|
|
399
|
+
patch?: never;
|
|
400
|
+
trace?: never;
|
|
141
401
|
};
|
|
142
402
|
'/v0/state/acs/force': {
|
|
403
|
+
parameters: {
|
|
404
|
+
query?: never;
|
|
405
|
+
header?: never;
|
|
406
|
+
path?: never;
|
|
407
|
+
cookie?: never;
|
|
408
|
+
};
|
|
409
|
+
get?: never;
|
|
410
|
+
put?: never;
|
|
143
411
|
/**
|
|
144
412
|
* @description Takes a snapshot of the ACS at the current time.
|
|
145
|
-
*
|
|
146
|
-
*
|
|
147
|
-
*
|
|
148
|
-
*
|
|
413
|
+
* The responses can be used as parameters to `/v0/state/acs` to retrieve the snapshot.
|
|
414
|
+
* Disabled in production environments due to its persistent alteration of
|
|
415
|
+
* the behavior of future invocations of `/v0/state/acs`, as it causes an
|
|
416
|
+
* immediate internal snapshot and delay in the next automatic snapshot.
|
|
149
417
|
*/
|
|
150
418
|
post: operations['forceAcsSnapshotNow'];
|
|
419
|
+
delete?: never;
|
|
420
|
+
options?: never;
|
|
421
|
+
head?: never;
|
|
422
|
+
patch?: never;
|
|
423
|
+
trace?: never;
|
|
151
424
|
};
|
|
152
425
|
'/v0/holdings/state': {
|
|
426
|
+
parameters: {
|
|
427
|
+
query?: never;
|
|
428
|
+
header?: never;
|
|
429
|
+
path?: never;
|
|
430
|
+
cookie?: never;
|
|
431
|
+
};
|
|
432
|
+
get?: never;
|
|
433
|
+
put?: never;
|
|
153
434
|
/** @description Returns the active amulet contracts for a given migration id and record time, in creation date ascending order, paged. */
|
|
154
435
|
post: operations['getHoldingsStateAt'];
|
|
436
|
+
delete?: never;
|
|
437
|
+
options?: never;
|
|
438
|
+
head?: never;
|
|
439
|
+
patch?: never;
|
|
440
|
+
trace?: never;
|
|
155
441
|
};
|
|
156
442
|
'/v0/holdings/summary': {
|
|
443
|
+
parameters: {
|
|
444
|
+
query?: never;
|
|
445
|
+
header?: never;
|
|
446
|
+
path?: never;
|
|
447
|
+
cookie?: never;
|
|
448
|
+
};
|
|
449
|
+
get?: never;
|
|
450
|
+
put?: never;
|
|
157
451
|
/**
|
|
158
452
|
* @description Returns the summary of active amulet contracts for a given migration id and record time, for the given parties.
|
|
159
|
-
*
|
|
453
|
+
* This is an aggregate of `/v0/holdings/state` by owner party ID with better performance than client-side computation.
|
|
160
454
|
*/
|
|
161
455
|
post: operations['getHoldingsSummaryAt'];
|
|
456
|
+
delete?: never;
|
|
457
|
+
options?: never;
|
|
458
|
+
head?: never;
|
|
459
|
+
patch?: never;
|
|
460
|
+
trace?: never;
|
|
162
461
|
};
|
|
163
462
|
'/v0/ans-entries': {
|
|
463
|
+
parameters: {
|
|
464
|
+
query?: never;
|
|
465
|
+
header?: never;
|
|
466
|
+
path?: never;
|
|
467
|
+
cookie?: never;
|
|
468
|
+
};
|
|
164
469
|
/**
|
|
165
470
|
* @description Lists all non-expired ANS entries whose names are prefixed with the
|
|
166
|
-
*
|
|
471
|
+
* `name_prefix`, up to `page_size` entries.
|
|
167
472
|
*/
|
|
168
473
|
get: operations['listAnsEntries'];
|
|
474
|
+
put?: never;
|
|
475
|
+
post?: never;
|
|
476
|
+
delete?: never;
|
|
477
|
+
options?: never;
|
|
478
|
+
head?: never;
|
|
479
|
+
patch?: never;
|
|
480
|
+
trace?: never;
|
|
169
481
|
};
|
|
170
482
|
'/v0/ans-entries/by-party/{party}': {
|
|
483
|
+
parameters: {
|
|
484
|
+
query?: never;
|
|
485
|
+
header?: never;
|
|
486
|
+
path?: never;
|
|
487
|
+
cookie?: never;
|
|
488
|
+
};
|
|
171
489
|
/**
|
|
172
490
|
* @description If present, the first ANS entry for user `party` according to
|
|
173
|
-
*
|
|
491
|
+
* `name` lexicographic order.
|
|
174
492
|
*/
|
|
175
493
|
get: operations['lookupAnsEntryByParty'];
|
|
494
|
+
put?: never;
|
|
495
|
+
post?: never;
|
|
496
|
+
delete?: never;
|
|
497
|
+
options?: never;
|
|
498
|
+
head?: never;
|
|
499
|
+
patch?: never;
|
|
500
|
+
trace?: never;
|
|
176
501
|
};
|
|
177
502
|
'/v0/ans-entries/by-name/{name}': {
|
|
503
|
+
parameters: {
|
|
504
|
+
query?: never;
|
|
505
|
+
header?: never;
|
|
506
|
+
path?: never;
|
|
507
|
+
cookie?: never;
|
|
508
|
+
};
|
|
178
509
|
/** @description If present, the ANS entry named exactly `name`. */
|
|
179
510
|
get: operations['lookupAnsEntryByName'];
|
|
511
|
+
put?: never;
|
|
512
|
+
post?: never;
|
|
513
|
+
delete?: never;
|
|
514
|
+
options?: never;
|
|
515
|
+
head?: never;
|
|
516
|
+
patch?: never;
|
|
517
|
+
trace?: never;
|
|
180
518
|
};
|
|
181
519
|
'/v0/dso-party-id': {
|
|
520
|
+
parameters: {
|
|
521
|
+
query?: never;
|
|
522
|
+
header?: never;
|
|
523
|
+
path?: never;
|
|
524
|
+
cookie?: never;
|
|
525
|
+
};
|
|
182
526
|
/** @description The party ID of the DSO for the Splice network connected by this Scan app. */
|
|
183
527
|
get: operations['getDsoPartyId'];
|
|
528
|
+
put?: never;
|
|
529
|
+
post?: never;
|
|
530
|
+
delete?: never;
|
|
531
|
+
options?: never;
|
|
532
|
+
head?: never;
|
|
533
|
+
patch?: never;
|
|
534
|
+
trace?: never;
|
|
184
535
|
};
|
|
185
536
|
'/v0/amulet-rules': {
|
|
537
|
+
parameters: {
|
|
538
|
+
query?: never;
|
|
539
|
+
header?: never;
|
|
540
|
+
path?: never;
|
|
541
|
+
cookie?: never;
|
|
542
|
+
};
|
|
543
|
+
get?: never;
|
|
544
|
+
put?: never;
|
|
186
545
|
post: operations['getAmuletRules'];
|
|
546
|
+
delete?: never;
|
|
547
|
+
options?: never;
|
|
548
|
+
head?: never;
|
|
549
|
+
patch?: never;
|
|
550
|
+
trace?: never;
|
|
187
551
|
};
|
|
188
552
|
'/v0/external-party-amulet-rules': {
|
|
553
|
+
parameters: {
|
|
554
|
+
query?: never;
|
|
555
|
+
header?: never;
|
|
556
|
+
path?: never;
|
|
557
|
+
cookie?: never;
|
|
558
|
+
};
|
|
559
|
+
get?: never;
|
|
560
|
+
put?: never;
|
|
189
561
|
post: operations['getExternalPartyAmuletRules'];
|
|
562
|
+
delete?: never;
|
|
563
|
+
options?: never;
|
|
564
|
+
head?: never;
|
|
565
|
+
patch?: never;
|
|
566
|
+
trace?: never;
|
|
190
567
|
};
|
|
191
568
|
'/v0/ans-rules': {
|
|
569
|
+
parameters: {
|
|
570
|
+
query?: never;
|
|
571
|
+
header?: never;
|
|
572
|
+
path?: never;
|
|
573
|
+
cookie?: never;
|
|
574
|
+
};
|
|
575
|
+
get?: never;
|
|
576
|
+
put?: never;
|
|
192
577
|
post: operations['getAnsRules'];
|
|
578
|
+
delete?: never;
|
|
579
|
+
options?: never;
|
|
580
|
+
head?: never;
|
|
581
|
+
patch?: never;
|
|
582
|
+
trace?: never;
|
|
193
583
|
};
|
|
194
584
|
'/v0/featured-apps': {
|
|
585
|
+
parameters: {
|
|
586
|
+
query?: never;
|
|
587
|
+
header?: never;
|
|
588
|
+
path?: never;
|
|
589
|
+
cookie?: never;
|
|
590
|
+
};
|
|
195
591
|
/** @description List every `FeaturedAppRight` registered with the DSO on the ledger. */
|
|
196
592
|
get: operations['listFeaturedAppRights'];
|
|
593
|
+
put?: never;
|
|
594
|
+
post?: never;
|
|
595
|
+
delete?: never;
|
|
596
|
+
options?: never;
|
|
597
|
+
head?: never;
|
|
598
|
+
patch?: never;
|
|
599
|
+
trace?: never;
|
|
197
600
|
};
|
|
198
601
|
'/v0/featured-apps/{provider_party_id}': {
|
|
602
|
+
parameters: {
|
|
603
|
+
query?: never;
|
|
604
|
+
header?: never;
|
|
605
|
+
path?: never;
|
|
606
|
+
cookie?: never;
|
|
607
|
+
};
|
|
199
608
|
/**
|
|
200
609
|
* @description If `provider_party_id` has a `FeaturedAppRight` registered with the DSO,
|
|
201
|
-
*
|
|
610
|
+
* return it; `featured_app_right` will be empty otherwise.
|
|
202
611
|
*/
|
|
203
612
|
get: operations['lookupFeaturedAppRight'];
|
|
613
|
+
put?: never;
|
|
614
|
+
post?: never;
|
|
615
|
+
delete?: never;
|
|
616
|
+
options?: never;
|
|
617
|
+
head?: never;
|
|
618
|
+
patch?: never;
|
|
619
|
+
trace?: never;
|
|
204
620
|
};
|
|
205
621
|
'/v0/top-validators-by-validator-faucets': {
|
|
622
|
+
parameters: {
|
|
623
|
+
query?: never;
|
|
624
|
+
header?: never;
|
|
625
|
+
path?: never;
|
|
626
|
+
cookie?: never;
|
|
627
|
+
};
|
|
206
628
|
/**
|
|
207
629
|
* @description Get a list of top validators by number of rounds in which they collected
|
|
208
|
-
*
|
|
630
|
+
* faucets, and basis statistics on their round collection history
|
|
209
631
|
*/
|
|
210
632
|
get: operations['getTopValidatorsByValidatorFaucets'];
|
|
633
|
+
put?: never;
|
|
634
|
+
post?: never;
|
|
635
|
+
delete?: never;
|
|
636
|
+
options?: never;
|
|
637
|
+
head?: never;
|
|
638
|
+
patch?: never;
|
|
639
|
+
trace?: never;
|
|
211
640
|
};
|
|
212
641
|
'/v0/transfer-preapprovals/by-party/{party}': {
|
|
642
|
+
parameters: {
|
|
643
|
+
query?: never;
|
|
644
|
+
header?: never;
|
|
645
|
+
path?: never;
|
|
646
|
+
cookie?: never;
|
|
647
|
+
};
|
|
213
648
|
/** @description Lookup a TransferPreapproval by the receiver party. */
|
|
214
649
|
get: operations['lookupTransferPreapprovalByParty'];
|
|
650
|
+
put?: never;
|
|
651
|
+
post?: never;
|
|
652
|
+
delete?: never;
|
|
653
|
+
options?: never;
|
|
654
|
+
head?: never;
|
|
655
|
+
patch?: never;
|
|
656
|
+
trace?: never;
|
|
215
657
|
};
|
|
216
658
|
'/v0/transfer-command-counter/{party}': {
|
|
659
|
+
parameters: {
|
|
660
|
+
query?: never;
|
|
661
|
+
header?: never;
|
|
662
|
+
path?: never;
|
|
663
|
+
cookie?: never;
|
|
664
|
+
};
|
|
217
665
|
/** @description Lookup a TransferCommandCounter by the receiver party. */
|
|
218
666
|
get: operations['lookupTransferCommandCounterByParty'];
|
|
667
|
+
put?: never;
|
|
668
|
+
post?: never;
|
|
669
|
+
delete?: never;
|
|
670
|
+
options?: never;
|
|
671
|
+
head?: never;
|
|
672
|
+
patch?: never;
|
|
673
|
+
trace?: never;
|
|
219
674
|
};
|
|
220
675
|
'/v0/transfer-command/status': {
|
|
676
|
+
parameters: {
|
|
677
|
+
query?: never;
|
|
678
|
+
header?: never;
|
|
679
|
+
path?: never;
|
|
680
|
+
cookie?: never;
|
|
681
|
+
};
|
|
221
682
|
/** @description Retrieve the status of all transfer commands (up to a limit of 100) of the given sender for the specified nonce. */
|
|
222
683
|
get: operations['lookupTransferCommandStatus'];
|
|
684
|
+
put?: never;
|
|
685
|
+
post?: never;
|
|
686
|
+
delete?: never;
|
|
687
|
+
options?: never;
|
|
688
|
+
head?: never;
|
|
689
|
+
patch?: never;
|
|
690
|
+
trace?: never;
|
|
223
691
|
};
|
|
224
692
|
'/v0/migrations/schedule': {
|
|
693
|
+
parameters: {
|
|
694
|
+
query?: never;
|
|
695
|
+
header?: never;
|
|
696
|
+
path?: never;
|
|
697
|
+
cookie?: never;
|
|
698
|
+
};
|
|
225
699
|
/**
|
|
226
700
|
* @description If the DSO has scheduled a synchronizer upgrade, return its planned time
|
|
227
|
-
*
|
|
701
|
+
* and the new migration ID.
|
|
228
702
|
*/
|
|
229
703
|
get: operations['getMigrationSchedule'];
|
|
704
|
+
put?: never;
|
|
705
|
+
post?: never;
|
|
706
|
+
delete?: never;
|
|
707
|
+
options?: never;
|
|
708
|
+
head?: never;
|
|
709
|
+
patch?: never;
|
|
710
|
+
trace?: never;
|
|
230
711
|
};
|
|
231
712
|
'/v0/synchronizer-identities/{domain_id_prefix}': {
|
|
713
|
+
parameters: {
|
|
714
|
+
query?: never;
|
|
715
|
+
header?: never;
|
|
716
|
+
path?: never;
|
|
717
|
+
cookie?: never;
|
|
718
|
+
};
|
|
232
719
|
get: operations['getSynchronizerIdentities'];
|
|
720
|
+
put?: never;
|
|
721
|
+
post?: never;
|
|
722
|
+
delete?: never;
|
|
723
|
+
options?: never;
|
|
724
|
+
head?: never;
|
|
725
|
+
patch?: never;
|
|
726
|
+
trace?: never;
|
|
233
727
|
};
|
|
234
728
|
'/v0/synchronizer-bootstrapping-transactions/{domain_id_prefix}': {
|
|
729
|
+
parameters: {
|
|
730
|
+
query?: never;
|
|
731
|
+
header?: never;
|
|
732
|
+
path?: never;
|
|
733
|
+
cookie?: never;
|
|
734
|
+
};
|
|
235
735
|
get: operations['getSynchronizerBootstrappingTransactions'];
|
|
736
|
+
put?: never;
|
|
737
|
+
post?: never;
|
|
738
|
+
delete?: never;
|
|
739
|
+
options?: never;
|
|
740
|
+
head?: never;
|
|
741
|
+
patch?: never;
|
|
742
|
+
trace?: never;
|
|
236
743
|
};
|
|
237
744
|
'/v0/splice-instance-names': {
|
|
745
|
+
parameters: {
|
|
746
|
+
query?: never;
|
|
747
|
+
header?: never;
|
|
748
|
+
path?: never;
|
|
749
|
+
cookie?: never;
|
|
750
|
+
};
|
|
238
751
|
/** @description Retrieve the UI names of various elements of this Splice network. */
|
|
239
752
|
get: operations['getSpliceInstanceNames'];
|
|
753
|
+
put?: never;
|
|
754
|
+
post?: never;
|
|
755
|
+
delete?: never;
|
|
756
|
+
options?: never;
|
|
757
|
+
head?: never;
|
|
758
|
+
patch?: never;
|
|
759
|
+
trace?: never;
|
|
240
760
|
};
|
|
241
761
|
'/v0/amulet-price/votes': {
|
|
762
|
+
parameters: {
|
|
763
|
+
query?: never;
|
|
764
|
+
header?: never;
|
|
765
|
+
path?: never;
|
|
766
|
+
cookie?: never;
|
|
767
|
+
};
|
|
242
768
|
/** @description Retrieve a list of the latest amulet price votes */
|
|
243
769
|
get: operations['listAmuletPriceVotes'];
|
|
770
|
+
put?: never;
|
|
771
|
+
post?: never;
|
|
772
|
+
delete?: never;
|
|
773
|
+
options?: never;
|
|
774
|
+
head?: never;
|
|
775
|
+
patch?: never;
|
|
776
|
+
trace?: never;
|
|
244
777
|
};
|
|
245
778
|
'/v0/voterequest': {
|
|
779
|
+
parameters: {
|
|
780
|
+
query?: never;
|
|
781
|
+
header?: never;
|
|
782
|
+
path?: never;
|
|
783
|
+
cookie?: never;
|
|
784
|
+
};
|
|
785
|
+
get?: never;
|
|
786
|
+
put?: never;
|
|
246
787
|
/** @description Look up several `VoteRequest`\ s at once by their contract IDs. */
|
|
247
788
|
post: operations['listVoteRequestsByTrackingCid'];
|
|
789
|
+
delete?: never;
|
|
790
|
+
options?: never;
|
|
791
|
+
head?: never;
|
|
792
|
+
patch?: never;
|
|
793
|
+
trace?: never;
|
|
248
794
|
};
|
|
249
795
|
'/v0/voterequests/{vote_request_contract_id}': {
|
|
796
|
+
parameters: {
|
|
797
|
+
query?: never;
|
|
798
|
+
header?: never;
|
|
799
|
+
path?: never;
|
|
800
|
+
cookie?: never;
|
|
801
|
+
};
|
|
250
802
|
/** @description Look up a `VoteRequest` by contract ID. */
|
|
251
803
|
get: operations['lookupDsoRulesVoteRequest'];
|
|
804
|
+
put?: never;
|
|
805
|
+
post?: never;
|
|
806
|
+
delete?: never;
|
|
807
|
+
options?: never;
|
|
808
|
+
head?: never;
|
|
809
|
+
patch?: never;
|
|
810
|
+
trace?: never;
|
|
252
811
|
};
|
|
253
812
|
'/v0/admin/sv/voterequests': {
|
|
813
|
+
parameters: {
|
|
814
|
+
query?: never;
|
|
815
|
+
header?: never;
|
|
816
|
+
path?: never;
|
|
817
|
+
cookie?: never;
|
|
818
|
+
};
|
|
254
819
|
/** @description List all active `VoteRequest`\ s. */
|
|
255
820
|
get: operations['listDsoRulesVoteRequests'];
|
|
821
|
+
put?: never;
|
|
822
|
+
post?: never;
|
|
823
|
+
delete?: never;
|
|
824
|
+
options?: never;
|
|
825
|
+
head?: never;
|
|
826
|
+
patch?: never;
|
|
827
|
+
trace?: never;
|
|
256
828
|
};
|
|
257
829
|
'/v0/admin/sv/voteresults': {
|
|
830
|
+
parameters: {
|
|
831
|
+
query?: never;
|
|
832
|
+
header?: never;
|
|
833
|
+
path?: never;
|
|
834
|
+
cookie?: never;
|
|
835
|
+
};
|
|
836
|
+
get?: never;
|
|
837
|
+
put?: never;
|
|
258
838
|
post: operations['listVoteRequestResults'];
|
|
839
|
+
delete?: never;
|
|
840
|
+
options?: never;
|
|
841
|
+
head?: never;
|
|
842
|
+
patch?: never;
|
|
843
|
+
trace?: never;
|
|
259
844
|
};
|
|
260
845
|
'/v0/backfilling/migration-info': {
|
|
846
|
+
parameters: {
|
|
847
|
+
query?: never;
|
|
848
|
+
header?: never;
|
|
849
|
+
path?: never;
|
|
850
|
+
cookie?: never;
|
|
851
|
+
};
|
|
852
|
+
get?: never;
|
|
853
|
+
put?: never;
|
|
261
854
|
/** @description List all previous synchronizer migrations in this Splice network's history. */
|
|
262
855
|
post: operations['getMigrationInfo'];
|
|
856
|
+
delete?: never;
|
|
857
|
+
options?: never;
|
|
858
|
+
head?: never;
|
|
859
|
+
patch?: never;
|
|
860
|
+
trace?: never;
|
|
263
861
|
};
|
|
264
862
|
'/v0/backfilling/updates-before': {
|
|
863
|
+
parameters: {
|
|
864
|
+
query?: never;
|
|
865
|
+
header?: never;
|
|
866
|
+
path?: never;
|
|
867
|
+
cookie?: never;
|
|
868
|
+
};
|
|
869
|
+
get?: never;
|
|
870
|
+
put?: never;
|
|
265
871
|
/**
|
|
266
872
|
* @description Retrieve transactions and synchronizer reassignments prior to the
|
|
267
|
-
*
|
|
873
|
+
* request's specification.
|
|
268
874
|
*/
|
|
269
875
|
post: operations['getUpdatesBefore'];
|
|
876
|
+
delete?: never;
|
|
877
|
+
options?: never;
|
|
878
|
+
head?: never;
|
|
879
|
+
patch?: never;
|
|
880
|
+
trace?: never;
|
|
270
881
|
};
|
|
271
882
|
'/v0/backfilling/status': {
|
|
883
|
+
parameters: {
|
|
884
|
+
query?: never;
|
|
885
|
+
header?: never;
|
|
886
|
+
path?: never;
|
|
887
|
+
cookie?: never;
|
|
888
|
+
};
|
|
272
889
|
/** @description Retrieve the status of the backfilling process. */
|
|
273
890
|
get: operations['getBackfillingStatus'];
|
|
891
|
+
put?: never;
|
|
892
|
+
post?: never;
|
|
893
|
+
delete?: never;
|
|
894
|
+
options?: never;
|
|
895
|
+
head?: never;
|
|
896
|
+
patch?: never;
|
|
897
|
+
trace?: never;
|
|
274
898
|
};
|
|
275
899
|
'/v0/acs/{party}': {
|
|
900
|
+
parameters: {
|
|
901
|
+
query?: never;
|
|
902
|
+
header?: never;
|
|
903
|
+
path?: never;
|
|
904
|
+
cookie?: never;
|
|
905
|
+
};
|
|
276
906
|
/**
|
|
277
907
|
* @deprecated
|
|
278
908
|
* @description **Deprecated**. Fetch the current SV participant ACS snapshot for the DSO and `party`.
|
|
279
909
|
*/
|
|
280
910
|
get: operations['getAcsSnapshot'];
|
|
911
|
+
put?: never;
|
|
912
|
+
post?: never;
|
|
913
|
+
delete?: never;
|
|
914
|
+
options?: never;
|
|
915
|
+
head?: never;
|
|
916
|
+
patch?: never;
|
|
917
|
+
trace?: never;
|
|
281
918
|
};
|
|
282
919
|
'/v0/aggregated-rounds': {
|
|
920
|
+
parameters: {
|
|
921
|
+
query?: never;
|
|
922
|
+
header?: never;
|
|
923
|
+
path?: never;
|
|
924
|
+
cookie?: never;
|
|
925
|
+
};
|
|
283
926
|
/**
|
|
284
927
|
* @deprecated
|
|
285
928
|
* @description **Deprecated**. Retrieve the current earliest and latest rounds aggregated for this Scan.
|
|
286
929
|
*/
|
|
287
930
|
get: operations['getAggregatedRounds'];
|
|
931
|
+
put?: never;
|
|
932
|
+
post?: never;
|
|
933
|
+
delete?: never;
|
|
934
|
+
options?: never;
|
|
935
|
+
head?: never;
|
|
936
|
+
patch?: never;
|
|
937
|
+
trace?: never;
|
|
288
938
|
};
|
|
289
939
|
'/v0/round-totals': {
|
|
940
|
+
parameters: {
|
|
941
|
+
query?: never;
|
|
942
|
+
header?: never;
|
|
943
|
+
path?: never;
|
|
944
|
+
cookie?: never;
|
|
945
|
+
};
|
|
946
|
+
get?: never;
|
|
947
|
+
put?: never;
|
|
290
948
|
/**
|
|
291
949
|
* @deprecated
|
|
292
950
|
* @description **Deprecated**. List Amulet statistics for up to 200 closed rounds.
|
|
293
951
|
*/
|
|
294
952
|
post: operations['listRoundTotals'];
|
|
953
|
+
delete?: never;
|
|
954
|
+
options?: never;
|
|
955
|
+
head?: never;
|
|
956
|
+
patch?: never;
|
|
957
|
+
trace?: never;
|
|
295
958
|
};
|
|
296
959
|
'/v0/round-party-totals': {
|
|
960
|
+
parameters: {
|
|
961
|
+
query?: never;
|
|
962
|
+
header?: never;
|
|
963
|
+
path?: never;
|
|
964
|
+
cookie?: never;
|
|
965
|
+
};
|
|
966
|
+
get?: never;
|
|
967
|
+
put?: never;
|
|
297
968
|
/**
|
|
298
969
|
* @deprecated
|
|
299
970
|
* @description **Deprecated**. Retrieve per-party Amulet statistics for up to 50 closed rounds.
|
|
300
971
|
*/
|
|
301
972
|
post: operations['listRoundPartyTotals'];
|
|
973
|
+
delete?: never;
|
|
974
|
+
options?: never;
|
|
975
|
+
head?: never;
|
|
976
|
+
patch?: never;
|
|
977
|
+
trace?: never;
|
|
302
978
|
};
|
|
303
979
|
'/v0/total-amulet-balance': {
|
|
980
|
+
parameters: {
|
|
981
|
+
query?: never;
|
|
982
|
+
header?: never;
|
|
983
|
+
path?: never;
|
|
984
|
+
cookie?: never;
|
|
985
|
+
};
|
|
304
986
|
/**
|
|
305
987
|
* @deprecated
|
|
306
988
|
* @description **Deprecated**. Get the total balance of Amulet in the network
|
|
307
989
|
*/
|
|
308
990
|
get: operations['getTotalAmuletBalance'];
|
|
991
|
+
put?: never;
|
|
992
|
+
post?: never;
|
|
993
|
+
delete?: never;
|
|
994
|
+
options?: never;
|
|
995
|
+
head?: never;
|
|
996
|
+
patch?: never;
|
|
997
|
+
trace?: never;
|
|
309
998
|
};
|
|
310
999
|
'/v0/wallet-balance': {
|
|
1000
|
+
parameters: {
|
|
1001
|
+
query?: never;
|
|
1002
|
+
header?: never;
|
|
1003
|
+
path?: never;
|
|
1004
|
+
cookie?: never;
|
|
1005
|
+
};
|
|
311
1006
|
/**
|
|
312
1007
|
* @deprecated
|
|
313
1008
|
* @description **Deprecated**, use /v0/holdings/summary with /v0/state/acs/snapshot-timestamp instead. Get the Amulet balance for a specific party at the end of a closed round
|
|
314
1009
|
*/
|
|
315
1010
|
get: operations['getWalletBalance'];
|
|
1011
|
+
put?: never;
|
|
1012
|
+
post?: never;
|
|
1013
|
+
delete?: never;
|
|
1014
|
+
options?: never;
|
|
1015
|
+
head?: never;
|
|
1016
|
+
patch?: never;
|
|
1017
|
+
trace?: never;
|
|
316
1018
|
};
|
|
317
1019
|
'/v0/amulet-config-for-round': {
|
|
1020
|
+
parameters: {
|
|
1021
|
+
query?: never;
|
|
1022
|
+
header?: never;
|
|
1023
|
+
path?: never;
|
|
1024
|
+
cookie?: never;
|
|
1025
|
+
};
|
|
318
1026
|
/**
|
|
319
1027
|
* @deprecated
|
|
320
1028
|
* @description **Deprecated**. Retrieve some information from the `AmuletRules` selected for the given round
|
|
321
1029
|
*/
|
|
322
1030
|
get: operations['getAmuletConfigForRound'];
|
|
1031
|
+
put?: never;
|
|
1032
|
+
post?: never;
|
|
1033
|
+
delete?: never;
|
|
1034
|
+
options?: never;
|
|
1035
|
+
head?: never;
|
|
1036
|
+
patch?: never;
|
|
1037
|
+
trace?: never;
|
|
323
1038
|
};
|
|
324
1039
|
'/v0/round-of-latest-data': {
|
|
1040
|
+
parameters: {
|
|
1041
|
+
query?: never;
|
|
1042
|
+
header?: never;
|
|
1043
|
+
path?: never;
|
|
1044
|
+
cookie?: never;
|
|
1045
|
+
};
|
|
325
1046
|
/**
|
|
326
1047
|
* @deprecated
|
|
327
1048
|
* @description **Deprecated**. Get the latest round number for which aggregated data is available and
|
|
328
|
-
*
|
|
1049
|
+
* the ledger effective time at which the round was closed.
|
|
329
1050
|
*/
|
|
330
1051
|
get: operations['getRoundOfLatestData'];
|
|
1052
|
+
put?: never;
|
|
1053
|
+
post?: never;
|
|
1054
|
+
delete?: never;
|
|
1055
|
+
options?: never;
|
|
1056
|
+
head?: never;
|
|
1057
|
+
patch?: never;
|
|
1058
|
+
trace?: never;
|
|
331
1059
|
};
|
|
332
1060
|
'/v0/rewards-collected': {
|
|
1061
|
+
parameters: {
|
|
1062
|
+
query?: never;
|
|
1063
|
+
header?: never;
|
|
1064
|
+
path?: never;
|
|
1065
|
+
cookie?: never;
|
|
1066
|
+
};
|
|
333
1067
|
/**
|
|
334
1068
|
* @deprecated
|
|
335
1069
|
* @description **Deprecated**. Get the total rewards collected ever
|
|
336
1070
|
*/
|
|
337
1071
|
get: operations['getRewardsCollected'];
|
|
1072
|
+
put?: never;
|
|
1073
|
+
post?: never;
|
|
1074
|
+
delete?: never;
|
|
1075
|
+
options?: never;
|
|
1076
|
+
head?: never;
|
|
1077
|
+
patch?: never;
|
|
1078
|
+
trace?: never;
|
|
338
1079
|
};
|
|
339
1080
|
'/v0/top-providers-by-app-rewards': {
|
|
1081
|
+
parameters: {
|
|
1082
|
+
query?: never;
|
|
1083
|
+
header?: never;
|
|
1084
|
+
path?: never;
|
|
1085
|
+
cookie?: never;
|
|
1086
|
+
};
|
|
340
1087
|
/**
|
|
341
1088
|
* @deprecated
|
|
342
1089
|
* @description **Deprecated**. Get a list of top-earning app providers, and the total earned app
|
|
343
|
-
*
|
|
1090
|
+
* rewards for each
|
|
344
1091
|
*/
|
|
345
1092
|
get: operations['getTopProvidersByAppRewards'];
|
|
1093
|
+
put?: never;
|
|
1094
|
+
post?: never;
|
|
1095
|
+
delete?: never;
|
|
1096
|
+
options?: never;
|
|
1097
|
+
head?: never;
|
|
1098
|
+
patch?: never;
|
|
1099
|
+
trace?: never;
|
|
346
1100
|
};
|
|
347
1101
|
'/v0/top-validators-by-validator-rewards': {
|
|
1102
|
+
parameters: {
|
|
1103
|
+
query?: never;
|
|
1104
|
+
header?: never;
|
|
1105
|
+
path?: never;
|
|
1106
|
+
cookie?: never;
|
|
1107
|
+
};
|
|
348
1108
|
/**
|
|
349
1109
|
* @deprecated
|
|
350
1110
|
* @description **Deprecated**. Get a list of top-earning validators, and the total earned validator
|
|
351
|
-
*
|
|
1111
|
+
* rewards for each
|
|
352
1112
|
*/
|
|
353
1113
|
get: operations['getTopValidatorsByValidatorRewards'];
|
|
1114
|
+
put?: never;
|
|
1115
|
+
post?: never;
|
|
1116
|
+
delete?: never;
|
|
1117
|
+
options?: never;
|
|
1118
|
+
head?: never;
|
|
1119
|
+
patch?: never;
|
|
1120
|
+
trace?: never;
|
|
354
1121
|
};
|
|
355
1122
|
'/v0/top-validators-by-purchased-traffic': {
|
|
1123
|
+
parameters: {
|
|
1124
|
+
query?: never;
|
|
1125
|
+
header?: never;
|
|
1126
|
+
path?: never;
|
|
1127
|
+
cookie?: never;
|
|
1128
|
+
};
|
|
356
1129
|
/**
|
|
357
1130
|
* @deprecated
|
|
358
1131
|
* @description **Deprecated**. Get a list of validators and their domain fees spends, sorted by the
|
|
359
|
-
*
|
|
1132
|
+
* amount of extra traffic purchased
|
|
360
1133
|
*/
|
|
361
1134
|
get: operations['getTopValidatorsByPurchasedTraffic'];
|
|
1135
|
+
put?: never;
|
|
1136
|
+
post?: never;
|
|
1137
|
+
delete?: never;
|
|
1138
|
+
options?: never;
|
|
1139
|
+
head?: never;
|
|
1140
|
+
patch?: never;
|
|
1141
|
+
trace?: never;
|
|
362
1142
|
};
|
|
363
1143
|
'/v0/activities': {
|
|
1144
|
+
parameters: {
|
|
1145
|
+
query?: never;
|
|
1146
|
+
header?: never;
|
|
1147
|
+
path?: never;
|
|
1148
|
+
cookie?: never;
|
|
1149
|
+
};
|
|
1150
|
+
get?: never;
|
|
1151
|
+
put?: never;
|
|
364
1152
|
/**
|
|
365
1153
|
* @deprecated
|
|
366
1154
|
* @description **Deprecated**. Lists activities in descending order, paged, optionally starting after a provided event id.
|
|
367
1155
|
*/
|
|
368
1156
|
post: operations['listActivity'];
|
|
1157
|
+
delete?: never;
|
|
1158
|
+
options?: never;
|
|
1159
|
+
head?: never;
|
|
1160
|
+
patch?: never;
|
|
1161
|
+
trace?: never;
|
|
369
1162
|
};
|
|
370
1163
|
'/v0/transactions': {
|
|
1164
|
+
parameters: {
|
|
1165
|
+
query?: never;
|
|
1166
|
+
header?: never;
|
|
1167
|
+
path?: never;
|
|
1168
|
+
cookie?: never;
|
|
1169
|
+
};
|
|
1170
|
+
get?: never;
|
|
1171
|
+
put?: never;
|
|
371
1172
|
/**
|
|
372
1173
|
* @deprecated
|
|
373
1174
|
* @description **Deprecated with known bugs that will not be fixed, use /v2/updates instead**.
|
|
374
1175
|
*
|
|
375
|
-
*
|
|
1176
|
+
* Lists transactions, by default in ascending order, paged, from ledger begin or optionally starting after a provided event id.
|
|
376
1177
|
*/
|
|
377
1178
|
post: operations['listTransactionHistory'];
|
|
1179
|
+
delete?: never;
|
|
1180
|
+
options?: never;
|
|
1181
|
+
head?: never;
|
|
1182
|
+
patch?: never;
|
|
1183
|
+
trace?: never;
|
|
378
1184
|
};
|
|
379
1185
|
'/v0/updates': {
|
|
1186
|
+
parameters: {
|
|
1187
|
+
query?: never;
|
|
1188
|
+
header?: never;
|
|
1189
|
+
path?: never;
|
|
1190
|
+
cookie?: never;
|
|
1191
|
+
};
|
|
1192
|
+
get?: never;
|
|
1193
|
+
put?: never;
|
|
380
1194
|
/**
|
|
381
1195
|
* @deprecated
|
|
382
1196
|
* @description **Deprecated**, use /v2/updates instead.
|
|
383
|
-
*
|
|
1197
|
+
* Returns the update history in ascending order, paged, from ledger begin or optionally starting after a record time.
|
|
384
1198
|
*/
|
|
385
1199
|
post: operations['getUpdateHistory'];
|
|
1200
|
+
delete?: never;
|
|
1201
|
+
options?: never;
|
|
1202
|
+
head?: never;
|
|
1203
|
+
patch?: never;
|
|
1204
|
+
trace?: never;
|
|
386
1205
|
};
|
|
387
1206
|
'/v0/updates/{update_id}': {
|
|
1207
|
+
parameters: {
|
|
1208
|
+
query?: never;
|
|
1209
|
+
header?: never;
|
|
1210
|
+
path?: never;
|
|
1211
|
+
cookie?: never;
|
|
1212
|
+
};
|
|
388
1213
|
/**
|
|
389
1214
|
* @deprecated
|
|
390
1215
|
* @description **Deprecated**, use /v2/updates/{update_id} instead.
|
|
391
1216
|
*/
|
|
392
1217
|
get: operations['getUpdateById'];
|
|
1218
|
+
put?: never;
|
|
1219
|
+
post?: never;
|
|
1220
|
+
delete?: never;
|
|
1221
|
+
options?: never;
|
|
1222
|
+
head?: never;
|
|
1223
|
+
patch?: never;
|
|
1224
|
+
trace?: never;
|
|
393
1225
|
};
|
|
394
1226
|
'/v0/feature-support': {
|
|
1227
|
+
parameters: {
|
|
1228
|
+
query?: never;
|
|
1229
|
+
header?: never;
|
|
1230
|
+
path?: never;
|
|
1231
|
+
cookie?: never;
|
|
1232
|
+
};
|
|
395
1233
|
get: operations['featureSupport'];
|
|
1234
|
+
put?: never;
|
|
1235
|
+
post?: never;
|
|
1236
|
+
delete?: never;
|
|
1237
|
+
options?: never;
|
|
1238
|
+
head?: never;
|
|
1239
|
+
patch?: never;
|
|
1240
|
+
trace?: never;
|
|
396
1241
|
};
|
|
397
1242
|
'/v0/backfilling/import-updates': {
|
|
1243
|
+
parameters: {
|
|
1244
|
+
query?: never;
|
|
1245
|
+
header?: never;
|
|
1246
|
+
path?: never;
|
|
1247
|
+
cookie?: never;
|
|
1248
|
+
};
|
|
1249
|
+
get?: never;
|
|
1250
|
+
put?: never;
|
|
398
1251
|
post: operations['getImportUpdates'];
|
|
1252
|
+
delete?: never;
|
|
1253
|
+
options?: never;
|
|
1254
|
+
head?: never;
|
|
1255
|
+
patch?: never;
|
|
1256
|
+
trace?: never;
|
|
399
1257
|
};
|
|
400
1258
|
'/v0/events': {
|
|
1259
|
+
parameters: {
|
|
1260
|
+
query?: never;
|
|
1261
|
+
header?: never;
|
|
1262
|
+
path?: never;
|
|
1263
|
+
cookie?: never;
|
|
1264
|
+
};
|
|
1265
|
+
get?: never;
|
|
1266
|
+
put?: never;
|
|
401
1267
|
/**
|
|
402
1268
|
* @description Returns the event history in ascending order, paged, from ledger begin or optionally starting after a record time.
|
|
403
|
-
*
|
|
404
|
-
*
|
|
405
|
-
*
|
|
406
|
-
*
|
|
407
|
-
*
|
|
408
|
-
*
|
|
1269
|
+
* An event bears some combination of a transaction, a contract reassignment, and a verdict.
|
|
1270
|
+
* Events are ordered lexicographically by `(migration id, record time)`.
|
|
1271
|
+
* For a given migration id, each event has a unique record time.
|
|
1272
|
+
* The record time ranges of different migrations may overlap, i.e.,
|
|
1273
|
+
* it is not guaranteed that the maximum record time of one migration is smaller than the minimum record time of the next migration,
|
|
1274
|
+
* and there may be two updates with the same record time but different migration ids.
|
|
409
1275
|
*/
|
|
410
1276
|
post: operations['getEventHistory'];
|
|
1277
|
+
delete?: never;
|
|
1278
|
+
options?: never;
|
|
1279
|
+
head?: never;
|
|
1280
|
+
patch?: never;
|
|
1281
|
+
trace?: never;
|
|
411
1282
|
};
|
|
412
1283
|
'/v0/events/{update_id}': {
|
|
1284
|
+
parameters: {
|
|
1285
|
+
query?: never;
|
|
1286
|
+
header?: never;
|
|
1287
|
+
path?: never;
|
|
1288
|
+
cookie?: never;
|
|
1289
|
+
};
|
|
413
1290
|
/**
|
|
414
1291
|
* @description Returns the event with the given update_id.
|
|
415
|
-
*
|
|
1292
|
+
* An event bears some combination of a transaction, a contract reassignment, and a verdict.
|
|
416
1293
|
*/
|
|
417
1294
|
get: operations['getEventById'];
|
|
1295
|
+
put?: never;
|
|
1296
|
+
post?: never;
|
|
1297
|
+
delete?: never;
|
|
1298
|
+
options?: never;
|
|
1299
|
+
head?: never;
|
|
1300
|
+
patch?: never;
|
|
1301
|
+
trace?: never;
|
|
418
1302
|
};
|
|
419
1303
|
}
|
|
420
1304
|
export type webhooks = Record<string, never>;
|
|
@@ -440,37 +1324,37 @@ export interface components {
|
|
|
440
1324
|
GetClosedRoundsResponse: {
|
|
441
1325
|
/**
|
|
442
1326
|
* @description Contracts of the Daml template `Splice.Round:ClosedMiningRound`, one
|
|
443
|
-
*
|
|
444
|
-
*
|
|
1327
|
+
* for every closed round that is still in process, i.e. it either has
|
|
1328
|
+
* unprocessed rewards or a missing `Splice.DsoRules:Confirmation`.
|
|
445
1329
|
*/
|
|
446
1330
|
rounds: components['schemas']['Contract'][];
|
|
447
1331
|
};
|
|
448
1332
|
GetOpenAndIssuingMiningRoundsRequest: {
|
|
449
1333
|
/**
|
|
450
1334
|
* @description The contract IDs for `open_mining_rounds` in the response the caller
|
|
451
|
-
*
|
|
452
|
-
*
|
|
1335
|
+
* knows about. If unsure, an empty array is fine; only a performance
|
|
1336
|
+
* penalty is incurred.
|
|
453
1337
|
*/
|
|
454
1338
|
cached_open_mining_round_contract_ids: components['schemas']['ContractId'][];
|
|
455
1339
|
/**
|
|
456
1340
|
* @description The contract IDs for `issuing_mining_rounds` in the response the
|
|
457
|
-
*
|
|
458
|
-
*
|
|
1341
|
+
* caller knows about. If unsure, an empty array is fine; only a
|
|
1342
|
+
* performance penalty is incurred.
|
|
459
1343
|
*/
|
|
460
1344
|
cached_issuing_round_contract_ids: components['schemas']['ContractId'][];
|
|
461
1345
|
};
|
|
462
1346
|
/**
|
|
463
1347
|
* @description Daml contracts of the templates `Splice.Round.OpenMiningRound` and
|
|
464
|
-
*
|
|
465
|
-
*
|
|
466
|
-
*
|
|
467
|
-
*
|
|
468
|
-
*
|
|
1348
|
+
* `Splice.Round.IssuingMiningRound` representing rounds for which rewards
|
|
1349
|
+
* can be registered or are currently being computed, respectively.
|
|
1350
|
+
* Contract IDs in the input serve as input sets for the two
|
|
1351
|
+
* `MaybeCachedContractWithStateMap`s as described for that structure for
|
|
1352
|
+
* `open_mining_rounds` and `issuing_mining_rounds`.
|
|
469
1353
|
*/
|
|
470
1354
|
GetOpenAndIssuingMiningRoundsResponse: {
|
|
471
1355
|
/**
|
|
472
1356
|
* @description Suggested cache TTL for the response; this should expire before the
|
|
473
|
-
*
|
|
1357
|
+
* `opensAt` of any open rounds that may not be in this response yet.
|
|
474
1358
|
*/
|
|
475
1359
|
time_to_live_in_microseconds: number;
|
|
476
1360
|
open_mining_rounds: components['schemas']['MaybeCachedContractWithStateMap'];
|
|
@@ -482,11 +1366,11 @@ export interface components {
|
|
|
482
1366
|
};
|
|
483
1367
|
/**
|
|
484
1368
|
* @description Contract of the Daml template `Splice.AmuletRules.AmuletRules`,
|
|
485
|
-
*
|
|
486
|
-
*
|
|
487
|
-
*
|
|
488
|
-
*
|
|
489
|
-
*
|
|
1369
|
+
* including the full schedule of `AmuletConfig` changes approved by
|
|
1370
|
+
* the DSO. Callers should not assume that `initialValue` is up-to-date,
|
|
1371
|
+
* and should instead search `futureValues` for the latest configuration
|
|
1372
|
+
* valid as of now. `contract` will be absent if its ID matches the input
|
|
1373
|
+
* `cached_amulet_rules_contract_id`.
|
|
490
1374
|
*/
|
|
491
1375
|
GetAmuletRulesResponse: {
|
|
492
1376
|
amulet_rules_update: components['schemas']['MaybeCachedContractWithState'];
|
|
@@ -497,7 +1381,7 @@ export interface components {
|
|
|
497
1381
|
};
|
|
498
1382
|
/**
|
|
499
1383
|
* @description A contract state update of Daml template
|
|
500
|
-
*
|
|
1384
|
+
* `Splice.ExternalPartyAmuletRules.ExternalPartyAmuletRules`
|
|
501
1385
|
*/
|
|
502
1386
|
GetExternalPartyAmuletRulesResponse: {
|
|
503
1387
|
external_party_amulet_rules_update: components['schemas']['MaybeCachedContractWithState'];
|
|
@@ -569,9 +1453,9 @@ export interface components {
|
|
|
569
1453
|
GetTopValidatorsByValidatorFaucetsResponse: {
|
|
570
1454
|
/**
|
|
571
1455
|
* @description Up to `limit` validators, sorted greatest number of rounds
|
|
572
|
-
*
|
|
1456
|
+
* collected first
|
|
573
1457
|
*/
|
|
574
|
-
validatorsByReceivedFaucets:
|
|
1458
|
+
validatorsByReceivedFaucets: components['schemas']['ValidatorReceivedFaucets'][];
|
|
575
1459
|
};
|
|
576
1460
|
GetTopValidatorsByPurchasedTrafficResponse: {
|
|
577
1461
|
validatorsByPurchasedTraffic: components['schemas']['ValidatorPurchasedTraffic'][];
|
|
@@ -634,7 +1518,7 @@ export interface components {
|
|
|
634
1518
|
domainId: string;
|
|
635
1519
|
/**
|
|
636
1520
|
* @description SV scans for the associated synchronizer ID; there is at most one
|
|
637
|
-
*
|
|
1521
|
+
* scan per SV for each synchronizer ID.
|
|
638
1522
|
*/
|
|
639
1523
|
scans: components['schemas']['ScanInfo'][];
|
|
640
1524
|
};
|
|
@@ -647,16 +1531,15 @@ export interface components {
|
|
|
647
1531
|
TransactionHistoryRequest: {
|
|
648
1532
|
/**
|
|
649
1533
|
* @description Note that all transactions carry some monotonically-increasing event_id.
|
|
650
|
-
*
|
|
651
|
-
*
|
|
652
|
-
*
|
|
1534
|
+
* Omit this page_end_event_id to start reading the first page, from the beginning or the end of the ledger, depending on the sort_order column.
|
|
1535
|
+
* A subsequent request can fill the page_end_event_id with the last event_id of the TransactionHistoryResponse to continue reading in the same sort_order.
|
|
1536
|
+
* The transaction with event_id == page_end_event_id will be skipped in the next response, making it possible to continuously read pages in the same sort_order.
|
|
653
1537
|
*/
|
|
654
1538
|
page_end_event_id?: string;
|
|
655
1539
|
/**
|
|
656
1540
|
* @description Sort order for the transactions. For ascending order, from beginning to the end of the ledger, use "asc".
|
|
657
|
-
*
|
|
658
|
-
*
|
|
659
|
-
*
|
|
1541
|
+
* For descending order, from end to beginning of the ledger, use "desc".
|
|
1542
|
+
* "asc" is used if the sort_order is omitted.
|
|
660
1543
|
* @enum {string}
|
|
661
1544
|
*/
|
|
662
1545
|
sort_order?: 'asc' | 'desc';
|
|
@@ -672,9 +1555,8 @@ export interface components {
|
|
|
672
1555
|
TransactionHistoryResponseItem: {
|
|
673
1556
|
/**
|
|
674
1557
|
* @description Describes the type of activity that occurred.
|
|
675
|
-
*
|
|
676
|
-
*
|
|
677
|
-
*
|
|
1558
|
+
* Determines if the data for the transaction should be read
|
|
1559
|
+
* from the `transfer`, `mint`, or `tap` property.
|
|
678
1560
|
* @enum {string}
|
|
679
1561
|
*/
|
|
680
1562
|
transaction_type: 'transfer' | 'mint' | 'devnet_tap' | 'abort_transfer_instruction';
|
|
@@ -682,7 +1564,7 @@ export interface components {
|
|
|
682
1564
|
event_id: string;
|
|
683
1565
|
/**
|
|
684
1566
|
* @description The ledger offset of the event.
|
|
685
|
-
*
|
|
1567
|
+
* Note that this field may not be the same across nodes, and therefore should not be compared between SVs.
|
|
686
1568
|
*/
|
|
687
1569
|
offset?: string;
|
|
688
1570
|
/**
|
|
@@ -715,16 +1597,16 @@ export interface components {
|
|
|
715
1597
|
after_migration_id: number;
|
|
716
1598
|
/**
|
|
717
1599
|
* @description The record time to start returning transactions from. This only affects
|
|
718
|
-
*
|
|
719
|
-
*
|
|
1600
|
+
* transactions with the same migration id as after_migration_id. Higher migration ids
|
|
1601
|
+
* are always considered to be later.
|
|
720
1602
|
*/
|
|
721
1603
|
after_record_time: string;
|
|
722
1604
|
};
|
|
723
1605
|
UpdateHistoryRequest: {
|
|
724
1606
|
/**
|
|
725
1607
|
* @description The transactions returned will either have a higher migration id or
|
|
726
|
-
*
|
|
727
|
-
*
|
|
1608
|
+
* the same migration id and a record_time greater than the migration id and record time
|
|
1609
|
+
* specified.
|
|
728
1610
|
*/
|
|
729
1611
|
after?: components['schemas']['UpdateHistoryRequestAfter'];
|
|
730
1612
|
/**
|
|
@@ -734,16 +1616,16 @@ export interface components {
|
|
|
734
1616
|
page_size: number;
|
|
735
1617
|
/**
|
|
736
1618
|
* @description Whether contract payload should be encoded into json using a lossless, but much harder to process, encoding.
|
|
737
|
-
*
|
|
738
|
-
*
|
|
1619
|
+
* This is mostly used for backend calls, and is not recommended for external users.
|
|
1620
|
+
* Optional and defaults to false.
|
|
739
1621
|
*/
|
|
740
1622
|
lossless?: boolean;
|
|
741
1623
|
};
|
|
742
1624
|
UpdateHistoryRequestV1: {
|
|
743
1625
|
/**
|
|
744
1626
|
* @description The transactions returned will either have a higher migration id or
|
|
745
|
-
*
|
|
746
|
-
*
|
|
1627
|
+
* the same migration id and a record_time greater than the migration id and record time
|
|
1628
|
+
* specified.
|
|
747
1629
|
*/
|
|
748
1630
|
after?: components['schemas']['UpdateHistoryRequestAfter'];
|
|
749
1631
|
/**
|
|
@@ -756,8 +1638,8 @@ export interface components {
|
|
|
756
1638
|
UpdateHistoryRequestV2: {
|
|
757
1639
|
/**
|
|
758
1640
|
* @description The transactions returned will either have a higher migration id or
|
|
759
|
-
*
|
|
760
|
-
*
|
|
1641
|
+
* the same migration id and a record_time greater than the migration id and record time
|
|
1642
|
+
* specified.
|
|
761
1643
|
*/
|
|
762
1644
|
after?: components['schemas']['UpdateHistoryRequestAfter'];
|
|
763
1645
|
/**
|
|
@@ -783,7 +1665,7 @@ export interface components {
|
|
|
783
1665
|
update_id: string;
|
|
784
1666
|
/**
|
|
785
1667
|
* @description The absolute offset.
|
|
786
|
-
*
|
|
1668
|
+
* Note that this field may not be the same across nodes, and therefore should not be compared between SVs.
|
|
787
1669
|
*/
|
|
788
1670
|
offset: string;
|
|
789
1671
|
/** @description The time at which the transaction was sequenced. */
|
|
@@ -805,8 +1687,8 @@ export interface components {
|
|
|
805
1687
|
migration_id: number;
|
|
806
1688
|
/**
|
|
807
1689
|
* @description The id of the corresponding unassign event; this assignment will
|
|
808
|
-
*
|
|
809
|
-
*
|
|
1690
|
+
* usually, but not always, occur after the so-identified unassignment
|
|
1691
|
+
* event.
|
|
810
1692
|
*/
|
|
811
1693
|
unassign_id: string;
|
|
812
1694
|
/** @description The corresponding contract create event */
|
|
@@ -849,38 +1731,38 @@ export interface components {
|
|
|
849
1731
|
migration_id: number;
|
|
850
1732
|
/**
|
|
851
1733
|
* @description This transaction's Daml workflow ID; a workflow ID can be associated
|
|
852
|
-
*
|
|
1734
|
+
* with multiple transactions. If empty, no workflow ID was set.
|
|
853
1735
|
*/
|
|
854
1736
|
workflow_id: string;
|
|
855
1737
|
/**
|
|
856
1738
|
* @description The time at which the transaction was sequenced, with microsecond
|
|
857
|
-
*
|
|
1739
|
+
* resolution, using ISO-8601 representation.
|
|
858
1740
|
*/
|
|
859
1741
|
record_time: string;
|
|
860
1742
|
/** @description The id of the synchronizer through which this transaction was sequenced. */
|
|
861
1743
|
synchronizer_id: string;
|
|
862
1744
|
/**
|
|
863
1745
|
* @description Ledger effective time, using ISO-8601 representation. This is the time
|
|
864
|
-
*
|
|
865
|
-
*
|
|
1746
|
+
* returned by `getTime` for all Daml executed as part of this transaction,
|
|
1747
|
+
* both by the submitting participant and all confirming participants.
|
|
866
1748
|
*/
|
|
867
1749
|
effective_at: string;
|
|
868
1750
|
/**
|
|
869
1751
|
* @description The absolute offset.
|
|
870
|
-
*
|
|
871
|
-
*
|
|
1752
|
+
* Note that this field may not be the same across nodes, and therefore should not be compared between SVs.
|
|
1753
|
+
* However, within a single SV's scan, it is monotonically, lexicographically increasing.
|
|
872
1754
|
*/
|
|
873
1755
|
offset: string;
|
|
874
1756
|
/**
|
|
875
1757
|
* @description Roots of the transaction tree. These are guaranteed to occur as keys
|
|
876
|
-
*
|
|
1758
|
+
* of the `events_by_id` object.
|
|
877
1759
|
*/
|
|
878
1760
|
root_event_ids: string[];
|
|
879
1761
|
/**
|
|
880
1762
|
* @description Changes to the ledger that were caused by this transaction, keyed by ID.
|
|
881
|
-
*
|
|
882
|
-
*
|
|
883
|
-
*
|
|
1763
|
+
* Values are nodes of the transaction tree.
|
|
1764
|
+
* Within a transaction, IDs may be referenced by `root_event_ids` or
|
|
1765
|
+
* `child_event_ids` in `ExercisedEvent` herein.
|
|
884
1766
|
*/
|
|
885
1767
|
events_by_id: {
|
|
886
1768
|
[key: string]: components['schemas']['TreeEvent'];
|
|
@@ -896,32 +1778,32 @@ export interface components {
|
|
|
896
1778
|
migration_id: number;
|
|
897
1779
|
/**
|
|
898
1780
|
* @description This transaction's Daml workflow ID; a workflow ID can be associated
|
|
899
|
-
*
|
|
1781
|
+
* with multiple transactions. If empty, no workflow ID was set.
|
|
900
1782
|
*/
|
|
901
1783
|
workflow_id: string;
|
|
902
1784
|
/**
|
|
903
1785
|
* @description The time at which the transaction was sequenced, with microsecond
|
|
904
|
-
*
|
|
1786
|
+
* resolution, using ISO-8601 representation.
|
|
905
1787
|
*/
|
|
906
1788
|
record_time: string;
|
|
907
1789
|
/** @description The id of the synchronizer through which this transaction was sequenced. */
|
|
908
1790
|
synchronizer_id: string;
|
|
909
1791
|
/**
|
|
910
1792
|
* @description Ledger effective time, using ISO-8601 representation. This is the time
|
|
911
|
-
*
|
|
912
|
-
*
|
|
1793
|
+
* returned by `getTime` for all Daml executed as part of this transaction,
|
|
1794
|
+
* both by the submitting participant and all confirming participants.
|
|
913
1795
|
*/
|
|
914
1796
|
effective_at: string;
|
|
915
1797
|
/**
|
|
916
1798
|
* @description Roots of the transaction tree. These are guaranteed to occur as keys
|
|
917
|
-
*
|
|
1799
|
+
* of the `events_by_id` object.
|
|
918
1800
|
*/
|
|
919
1801
|
root_event_ids: string[];
|
|
920
1802
|
/**
|
|
921
1803
|
* @description Changes to the ledger that were caused by this transaction, keyed by ID and sorted lexicographically by ID for display consistency.
|
|
922
|
-
*
|
|
923
|
-
*
|
|
924
|
-
*
|
|
1804
|
+
* Values are nodes of the transaction tree.
|
|
1805
|
+
* Within a transaction, IDs may be referenced by `root_event_ids` or
|
|
1806
|
+
* `child_event_ids` in `ExercisedEvent` herein, which are sorted in the order as they occurred in the transaction.
|
|
925
1807
|
*/
|
|
926
1808
|
events_by_id: {
|
|
927
1809
|
[key: string]: components['schemas']['TreeEvent'];
|
|
@@ -930,10 +1812,14 @@ export interface components {
|
|
|
930
1812
|
/** @description Either a creation or an exercise of a contract. */
|
|
931
1813
|
TreeEvent: components['schemas']['CreatedEvent'] | components['schemas']['ExercisedEvent'];
|
|
932
1814
|
CreatedEvent: {
|
|
933
|
-
|
|
1815
|
+
/**
|
|
1816
|
+
* @description discriminator enum property added by openapi-typescript
|
|
1817
|
+
* @enum {string}
|
|
1818
|
+
*/
|
|
1819
|
+
event_type: 'created_event';
|
|
934
1820
|
/**
|
|
935
1821
|
* @description The ID of this particular event. Equal to the key of this element of
|
|
936
|
-
*
|
|
1822
|
+
* the containing `events_by_id` if this is part of a `TreeEvent`.
|
|
937
1823
|
*/
|
|
938
1824
|
event_id: string;
|
|
939
1825
|
/** @description The ID of the created contract. */
|
|
@@ -944,7 +1830,7 @@ export interface components {
|
|
|
944
1830
|
package_name: string;
|
|
945
1831
|
/**
|
|
946
1832
|
* @description The arguments that have been used to create the contract, in the
|
|
947
|
-
*
|
|
1833
|
+
* form of JSON representation of a Daml record.
|
|
948
1834
|
*/
|
|
949
1835
|
create_arguments: Record<string, never>;
|
|
950
1836
|
/**
|
|
@@ -958,10 +1844,14 @@ export interface components {
|
|
|
958
1844
|
observers: string[];
|
|
959
1845
|
};
|
|
960
1846
|
ExercisedEvent: {
|
|
961
|
-
|
|
1847
|
+
/**
|
|
1848
|
+
* @description discriminator enum property added by openapi-typescript
|
|
1849
|
+
* @enum {string}
|
|
1850
|
+
*/
|
|
1851
|
+
event_type: 'exercised_event';
|
|
962
1852
|
/**
|
|
963
1853
|
* @description The ID of this particular event. Equal to the key of this element of
|
|
964
|
-
*
|
|
1854
|
+
* the containing `events_by_id` if this is part of a `TreeEvent`.
|
|
965
1855
|
*/
|
|
966
1856
|
event_id: string;
|
|
967
1857
|
/** @description The ID of the created contract. */
|
|
@@ -972,25 +1862,25 @@ export interface components {
|
|
|
972
1862
|
package_name: string;
|
|
973
1863
|
/**
|
|
974
1864
|
* @description The choice that was exercised on the target contract, as an unqualified
|
|
975
|
-
*
|
|
1865
|
+
* choice name, i.e. with no package or module name qualifiers.
|
|
976
1866
|
*/
|
|
977
1867
|
choice: string;
|
|
978
1868
|
/**
|
|
979
1869
|
* @description The argument of the exercised choice, in the form of JSON
|
|
980
|
-
*
|
|
981
|
-
*
|
|
982
|
-
*
|
|
1870
|
+
* representation of a Daml value. This is usually a record with field
|
|
1871
|
+
* names being the argument names, even in the case of a single apparent
|
|
1872
|
+
* choice argument, which is represented as a single-element Daml record.
|
|
983
1873
|
*/
|
|
984
1874
|
choice_argument: Record<string, never>;
|
|
985
1875
|
/**
|
|
986
1876
|
* @description References to further events in the same transaction that appeared as a result of this ExercisedEvent.
|
|
987
|
-
*
|
|
988
|
-
*
|
|
1877
|
+
* It contains only the immediate children of this event, not all members of the subtree rooted at this node.
|
|
1878
|
+
* The order of the children is the same as the event order in the transaction.
|
|
989
1879
|
*/
|
|
990
1880
|
child_event_ids: string[];
|
|
991
1881
|
/**
|
|
992
1882
|
* @description The result of exercising the choice, as the JSON representation of a
|
|
993
|
-
*
|
|
1883
|
+
* Daml value.
|
|
994
1884
|
*/
|
|
995
1885
|
exercise_result: Record<string, never>;
|
|
996
1886
|
/** @description If true, the target contract may no longer be exercised. */
|
|
@@ -1016,25 +1906,24 @@ export interface components {
|
|
|
1016
1906
|
/**
|
|
1017
1907
|
* Format: date-time
|
|
1018
1908
|
* @description The timestamp at which the contract set was active.
|
|
1019
|
-
*
|
|
1020
|
-
*
|
|
1021
|
-
*
|
|
1909
|
+
* This needs to be an exact timestamp, i.e.,
|
|
1910
|
+
* needs to correspond to a timestamp reported by `/v0/state/acs/snapshot-timestamp` if `record_time_match` is set to `exact` (which is the default).
|
|
1911
|
+
* If `record_time_match` is set to `at_or_before`, this can be any timestamp, and the most recent snapshot at or before the given `record_time` will be returned.
|
|
1022
1912
|
*/
|
|
1023
1913
|
record_time: string;
|
|
1024
1914
|
/**
|
|
1025
1915
|
* @description How to match the record_time. "exact" requires the record_time to match exactly.
|
|
1026
|
-
*
|
|
1027
|
-
*
|
|
1916
|
+
* "at_or_before" finds the most recent snapshot at or before the given record_time.
|
|
1028
1917
|
* @default exact
|
|
1029
1918
|
* @enum {string}
|
|
1030
1919
|
*/
|
|
1031
|
-
record_time_match
|
|
1920
|
+
record_time_match: 'exact' | 'at_or_before';
|
|
1032
1921
|
/**
|
|
1033
1922
|
* Format: int64
|
|
1034
1923
|
* @description Pagination token for the next page of results. For this to be valid,
|
|
1035
|
-
*
|
|
1036
|
-
*
|
|
1037
|
-
*
|
|
1924
|
+
* this must be the `next_page_token` from a prior request with identical
|
|
1925
|
+
* parameters aside from `after` and `page_size`; the response may be
|
|
1926
|
+
* invalid otherwise.
|
|
1038
1927
|
*/
|
|
1039
1928
|
after?: number;
|
|
1040
1929
|
/**
|
|
@@ -1056,19 +1945,18 @@ export interface components {
|
|
|
1056
1945
|
/**
|
|
1057
1946
|
* Format: date-time
|
|
1058
1947
|
* @description The timestamp at which the contract set was active.
|
|
1059
|
-
*
|
|
1060
|
-
*
|
|
1061
|
-
*
|
|
1948
|
+
* This needs to be an exact timestamp, i.e.,
|
|
1949
|
+
* needs to correspond to a timestamp reported by `/v0/state/acs/snapshot-timestamp` if `record_time_match` is set to `exact` (which is the default).
|
|
1950
|
+
* If `record_time_match` is set to `at_or_before`, this can be any timestamp, and the most recent snapshot at or before the given `record_time` will be returned.
|
|
1062
1951
|
*/
|
|
1063
1952
|
record_time: string;
|
|
1064
1953
|
/**
|
|
1065
1954
|
* @description How to match the record_time. "exact" requires the record_time to match exactly.
|
|
1066
|
-
*
|
|
1067
|
-
*
|
|
1955
|
+
* "at_or_before" finds the most recent snapshot at or before the given record_time.
|
|
1068
1956
|
* @default exact
|
|
1069
1957
|
* @enum {string}
|
|
1070
1958
|
*/
|
|
1071
|
-
record_time_match
|
|
1959
|
+
record_time_match: 'exact' | 'at_or_before';
|
|
1072
1960
|
/**
|
|
1073
1961
|
* Format: int64
|
|
1074
1962
|
* @description Pagination token for the next page of results.
|
|
@@ -1091,19 +1979,18 @@ export interface components {
|
|
|
1091
1979
|
/**
|
|
1092
1980
|
* Format: date-time
|
|
1093
1981
|
* @description The timestamp at which the contract set was active.
|
|
1094
|
-
*
|
|
1095
|
-
*
|
|
1096
|
-
*
|
|
1982
|
+
* This needs to be an exact timestamp, i.e.,
|
|
1983
|
+
* needs to correspond to a timestamp reported by `/v0/state/acs/snapshot-timestamp` if `record_time_match` is set to `exact` (which is the default).
|
|
1984
|
+
* If `record_time_match` is set to `at_or_before`, this can be any timestamp, and the most recent snapshot at or before the given `record_time` will be returned.
|
|
1097
1985
|
*/
|
|
1098
1986
|
record_time: string;
|
|
1099
1987
|
/**
|
|
1100
1988
|
* @description How to match the record_time. "exact" requires the record_time to match exactly.
|
|
1101
|
-
*
|
|
1102
|
-
*
|
|
1989
|
+
* "at_or_before" finds the most recent snapshot at or before the given record_time.
|
|
1103
1990
|
* @default exact
|
|
1104
1991
|
* @enum {string}
|
|
1105
1992
|
*/
|
|
1106
|
-
record_time_match
|
|
1993
|
+
record_time_match: 'exact' | 'at_or_before';
|
|
1107
1994
|
/** @description The owners for which to compute the summary. */
|
|
1108
1995
|
owner_party_ids: string[];
|
|
1109
1996
|
/**
|
|
@@ -1137,14 +2024,14 @@ export interface components {
|
|
|
1137
2024
|
migration_id: number;
|
|
1138
2025
|
/**
|
|
1139
2026
|
* @description Up to `page_size` contracts in the ACS.
|
|
1140
|
-
*
|
|
2027
|
+
* `create_arguments` are always encoded as `compact_json`.
|
|
1141
2028
|
*/
|
|
1142
2029
|
created_events: components['schemas']['CreatedEvent'][];
|
|
1143
2030
|
/**
|
|
1144
2031
|
* Format: int64
|
|
1145
2032
|
* @description When requesting the next page of results, pass this as `after`
|
|
1146
|
-
*
|
|
1147
|
-
*
|
|
2033
|
+
* to the `AcsRequest` or `HoldingsStateRequest`.
|
|
2034
|
+
* Will be absent when there are no more pages.
|
|
1148
2035
|
*/
|
|
1149
2036
|
next_page_token?: number;
|
|
1150
2037
|
};
|
|
@@ -1172,25 +2059,25 @@ export interface components {
|
|
|
1172
2059
|
party_id: string;
|
|
1173
2060
|
/**
|
|
1174
2061
|
* @description Sum of unlocked amulet at time of reception, not counting holding
|
|
1175
|
-
*
|
|
2062
|
+
* fees deducted since.
|
|
1176
2063
|
*/
|
|
1177
2064
|
total_unlocked_coin: string;
|
|
1178
2065
|
/**
|
|
1179
2066
|
* @description Sum of locked amulet at time of original amulet reception, not
|
|
1180
|
-
*
|
|
2067
|
+
* counting holding fees deducted since.
|
|
1181
2068
|
*/
|
|
1182
2069
|
total_locked_coin: string;
|
|
1183
2070
|
/** @description `total_unlocked_coin` + `total_locked_coin`. */
|
|
1184
2071
|
total_coin_holdings: string;
|
|
1185
2072
|
/**
|
|
1186
2073
|
* @description Sum of holding fees as of `computed_as_of_round` that apply to
|
|
1187
|
-
*
|
|
2074
|
+
* unlocked amulet.
|
|
1188
2075
|
*/
|
|
1189
2076
|
accumulated_holding_fees_unlocked: string;
|
|
1190
2077
|
/**
|
|
1191
2078
|
* @description Sum of holding fees as of `computed_as_of_round` that apply to
|
|
1192
|
-
*
|
|
1193
|
-
*
|
|
2079
|
+
* locked amulet, including fees applied since the amulet's creation
|
|
2080
|
+
* round.
|
|
1194
2081
|
*/
|
|
1195
2082
|
accumulated_holding_fees_locked: string;
|
|
1196
2083
|
/** @description Same as `accumulated_holding_fees_unlocked` + `accumulated_holding_fees_locked`. */
|
|
@@ -1201,7 +2088,7 @@ export interface components {
|
|
|
1201
2088
|
ListActivityRequest: {
|
|
1202
2089
|
/**
|
|
1203
2090
|
* @description Minimal event_id for returned activities.
|
|
1204
|
-
*
|
|
2091
|
+
* Note that all activities carry some monotonically-increasing event_id. begin_after_id sets the minimum value for event_id's for the query.
|
|
1205
2092
|
*/
|
|
1206
2093
|
begin_after_id?: string;
|
|
1207
2094
|
/**
|
|
@@ -1216,9 +2103,8 @@ export interface components {
|
|
|
1216
2103
|
ListActivityResponseItem: {
|
|
1217
2104
|
/**
|
|
1218
2105
|
* @description Describes the type of activity that occurred.
|
|
1219
|
-
*
|
|
1220
|
-
*
|
|
1221
|
-
*
|
|
2106
|
+
* Determines if the data for the activity should be read
|
|
2107
|
+
* from the `transfer`, `mint`, or `tap` property.
|
|
1222
2108
|
* @enum {string}
|
|
1223
2109
|
*/
|
|
1224
2110
|
activity_type: 'transfer' | 'mint' | 'devnet_tap' | 'abort_transfer_instruction';
|
|
@@ -1226,7 +2112,7 @@ export interface components {
|
|
|
1226
2112
|
event_id: string;
|
|
1227
2113
|
/**
|
|
1228
2114
|
* @description The ledger offset of the event.
|
|
1229
|
-
*
|
|
2115
|
+
* Note that this field may not be the same across nodes, and therefore should not be compared between SVs.
|
|
1230
2116
|
*/
|
|
1231
2117
|
offset?: string;
|
|
1232
2118
|
/**
|
|
@@ -1278,7 +2164,7 @@ export interface components {
|
|
|
1278
2164
|
party: string;
|
|
1279
2165
|
/**
|
|
1280
2166
|
* @description The change to the total balance introduced by this balance change, normalized to round zero, i.e.,
|
|
1281
|
-
*
|
|
2167
|
+
* a amulet created in round 3 is treated as a amulet created in round 0 with a higher initial amount.
|
|
1282
2168
|
*/
|
|
1283
2169
|
change_to_initial_amount_as_of_round_zero: string;
|
|
1284
2170
|
/** @description The change of total holding fees introduced by this balance change. */
|
|
@@ -1305,8 +2191,8 @@ export interface components {
|
|
|
1305
2191
|
input_validator_faucet_amount?: string;
|
|
1306
2192
|
/**
|
|
1307
2193
|
* @description Fee charged for returning change to the sender,
|
|
1308
|
-
*
|
|
1309
|
-
*
|
|
2194
|
+
* which is the smaller of the left-over balance after paying for all outputs
|
|
2195
|
+
* or one amulet create fee.
|
|
1310
2196
|
*/
|
|
1311
2197
|
sender_change_fee: string;
|
|
1312
2198
|
/** @description The final amount of amulet returned to the sender after paying for all outputs and fees. */
|
|
@@ -1349,7 +2235,7 @@ export interface components {
|
|
|
1349
2235
|
};
|
|
1350
2236
|
/**
|
|
1351
2237
|
* @description A contract of Daml template `Splice.ExternalPartyAmuletRules:TransferCommand`,
|
|
1352
|
-
*
|
|
2238
|
+
* and its status determined by the latest transactions.
|
|
1353
2239
|
*/
|
|
1354
2240
|
TransferCommandContractWithStatus: {
|
|
1355
2241
|
contract: components['schemas']['Contract'];
|
|
@@ -1359,33 +2245,50 @@ export interface components {
|
|
|
1359
2245
|
BaseLookupTransferCommandStatusResponse: {
|
|
1360
2246
|
/**
|
|
1361
2247
|
* @description The status of the transfer command.
|
|
1362
|
-
*
|
|
1363
|
-
*
|
|
1364
|
-
*
|
|
1365
|
-
*
|
|
1366
|
-
*
|
|
1367
|
-
*
|
|
1368
|
-
*
|
|
2248
|
+
* created:
|
|
2249
|
+
* The transfer command has been created and is waiting for automation to complete it.
|
|
2250
|
+
* sent:
|
|
2251
|
+
* The transfer command has been completed and the transfer to the receiver has finished.
|
|
2252
|
+
* failed:
|
|
2253
|
+
* The transfer command has failed permanently and nothing has been transferred. Refer to
|
|
2254
|
+
* failure_reason for details. A new transfer command can be created.
|
|
1369
2255
|
*/
|
|
1370
2256
|
status: string;
|
|
1371
2257
|
};
|
|
1372
|
-
TransferCommandCreatedResponse: components['schemas']['BaseLookupTransferCommandStatusResponse']
|
|
1373
|
-
|
|
2258
|
+
TransferCommandCreatedResponse: components['schemas']['BaseLookupTransferCommandStatusResponse'] & {
|
|
2259
|
+
/**
|
|
2260
|
+
* @description discriminator enum property added by openapi-typescript
|
|
2261
|
+
* @enum {string}
|
|
2262
|
+
*/
|
|
2263
|
+
status: 'created';
|
|
2264
|
+
};
|
|
2265
|
+
TransferCommandSentResponse: components['schemas']['BaseLookupTransferCommandStatusResponse'] & {
|
|
2266
|
+
/**
|
|
2267
|
+
* @description discriminator enum property added by openapi-typescript
|
|
2268
|
+
* @enum {string}
|
|
2269
|
+
*/
|
|
2270
|
+
status: 'sent';
|
|
2271
|
+
};
|
|
1374
2272
|
TransferCommandFailedResponse: components['schemas']['BaseLookupTransferCommandStatusResponse'] & {
|
|
1375
2273
|
/**
|
|
1376
2274
|
* @description The reason for the failure of the TransferCommand.
|
|
1377
|
-
*
|
|
1378
|
-
*
|
|
1379
|
-
*
|
|
1380
|
-
*
|
|
1381
|
-
*
|
|
1382
|
-
*
|
|
1383
|
-
*
|
|
2275
|
+
* failed:
|
|
2276
|
+
* Completing the transfer failed, check the reason for details.
|
|
2277
|
+
* withdrawn:
|
|
2278
|
+
* The sender has withdrawn the TransferCommand before it could be completed.
|
|
2279
|
+
* expired:
|
|
2280
|
+
* The expiry time on the TransferCommand was reached before it could be completed.
|
|
1384
2281
|
* @enum {string}
|
|
1385
2282
|
*/
|
|
1386
2283
|
failure_kind: 'failed' | 'expired' | 'withdrawn';
|
|
1387
2284
|
/** @description Human readable description of the failure */
|
|
1388
2285
|
reason: string;
|
|
2286
|
+
} & {
|
|
2287
|
+
/**
|
|
2288
|
+
* @description discriminator enum property added by openapi-typescript
|
|
2289
|
+
* @enum {string}
|
|
2290
|
+
*/
|
|
2291
|
+
status: 'failed';
|
|
1389
2292
|
};
|
|
1390
2293
|
GetAcsSnapshotResponse: {
|
|
1391
2294
|
/** @description base64-encoded ACS snapshot for the intersection of the DSO party and the requested party’s ACS */
|
|
@@ -1394,7 +2297,7 @@ export interface components {
|
|
|
1394
2297
|
AnsEntry: {
|
|
1395
2298
|
/**
|
|
1396
2299
|
* @description If present, Daml contract ID of template `Splice.Ans:AnsEntry`.
|
|
1397
|
-
*
|
|
2300
|
+
* If absent, this is a DSO-provided entry for either the DSO or an SV.
|
|
1398
2301
|
*/
|
|
1399
2302
|
contract_id?: string;
|
|
1400
2303
|
/** @description Owner party ID of this ANS entry. */
|
|
@@ -1408,9 +2311,9 @@ export interface components {
|
|
|
1408
2311
|
/**
|
|
1409
2312
|
* Format: date-time
|
|
1410
2313
|
* @description Time after which this ANS entry expires; if renewed, it will have a
|
|
1411
|
-
*
|
|
1412
|
-
*
|
|
1413
|
-
*
|
|
2314
|
+
* new `contract_id` and `expires_at`.
|
|
2315
|
+
* If `null` or absent, does not expire; this is the case only for
|
|
2316
|
+
* special entries provided by the DSO.
|
|
1414
2317
|
*/
|
|
1415
2318
|
expires_at?: string;
|
|
1416
2319
|
};
|
|
@@ -1503,12 +2406,12 @@ export interface components {
|
|
|
1503
2406
|
previous_migration_id?: number;
|
|
1504
2407
|
/**
|
|
1505
2408
|
* @description All domains for which there are updates in the given migration id,
|
|
1506
|
-
*
|
|
2409
|
+
* along with the record time of the newest and oldest update associated with each domain
|
|
1507
2410
|
*/
|
|
1508
2411
|
record_time_range: components['schemas']['RecordTimeRange'][];
|
|
1509
2412
|
/**
|
|
1510
2413
|
* @description The update id of the last import update (where import updates are sorted by update id, ascending)
|
|
1511
|
-
*
|
|
2414
|
+
* for the given migration id, if any
|
|
1512
2415
|
*/
|
|
1513
2416
|
last_import_update_id?: string;
|
|
1514
2417
|
/** @description True if this scan has all non-import updates for given migration id */
|
|
@@ -1562,22 +2465,21 @@ export interface components {
|
|
|
1562
2465
|
};
|
|
1563
2466
|
/**
|
|
1564
2467
|
* @description How daml values should be encoded in the response.
|
|
1565
|
-
*
|
|
1566
|
-
*
|
|
1567
|
-
*
|
|
1568
|
-
*
|
|
1569
|
-
*
|
|
1570
|
-
*
|
|
1571
|
-
*
|
|
2468
|
+
* "compact_json" is a compact, human-readable JSON encoding. It is the same encoding
|
|
2469
|
+
* as the one used in the HTTP JSON API or the JavaScript codegen.
|
|
2470
|
+
* "protobuf_json" is a verbose JSON encoding that is more difficult to parse,
|
|
2471
|
+
* but contains type information, i.e., the values can be parsed losslessly
|
|
2472
|
+
* without having access to the Daml source code.
|
|
2473
|
+
* Optional and defaults to "compact_json".
|
|
1572
2474
|
* @enum {string}
|
|
1573
2475
|
*/
|
|
1574
2476
|
DamlValueEncoding: 'compact_json' | 'protobuf_json';
|
|
1575
2477
|
GetMemberTrafficStatusResponse: {
|
|
1576
2478
|
/**
|
|
1577
2479
|
* @description The current traffic state for the member on the synchronizer under
|
|
1578
|
-
*
|
|
1579
|
-
*
|
|
1580
|
-
*
|
|
2480
|
+
* `actual`, and the total purchased traffic under `target`. The purchased
|
|
2481
|
+
* traffic may exceed the `actual` limit as purchases take time to be
|
|
2482
|
+
* incorporated into the limit.
|
|
1581
2483
|
*/
|
|
1582
2484
|
traffic_status: components['schemas']['MemberTrafficStatus'];
|
|
1583
2485
|
};
|
|
@@ -1596,7 +2498,7 @@ export interface components {
|
|
|
1596
2498
|
/**
|
|
1597
2499
|
* Format: int64
|
|
1598
2500
|
* @description Current extra traffic limit set for the member on the given synchronizer.
|
|
1599
|
-
*
|
|
2501
|
+
* An extra traffic top-up is complete once total_limit matches total_purchased.
|
|
1600
2502
|
*/
|
|
1601
2503
|
total_limit: number;
|
|
1602
2504
|
};
|
|
@@ -1604,21 +2506,21 @@ export interface components {
|
|
|
1604
2506
|
/**
|
|
1605
2507
|
* Format: int64
|
|
1606
2508
|
* @description Total extra traffic purchased for the member on the given
|
|
1607
|
-
*
|
|
2509
|
+
* synchronizer in bytes.
|
|
1608
2510
|
*/
|
|
1609
2511
|
total_purchased: number;
|
|
1610
2512
|
};
|
|
1611
2513
|
GetPartyToParticipantResponse: {
|
|
1612
2514
|
/**
|
|
1613
2515
|
* @description ID of the participant hosting the provided party, in the form
|
|
1614
|
-
*
|
|
2516
|
+
* `PAR::id::fingerprint`
|
|
1615
2517
|
*/
|
|
1616
2518
|
participant_id: string;
|
|
1617
2519
|
};
|
|
1618
2520
|
GetValidatorFaucetsByValidatorResponse: {
|
|
1619
2521
|
/**
|
|
1620
2522
|
* @description Statistics for any party ID arguments found to have valid onboarding
|
|
1621
|
-
*
|
|
2523
|
+
* licenses; the order in the response is unrelated to argument order.
|
|
1622
2524
|
*/
|
|
1623
2525
|
validatorsReceivedFaucets: components['schemas']['ValidatorReceivedFaucets'][];
|
|
1624
2526
|
};
|
|
@@ -1628,27 +2530,27 @@ export interface components {
|
|
|
1628
2530
|
/**
|
|
1629
2531
|
* Format: int64
|
|
1630
2532
|
* @description how many rounds the validator has received a faucet for; guaranteed
|
|
1631
|
-
*
|
|
2533
|
+
* that collected + missed = last - first + 1
|
|
1632
2534
|
*/
|
|
1633
2535
|
numRoundsCollected: number;
|
|
1634
2536
|
/**
|
|
1635
2537
|
* Format: int64
|
|
1636
2538
|
* @description how many rounds between firstCollected and lastCollected in which
|
|
1637
|
-
*
|
|
1638
|
-
*
|
|
2539
|
+
* the validator failed to collect (i.e. was not active or available);
|
|
2540
|
+
* can at most be max(0, lastCollected - firstCollected - 1).
|
|
1639
2541
|
*/
|
|
1640
2542
|
numRoundsMissed: number;
|
|
1641
2543
|
/**
|
|
1642
2544
|
* Format: int64
|
|
1643
2545
|
* @description the round number when this validator started collecting faucets;
|
|
1644
|
-
*
|
|
2546
|
+
* the validator definitely recorded liveness in this round
|
|
1645
2547
|
*/
|
|
1646
2548
|
firstCollectedInRound: number;
|
|
1647
2549
|
/**
|
|
1648
2550
|
* Format: int64
|
|
1649
2551
|
* @description The most recent round number in which the validator collected a faucet;
|
|
1650
|
-
*
|
|
1651
|
-
*
|
|
2552
|
+
* the validator definitely recorded liveness in this round. Will equal
|
|
2553
|
+
* `firstCollected` if the validator has collected in only one round
|
|
1652
2554
|
*/
|
|
1653
2555
|
lastCollectedInRound: number;
|
|
1654
2556
|
};
|
|
@@ -1656,19 +2558,19 @@ export interface components {
|
|
|
1656
2558
|
/**
|
|
1657
2559
|
* @description True if ALL backfilling processes are complete, false otherwise.
|
|
1658
2560
|
*
|
|
1659
|
-
*
|
|
1660
|
-
*
|
|
1661
|
-
*
|
|
2561
|
+
* Some scan endpoints return error responses if backfilling is not complete
|
|
2562
|
+
* (e.g., `/v1/updates`), others return partial results (e.g., `/v0/transactions`).
|
|
2563
|
+
* This endpoint is a simple indicator for whether historical information may be incomplete.
|
|
1662
2564
|
*
|
|
1663
|
-
*
|
|
2565
|
+
* To determine the progress of individual backfilling processes, inspect the corresponding metrics.
|
|
1664
2566
|
*/
|
|
1665
2567
|
complete: boolean;
|
|
1666
2568
|
};
|
|
1667
2569
|
EventHistoryRequest: {
|
|
1668
2570
|
/**
|
|
1669
2571
|
* @description The events returned will either have a higher migration id or
|
|
1670
|
-
*
|
|
1671
|
-
*
|
|
2572
|
+
* the same migration id and a record_time greater than the migration id and record time
|
|
2573
|
+
* specified.
|
|
1672
2574
|
*/
|
|
1673
2575
|
after?: components['schemas']['UpdateHistoryRequestAfter'];
|
|
1674
2576
|
/**
|
|
@@ -1683,10 +2585,10 @@ export interface components {
|
|
|
1683
2585
|
};
|
|
1684
2586
|
/**
|
|
1685
2587
|
* @description An event history item may contain a transaction update, a verdict from a mediator, both, or a contract reassignment.
|
|
1686
|
-
*
|
|
1687
|
-
*
|
|
1688
|
-
*
|
|
1689
|
-
*
|
|
2588
|
+
* If an event pertains to a contract reassignment, there will be no verdict data.
|
|
2589
|
+
* If an event pertains to a wholly private transaction, there will only be verdict data.
|
|
2590
|
+
* If an event pertains to a transaction that is partially private, it may also bear verdict information for the private portions.
|
|
2591
|
+
* When both fields are present, the transaction and verdict have the same `update_id` and `record_time`.
|
|
1690
2592
|
*/
|
|
1691
2593
|
EventHistoryItem: {
|
|
1692
2594
|
update?: components['schemas']['UpdateHistoryItemV2'];
|
|
@@ -1706,7 +2608,7 @@ export interface components {
|
|
|
1706
2608
|
record_time: string;
|
|
1707
2609
|
/**
|
|
1708
2610
|
* @description The finalization_time of the transaction the verdict corresponds to.
|
|
1709
|
-
*
|
|
2611
|
+
* Note that this time might be different between different scans/mediators.
|
|
1710
2612
|
*/
|
|
1711
2613
|
finalization_time: string;
|
|
1712
2614
|
/** @description Parties on whose behalf the transaction was submitted. */
|
|
@@ -1789,40 +2691,40 @@ export interface components {
|
|
|
1789
2691
|
sv_party_id: string;
|
|
1790
2692
|
/**
|
|
1791
2693
|
* @description Party representing the whole DSO; for Scan only, also returned by
|
|
1792
|
-
*
|
|
2694
|
+
* `/v0/dso-party-id`
|
|
1793
2695
|
*/
|
|
1794
2696
|
dso_party_id: string;
|
|
1795
2697
|
/**
|
|
1796
2698
|
* @description Threshold required to pass vote requests; also known as the
|
|
1797
|
-
*
|
|
1798
|
-
*
|
|
2699
|
+
* "governance threshold", it is always derived from the number of
|
|
2700
|
+
* `svs` in `dso_rules`
|
|
1799
2701
|
*/
|
|
1800
2702
|
voting_threshold: number;
|
|
1801
2703
|
/**
|
|
1802
2704
|
* @description Contract of the Daml template `Splice.Round.OpenMiningRound`, the
|
|
1803
|
-
*
|
|
1804
|
-
*
|
|
1805
|
-
*
|
|
2705
|
+
* one with the highest round number on the ledger that has been signed
|
|
2706
|
+
* by `dso_party_id`. The round may not be usable as it may not be
|
|
2707
|
+
* opened yet, in accordance with its `opensAt` template field
|
|
1806
2708
|
*/
|
|
1807
2709
|
latest_mining_round: components['schemas']['ContractWithState'];
|
|
1808
2710
|
/**
|
|
1809
2711
|
* @description Contract of the Daml template `Splice.AmuletRules.AmuletRules`,
|
|
1810
|
-
*
|
|
1811
|
-
*
|
|
1812
|
-
*
|
|
1813
|
-
*
|
|
2712
|
+
* including the full schedule of `AmuletConfig` changes approved by
|
|
2713
|
+
* the DSO. Callers should not assume that `initialValue` is up-to-date,
|
|
2714
|
+
* and should instead search `futureValues` for the latest configuration
|
|
2715
|
+
* valid as of now
|
|
1814
2716
|
*/
|
|
1815
2717
|
amulet_rules: components['schemas']['ContractWithState'];
|
|
1816
2718
|
/**
|
|
1817
2719
|
* @description Contract of the Daml template `Splice.DsoRules.DsoRules`, listing
|
|
1818
|
-
*
|
|
2720
|
+
* the governance rules approved by the DSO governing this Splice network.
|
|
1819
2721
|
*/
|
|
1820
2722
|
dso_rules: components['schemas']['ContractWithState'];
|
|
1821
2723
|
/**
|
|
1822
2724
|
* @description For every one of `svs` listed in `dso_rules`, a contract of the Daml
|
|
1823
|
-
*
|
|
1824
|
-
*
|
|
1825
|
-
*
|
|
2725
|
+
* template `Splice.DSO.SvState.SvNodeState`. This does not include
|
|
2726
|
+
* states for offboarded SVs, though they may still have an on-ledger
|
|
2727
|
+
* state contract
|
|
1826
2728
|
*/
|
|
1827
2729
|
sv_node_states: components['schemas']['ContractWithState'][];
|
|
1828
2730
|
/** @description Initial round from which the network bootstraps */
|
|
@@ -1834,7 +2736,7 @@ export interface components {
|
|
|
1834
2736
|
/**
|
|
1835
2737
|
* Format: int64
|
|
1836
2738
|
* @description When requesting the next page of results, pass this as URL query parameter `after`.
|
|
1837
|
-
*
|
|
2739
|
+
* If absent or `null`, there are no more pages.
|
|
1838
2740
|
*/
|
|
1839
2741
|
next_page_token?: number;
|
|
1840
2742
|
};
|
|
@@ -1845,12 +2747,12 @@ export interface components {
|
|
|
1845
2747
|
};
|
|
1846
2748
|
/**
|
|
1847
2749
|
* @description Always created with respect to an input set of contract IDs. If an input
|
|
1848
|
-
*
|
|
1849
|
-
*
|
|
1850
|
-
*
|
|
1851
|
-
*
|
|
1852
|
-
*
|
|
1853
|
-
*
|
|
2750
|
+
* contract ID is absent from the keys of this map, that contract should be
|
|
2751
|
+
* considered removed by the caller; if present, `contract` may be empty,
|
|
2752
|
+
* reflecting that the caller should already have the full contract data
|
|
2753
|
+
* for that contract ID. Contracts not present in the input set will have
|
|
2754
|
+
* full contract data. `domain_id` is always up-to-date; if undefined the
|
|
2755
|
+
* contract is currently unassigned to a synchronizer, i.e. "in-flight".
|
|
1854
2756
|
*/
|
|
1855
2757
|
MaybeCachedContractWithStateMap: {
|
|
1856
2758
|
[key: string]: components['schemas']['MaybeCachedContractWithState'];
|
|
@@ -1866,7 +2768,7 @@ export interface components {
|
|
|
1866
2768
|
ListVoteRequestByTrackingCidResponse: {
|
|
1867
2769
|
/**
|
|
1868
2770
|
* @description Contracts of Daml template `Splice.DsoRules:VoteRequest` that match
|
|
1869
|
-
*
|
|
2771
|
+
* `vote_request_contract_ids` in the request.
|
|
1870
2772
|
*/
|
|
1871
2773
|
vote_requests: components['schemas']['Contract'][];
|
|
1872
2774
|
};
|
|
@@ -1896,18 +2798,27 @@ export interface components {
|
|
|
1896
2798
|
responses: {
|
|
1897
2799
|
/** @description bad request */
|
|
1898
2800
|
400: {
|
|
2801
|
+
headers: {
|
|
2802
|
+
[name: string]: unknown;
|
|
2803
|
+
};
|
|
1899
2804
|
content: {
|
|
1900
2805
|
'application/json': components['schemas']['ErrorResponse'];
|
|
1901
2806
|
};
|
|
1902
2807
|
};
|
|
1903
2808
|
/** @description not found */
|
|
1904
2809
|
404: {
|
|
2810
|
+
headers: {
|
|
2811
|
+
[name: string]: unknown;
|
|
2812
|
+
};
|
|
1905
2813
|
content: {
|
|
1906
2814
|
'application/json': components['schemas']['ErrorResponse'];
|
|
1907
2815
|
};
|
|
1908
2816
|
};
|
|
1909
2817
|
/** @description internal server error */
|
|
1910
2818
|
500: {
|
|
2819
|
+
headers: {
|
|
2820
|
+
[name: string]: unknown;
|
|
2821
|
+
};
|
|
1911
2822
|
content: {
|
|
1912
2823
|
'application/json': components['schemas']['ErrorResponse'];
|
|
1913
2824
|
};
|
|
@@ -1919,36 +2830,71 @@ export interface components {
|
|
|
1919
2830
|
pathItems: never;
|
|
1920
2831
|
}
|
|
1921
2832
|
export type $defs = Record<string, never>;
|
|
1922
|
-
export type external = Record<string, never>;
|
|
1923
2833
|
export interface operations {
|
|
1924
2834
|
isReady: {
|
|
2835
|
+
parameters: {
|
|
2836
|
+
query?: never;
|
|
2837
|
+
header?: never;
|
|
2838
|
+
path?: never;
|
|
2839
|
+
cookie?: never;
|
|
2840
|
+
};
|
|
2841
|
+
requestBody?: never;
|
|
1925
2842
|
responses: {
|
|
1926
2843
|
/** @description ok */
|
|
1927
2844
|
200: {
|
|
1928
|
-
|
|
2845
|
+
headers: {
|
|
2846
|
+
[name: string]: unknown;
|
|
2847
|
+
};
|
|
2848
|
+
content?: never;
|
|
1929
2849
|
};
|
|
1930
2850
|
/** @description service_unavailable */
|
|
1931
2851
|
503: {
|
|
1932
|
-
|
|
2852
|
+
headers: {
|
|
2853
|
+
[name: string]: unknown;
|
|
2854
|
+
};
|
|
2855
|
+
content?: never;
|
|
1933
2856
|
};
|
|
1934
2857
|
};
|
|
1935
2858
|
};
|
|
1936
2859
|
isLive: {
|
|
2860
|
+
parameters: {
|
|
2861
|
+
query?: never;
|
|
2862
|
+
header?: never;
|
|
2863
|
+
path?: never;
|
|
2864
|
+
cookie?: never;
|
|
2865
|
+
};
|
|
2866
|
+
requestBody?: never;
|
|
1937
2867
|
responses: {
|
|
1938
2868
|
/** @description ok */
|
|
1939
2869
|
200: {
|
|
1940
|
-
|
|
2870
|
+
headers: {
|
|
2871
|
+
[name: string]: unknown;
|
|
2872
|
+
};
|
|
2873
|
+
content?: never;
|
|
1941
2874
|
};
|
|
1942
2875
|
/** @description service_unavailable */
|
|
1943
2876
|
503: {
|
|
1944
|
-
|
|
2877
|
+
headers: {
|
|
2878
|
+
[name: string]: unknown;
|
|
2879
|
+
};
|
|
2880
|
+
content?: never;
|
|
1945
2881
|
};
|
|
1946
2882
|
};
|
|
1947
2883
|
};
|
|
1948
2884
|
getHealthStatus: {
|
|
2885
|
+
parameters: {
|
|
2886
|
+
query?: never;
|
|
2887
|
+
header?: never;
|
|
2888
|
+
path?: never;
|
|
2889
|
+
cookie?: never;
|
|
2890
|
+
};
|
|
2891
|
+
requestBody?: never;
|
|
1949
2892
|
responses: {
|
|
1950
2893
|
/** @description ok */
|
|
1951
2894
|
200: {
|
|
2895
|
+
headers: {
|
|
2896
|
+
[name: string]: unknown;
|
|
2897
|
+
};
|
|
1952
2898
|
content: {
|
|
1953
2899
|
'application/json': components['schemas']['NodeStatus'];
|
|
1954
2900
|
};
|
|
@@ -1956,9 +2902,19 @@ export interface operations {
|
|
|
1956
2902
|
};
|
|
1957
2903
|
};
|
|
1958
2904
|
getVersion: {
|
|
2905
|
+
parameters: {
|
|
2906
|
+
query?: never;
|
|
2907
|
+
header?: never;
|
|
2908
|
+
path?: never;
|
|
2909
|
+
cookie?: never;
|
|
2910
|
+
};
|
|
2911
|
+
requestBody?: never;
|
|
1959
2912
|
responses: {
|
|
1960
2913
|
/** @description ok */
|
|
1961
2914
|
200: {
|
|
2915
|
+
headers: {
|
|
2916
|
+
[name: string]: unknown;
|
|
2917
|
+
};
|
|
1962
2918
|
content: {
|
|
1963
2919
|
'application/json': components['schemas']['Version'];
|
|
1964
2920
|
};
|
|
@@ -1966,33 +2922,45 @@ export interface operations {
|
|
|
1966
2922
|
};
|
|
1967
2923
|
};
|
|
1968
2924
|
getDsoInfo: {
|
|
2925
|
+
parameters: {
|
|
2926
|
+
query?: never;
|
|
2927
|
+
header?: never;
|
|
2928
|
+
path?: never;
|
|
2929
|
+
cookie?: never;
|
|
2930
|
+
};
|
|
2931
|
+
requestBody?: never;
|
|
1969
2932
|
responses: {
|
|
1970
2933
|
/** @description ok */
|
|
1971
2934
|
200: {
|
|
2935
|
+
headers: {
|
|
2936
|
+
[name: string]: unknown;
|
|
2937
|
+
};
|
|
1972
2938
|
content: {
|
|
1973
2939
|
'application/json': components['schemas']['GetDsoInfoResponse'];
|
|
1974
2940
|
};
|
|
1975
2941
|
};
|
|
1976
2942
|
};
|
|
1977
2943
|
};
|
|
1978
|
-
/**
|
|
1979
|
-
* @description For every argument that is a valid onboarded validator, return
|
|
1980
|
-
* statistics on its liveness activity, according to on-ledger state at the
|
|
1981
|
-
* time of the request.
|
|
1982
|
-
*/
|
|
1983
2944
|
getValidatorFaucetsByValidator: {
|
|
1984
2945
|
parameters: {
|
|
1985
2946
|
query: {
|
|
1986
2947
|
/**
|
|
1987
2948
|
* @description A list of validator party IDs, one per specification of the parameter.
|
|
1988
|
-
*
|
|
2949
|
+
* Any party IDs not matching onboarded validators will be ignored
|
|
1989
2950
|
*/
|
|
1990
2951
|
validator_ids: string[];
|
|
1991
2952
|
};
|
|
2953
|
+
header?: never;
|
|
2954
|
+
path?: never;
|
|
2955
|
+
cookie?: never;
|
|
1992
2956
|
};
|
|
2957
|
+
requestBody?: never;
|
|
1993
2958
|
responses: {
|
|
1994
2959
|
/** @description ok */
|
|
1995
2960
|
200: {
|
|
2961
|
+
headers: {
|
|
2962
|
+
[name: string]: unknown;
|
|
2963
|
+
};
|
|
1996
2964
|
content: {
|
|
1997
2965
|
'application/json': components['schemas']['GetValidatorFaucetsByValidatorResponse'];
|
|
1998
2966
|
};
|
|
@@ -2001,24 +2969,26 @@ export interface operations {
|
|
|
2001
2969
|
404: components['responses']['404'];
|
|
2002
2970
|
};
|
|
2003
2971
|
};
|
|
2004
|
-
/**
|
|
2005
|
-
* @description Retrieve Canton scan configuration for all SVs, grouped by
|
|
2006
|
-
* connected synchronizer ID
|
|
2007
|
-
*/
|
|
2008
2972
|
listDsoScans: {
|
|
2973
|
+
parameters: {
|
|
2974
|
+
query?: never;
|
|
2975
|
+
header?: never;
|
|
2976
|
+
path?: never;
|
|
2977
|
+
cookie?: never;
|
|
2978
|
+
};
|
|
2979
|
+
requestBody?: never;
|
|
2009
2980
|
responses: {
|
|
2010
2981
|
/** @description ok */
|
|
2011
2982
|
200: {
|
|
2983
|
+
headers: {
|
|
2984
|
+
[name: string]: unknown;
|
|
2985
|
+
};
|
|
2012
2986
|
content: {
|
|
2013
2987
|
'application/json': components['schemas']['ListDsoScansResponse'];
|
|
2014
2988
|
};
|
|
2015
2989
|
};
|
|
2016
2990
|
};
|
|
2017
2991
|
};
|
|
2018
|
-
/**
|
|
2019
|
-
* @description List all validators currently approved by members of the DSO, paginated,
|
|
2020
|
-
* sorted newest-first.
|
|
2021
|
-
*/
|
|
2022
2992
|
listValidatorLicenses: {
|
|
2023
2993
|
parameters: {
|
|
2024
2994
|
query?: {
|
|
@@ -2027,58 +2997,82 @@ export interface operations {
|
|
|
2027
2997
|
/** @description Maximum number of elements to return, 1000 by default. */
|
|
2028
2998
|
limit?: number;
|
|
2029
2999
|
};
|
|
3000
|
+
header?: never;
|
|
3001
|
+
path?: never;
|
|
3002
|
+
cookie?: never;
|
|
2030
3003
|
};
|
|
3004
|
+
requestBody?: never;
|
|
2031
3005
|
responses: {
|
|
2032
3006
|
/** @description ok */
|
|
2033
3007
|
200: {
|
|
3008
|
+
headers: {
|
|
3009
|
+
[name: string]: unknown;
|
|
3010
|
+
};
|
|
2034
3011
|
content: {
|
|
2035
3012
|
'application/json': components['schemas']['ListValidatorLicensesResponse'];
|
|
2036
3013
|
};
|
|
2037
3014
|
};
|
|
2038
3015
|
};
|
|
2039
3016
|
};
|
|
2040
|
-
/**
|
|
2041
|
-
* @description Retrieve Canton sequencer configuration for all SVs, grouped by
|
|
2042
|
-
* connected synchronizer ID
|
|
2043
|
-
*/
|
|
2044
3017
|
listDsoSequencers: {
|
|
3018
|
+
parameters: {
|
|
3019
|
+
query?: never;
|
|
3020
|
+
header?: never;
|
|
3021
|
+
path?: never;
|
|
3022
|
+
cookie?: never;
|
|
3023
|
+
};
|
|
3024
|
+
requestBody?: never;
|
|
2045
3025
|
responses: {
|
|
2046
3026
|
/** @description ok */
|
|
2047
3027
|
200: {
|
|
3028
|
+
headers: {
|
|
3029
|
+
[name: string]: unknown;
|
|
3030
|
+
};
|
|
2048
3031
|
content: {
|
|
2049
3032
|
'application/json': components['schemas']['ListDsoSequencersResponse'];
|
|
2050
3033
|
};
|
|
2051
3034
|
};
|
|
2052
3035
|
};
|
|
2053
3036
|
};
|
|
2054
|
-
/** @description Retrieve Canton BFT sequencer configuration for this SV, for each configured Synchronizer */
|
|
2055
3037
|
listSvBftSequencers: {
|
|
3038
|
+
parameters: {
|
|
3039
|
+
query?: never;
|
|
3040
|
+
header?: never;
|
|
3041
|
+
path?: never;
|
|
3042
|
+
cookie?: never;
|
|
3043
|
+
};
|
|
3044
|
+
requestBody?: never;
|
|
2056
3045
|
responses: {
|
|
2057
3046
|
/** @description ok */
|
|
2058
3047
|
200: {
|
|
3048
|
+
headers: {
|
|
3049
|
+
[name: string]: unknown;
|
|
3050
|
+
};
|
|
2059
3051
|
content: {
|
|
2060
3052
|
'application/json': components['schemas']['ListSvBftSequencersResponse'];
|
|
2061
3053
|
};
|
|
2062
3054
|
};
|
|
2063
3055
|
};
|
|
2064
3056
|
};
|
|
2065
|
-
/**
|
|
2066
|
-
* @description Get the ID of the participant hosting a given party. This will fail if
|
|
2067
|
-
* there are multiple party-to-participant mappings for the given
|
|
2068
|
-
* synchronizer and party, which is not currently supported.
|
|
2069
|
-
*/
|
|
2070
3057
|
getPartyToParticipant: {
|
|
2071
3058
|
parameters: {
|
|
3059
|
+
query?: never;
|
|
3060
|
+
header?: never;
|
|
2072
3061
|
path: {
|
|
2073
3062
|
/** @description The synchronizer ID to look up a mapping for. */
|
|
2074
3063
|
domain_id: string;
|
|
2075
3064
|
/** @description The party ID to lookup a participant ID for. */
|
|
2076
3065
|
party_id: string;
|
|
2077
3066
|
};
|
|
3067
|
+
cookie?: never;
|
|
2078
3068
|
};
|
|
3069
|
+
requestBody?: never;
|
|
2079
3070
|
responses: {
|
|
2080
3071
|
/** @description ok */
|
|
2081
3072
|
200: {
|
|
3073
|
+
headers: {
|
|
3074
|
+
[name: string]: unknown;
|
|
3075
|
+
};
|
|
2082
3076
|
content: {
|
|
2083
3077
|
'application/json': components['schemas']['GetPartyToParticipantResponse'];
|
|
2084
3078
|
};
|
|
@@ -2087,25 +3081,28 @@ export interface operations {
|
|
|
2087
3081
|
500: components['responses']['500'];
|
|
2088
3082
|
};
|
|
2089
3083
|
};
|
|
2090
|
-
/**
|
|
2091
|
-
* @description Get a member's traffic status as reported by the sequencer, according to
|
|
2092
|
-
* ledger state at the time of the request.
|
|
2093
|
-
*/
|
|
2094
3084
|
getMemberTrafficStatus: {
|
|
2095
3085
|
parameters: {
|
|
3086
|
+
query?: never;
|
|
3087
|
+
header?: never;
|
|
2096
3088
|
path: {
|
|
2097
3089
|
/** @description The synchronizer ID to look up traffic for. */
|
|
2098
3090
|
domain_id: string;
|
|
2099
3091
|
/**
|
|
2100
3092
|
* @description The participant or mediator whose traffic to look up, in the format
|
|
2101
|
-
*
|
|
3093
|
+
* `code::id::fingerprint` where `code` is `PAR` or `MED`.
|
|
2102
3094
|
*/
|
|
2103
3095
|
member_id: string;
|
|
2104
3096
|
};
|
|
3097
|
+
cookie?: never;
|
|
2105
3098
|
};
|
|
3099
|
+
requestBody?: never;
|
|
2106
3100
|
responses: {
|
|
2107
3101
|
/** @description ok */
|
|
2108
3102
|
200: {
|
|
3103
|
+
headers: {
|
|
3104
|
+
[name: string]: unknown;
|
|
3105
|
+
};
|
|
2109
3106
|
content: {
|
|
2110
3107
|
'application/json': components['schemas']['GetMemberTrafficStatusResponse'];
|
|
2111
3108
|
};
|
|
@@ -2115,26 +3112,33 @@ export interface operations {
|
|
|
2115
3112
|
500: components['responses']['500'];
|
|
2116
3113
|
};
|
|
2117
3114
|
};
|
|
2118
|
-
/**
|
|
2119
|
-
* @description Every closed mining round on the ledger still in post-close process for
|
|
2120
|
-
* the connected Splice network, in round number order, earliest-first.
|
|
2121
|
-
*/
|
|
2122
3115
|
getClosedRounds: {
|
|
3116
|
+
parameters: {
|
|
3117
|
+
query?: never;
|
|
3118
|
+
header?: never;
|
|
3119
|
+
path?: never;
|
|
3120
|
+
cookie?: never;
|
|
3121
|
+
};
|
|
3122
|
+
requestBody?: never;
|
|
2123
3123
|
responses: {
|
|
2124
3124
|
/** @description ok */
|
|
2125
3125
|
200: {
|
|
3126
|
+
headers: {
|
|
3127
|
+
[name: string]: unknown;
|
|
3128
|
+
};
|
|
2126
3129
|
content: {
|
|
2127
3130
|
'application/json': components['schemas']['GetClosedRoundsResponse'];
|
|
2128
3131
|
};
|
|
2129
3132
|
};
|
|
2130
3133
|
};
|
|
2131
3134
|
};
|
|
2132
|
-
/**
|
|
2133
|
-
* @description All current open and issuing mining rounds, if the request is empty;
|
|
2134
|
-
* passing contract IDs in the request can reduce the response data for
|
|
2135
|
-
* polling/client-cache-update efficiency.
|
|
2136
|
-
*/
|
|
2137
3135
|
getOpenAndIssuingMiningRounds: {
|
|
3136
|
+
parameters: {
|
|
3137
|
+
query?: never;
|
|
3138
|
+
header?: never;
|
|
3139
|
+
path?: never;
|
|
3140
|
+
cookie?: never;
|
|
3141
|
+
};
|
|
2138
3142
|
requestBody: {
|
|
2139
3143
|
content: {
|
|
2140
3144
|
'application/json': components['schemas']['GetOpenAndIssuingMiningRoundsRequest'];
|
|
@@ -2143,25 +3147,22 @@ export interface operations {
|
|
|
2143
3147
|
responses: {
|
|
2144
3148
|
/** @description ok */
|
|
2145
3149
|
200: {
|
|
3150
|
+
headers: {
|
|
3151
|
+
[name: string]: unknown;
|
|
3152
|
+
};
|
|
2146
3153
|
content: {
|
|
2147
3154
|
'application/json': components['schemas']['GetOpenAndIssuingMiningRoundsResponse'];
|
|
2148
3155
|
};
|
|
2149
3156
|
};
|
|
2150
3157
|
};
|
|
2151
3158
|
};
|
|
2152
|
-
/**
|
|
2153
|
-
* @description Returns the update history in ascending order, paged, from ledger begin or optionally starting after a record time.
|
|
2154
|
-
* Compared to `/v1/updates`, the `/v2/updates` removes the `offset` field in responses,
|
|
2155
|
-
* which was hardcoded to 1 in `/v1/updates` for compatibility, and is now removed.
|
|
2156
|
-
* `/v2/updates` sorts events lexicographically in `events_by_id` by `ID` for convenience, which should not be confused with the
|
|
2157
|
-
* order of events in the transaction, for this you should rely on the order of `root_event_ids` and `child_event_ids`.
|
|
2158
|
-
* Updates are ordered lexicographically by `(migration id, record time)`.
|
|
2159
|
-
* For a given migration id, each update has a unique record time.
|
|
2160
|
-
* The record time ranges of different migrations may overlap, i.e.,
|
|
2161
|
-
* it is not guaranteed that the maximum record time of one migration is smaller than the minimum record time of the next migration,
|
|
2162
|
-
* and there may be two updates with the same record time but different migration ids.
|
|
2163
|
-
*/
|
|
2164
3159
|
getUpdateHistoryV2: {
|
|
3160
|
+
parameters: {
|
|
3161
|
+
query?: never;
|
|
3162
|
+
header?: never;
|
|
3163
|
+
path?: never;
|
|
3164
|
+
cookie?: never;
|
|
3165
|
+
};
|
|
2165
3166
|
requestBody: {
|
|
2166
3167
|
content: {
|
|
2167
3168
|
'application/json': components['schemas']['UpdateHistoryRequestV2'];
|
|
@@ -2170,6 +3171,9 @@ export interface operations {
|
|
|
2170
3171
|
responses: {
|
|
2171
3172
|
/** @description ok */
|
|
2172
3173
|
200: {
|
|
3174
|
+
headers: {
|
|
3175
|
+
[name: string]: unknown;
|
|
3176
|
+
};
|
|
2173
3177
|
content: {
|
|
2174
3178
|
'application/json': components['schemas']['UpdateHistoryResponseV2'];
|
|
2175
3179
|
};
|
|
@@ -2178,25 +3182,24 @@ export interface operations {
|
|
|
2178
3182
|
500: components['responses']['500'];
|
|
2179
3183
|
};
|
|
2180
3184
|
};
|
|
2181
|
-
/**
|
|
2182
|
-
* @description Returns the update with the given update_id.
|
|
2183
|
-
* Compared to `/v1/updates/{update_id}`, the `/v2/updates/{update_id}` removes the `offset` field in responses,
|
|
2184
|
-
* which was hardcoded to 1 in `/v1/updates/{update_id}` for compatibility, and is now removed.
|
|
2185
|
-
* `/v2/updates/{update_id}` sorts events lexicographically in `events_by_id` by `ID` for convenience, which should not be confused with the
|
|
2186
|
-
* order of events in the transaction, for this you should rely on the order of `root_event_ids` and `child_event_ids`.
|
|
2187
|
-
*/
|
|
2188
3185
|
getUpdateByIdV2: {
|
|
2189
3186
|
parameters: {
|
|
2190
3187
|
query?: {
|
|
2191
3188
|
daml_value_encoding?: components['schemas']['DamlValueEncoding'];
|
|
2192
3189
|
};
|
|
3190
|
+
header?: never;
|
|
2193
3191
|
path: {
|
|
2194
3192
|
update_id: string;
|
|
2195
3193
|
};
|
|
3194
|
+
cookie?: never;
|
|
2196
3195
|
};
|
|
3196
|
+
requestBody?: never;
|
|
2197
3197
|
responses: {
|
|
2198
3198
|
/** @description ok */
|
|
2199
3199
|
200: {
|
|
3200
|
+
headers: {
|
|
3201
|
+
[name: string]: unknown;
|
|
3202
|
+
};
|
|
2200
3203
|
content: {
|
|
2201
3204
|
'application/json': components['schemas']['UpdateHistoryItemV2'];
|
|
2202
3205
|
};
|
|
@@ -2206,20 +3209,13 @@ export interface operations {
|
|
|
2206
3209
|
500: components['responses']['500'];
|
|
2207
3210
|
};
|
|
2208
3211
|
};
|
|
2209
|
-
/**
|
|
2210
|
-
* @deprecated
|
|
2211
|
-
* @description Returns the update history in ascending order, paged, from ledger begin or optionally starting after a record time.
|
|
2212
|
-
* Unlike /v0/updates, this endpoint returns responses that are consistent across different
|
|
2213
|
-
* scan instances. Event ids returned by this endpoint are not comparable to event ids returned by /v0/updates.
|
|
2214
|
-
*
|
|
2215
|
-
* Updates are ordered lexicographically by `(migration id, record time)`.
|
|
2216
|
-
* For a given migration id, each update has a unique record time.
|
|
2217
|
-
* The record time ranges of different migrations may overlap, i.e.,
|
|
2218
|
-
* it is not guaranteed that the maximum record time of one migration is smaller than the minimum record time of the next migration,
|
|
2219
|
-
* and there may be two updates with the same record time but different migration ids.
|
|
2220
|
-
* The order of items in events_by_id is not defined.
|
|
2221
|
-
*/
|
|
2222
3212
|
getUpdateHistoryV1: {
|
|
3213
|
+
parameters: {
|
|
3214
|
+
query?: never;
|
|
3215
|
+
header?: never;
|
|
3216
|
+
path?: never;
|
|
3217
|
+
cookie?: never;
|
|
3218
|
+
};
|
|
2223
3219
|
requestBody: {
|
|
2224
3220
|
content: {
|
|
2225
3221
|
'application/json': components['schemas']['UpdateHistoryRequestV1'];
|
|
@@ -2228,6 +3224,9 @@ export interface operations {
|
|
|
2228
3224
|
responses: {
|
|
2229
3225
|
/** @description ok */
|
|
2230
3226
|
200: {
|
|
3227
|
+
headers: {
|
|
3228
|
+
[name: string]: unknown;
|
|
3229
|
+
};
|
|
2231
3230
|
content: {
|
|
2232
3231
|
'application/json': components['schemas']['UpdateHistoryResponse'];
|
|
2233
3232
|
};
|
|
@@ -2236,25 +3235,24 @@ export interface operations {
|
|
|
2236
3235
|
500: components['responses']['500'];
|
|
2237
3236
|
};
|
|
2238
3237
|
};
|
|
2239
|
-
/**
|
|
2240
|
-
* @deprecated
|
|
2241
|
-
* @description Returns the update with the given update_id.
|
|
2242
|
-
* Unlike /v0/updates/{update_id}, this endpoint returns responses that are consistent across different
|
|
2243
|
-
* scan instances. Event ids returned by this endpoint are not comparable to event ids returned by /v0/updates.
|
|
2244
|
-
* The order of items in events_by_id is not defined.
|
|
2245
|
-
*/
|
|
2246
3238
|
getUpdateByIdV1: {
|
|
2247
3239
|
parameters: {
|
|
2248
3240
|
query?: {
|
|
2249
3241
|
daml_value_encoding?: components['schemas']['DamlValueEncoding'];
|
|
2250
3242
|
};
|
|
3243
|
+
header?: never;
|
|
2251
3244
|
path: {
|
|
2252
3245
|
update_id: string;
|
|
2253
3246
|
};
|
|
3247
|
+
cookie?: never;
|
|
2254
3248
|
};
|
|
3249
|
+
requestBody?: never;
|
|
2255
3250
|
responses: {
|
|
2256
3251
|
/** @description ok */
|
|
2257
3252
|
200: {
|
|
3253
|
+
headers: {
|
|
3254
|
+
[name: string]: unknown;
|
|
3255
|
+
};
|
|
2258
3256
|
content: {
|
|
2259
3257
|
'application/json': components['schemas']['UpdateHistoryItem'];
|
|
2260
3258
|
};
|
|
@@ -2264,20 +3262,23 @@ export interface operations {
|
|
|
2264
3262
|
500: components['responses']['500'];
|
|
2265
3263
|
};
|
|
2266
3264
|
};
|
|
2267
|
-
/**
|
|
2268
|
-
* @description Returns the timestamp of the most recent snapshot before the given date, for the given migration_id.
|
|
2269
|
-
* This corresponds to the record time of the last transaction in the snapshot.
|
|
2270
|
-
*/
|
|
2271
3265
|
getDateOfMostRecentSnapshotBefore: {
|
|
2272
3266
|
parameters: {
|
|
2273
3267
|
query: {
|
|
2274
3268
|
before: string;
|
|
2275
3269
|
migration_id: number;
|
|
2276
3270
|
};
|
|
3271
|
+
header?: never;
|
|
3272
|
+
path?: never;
|
|
3273
|
+
cookie?: never;
|
|
2277
3274
|
};
|
|
3275
|
+
requestBody?: never;
|
|
2278
3276
|
responses: {
|
|
2279
3277
|
/** @description ok */
|
|
2280
3278
|
200: {
|
|
3279
|
+
headers: {
|
|
3280
|
+
[name: string]: unknown;
|
|
3281
|
+
};
|
|
2281
3282
|
content: {
|
|
2282
3283
|
'application/json': components['schemas']['AcsSnapshotTimestampResponse'];
|
|
2283
3284
|
};
|
|
@@ -2287,8 +3288,13 @@ export interface operations {
|
|
|
2287
3288
|
500: components['responses']['500'];
|
|
2288
3289
|
};
|
|
2289
3290
|
};
|
|
2290
|
-
/** @description Returns the ACS in creation date ascending order, paged, for a given migration id and record time. */
|
|
2291
3291
|
getAcsSnapshotAt: {
|
|
3292
|
+
parameters: {
|
|
3293
|
+
query?: never;
|
|
3294
|
+
header?: never;
|
|
3295
|
+
path?: never;
|
|
3296
|
+
cookie?: never;
|
|
3297
|
+
};
|
|
2292
3298
|
requestBody: {
|
|
2293
3299
|
content: {
|
|
2294
3300
|
'application/json': components['schemas']['AcsRequest'];
|
|
@@ -2297,6 +3303,9 @@ export interface operations {
|
|
|
2297
3303
|
responses: {
|
|
2298
3304
|
/** @description ok */
|
|
2299
3305
|
200: {
|
|
3306
|
+
headers: {
|
|
3307
|
+
[name: string]: unknown;
|
|
3308
|
+
};
|
|
2300
3309
|
content: {
|
|
2301
3310
|
'application/json': components['schemas']['AcsResponse'];
|
|
2302
3311
|
};
|
|
@@ -2306,17 +3315,20 @@ export interface operations {
|
|
|
2306
3315
|
500: components['responses']['500'];
|
|
2307
3316
|
};
|
|
2308
3317
|
};
|
|
2309
|
-
/**
|
|
2310
|
-
* @description Takes a snapshot of the ACS at the current time.
|
|
2311
|
-
* The responses can be used as parameters to `/v0/state/acs` to retrieve the snapshot.
|
|
2312
|
-
* Disabled in production environments due to its persistent alteration of
|
|
2313
|
-
* the behavior of future invocations of `/v0/state/acs`, as it causes an
|
|
2314
|
-
* immediate internal snapshot and delay in the next automatic snapshot.
|
|
2315
|
-
*/
|
|
2316
3318
|
forceAcsSnapshotNow: {
|
|
3319
|
+
parameters: {
|
|
3320
|
+
query?: never;
|
|
3321
|
+
header?: never;
|
|
3322
|
+
path?: never;
|
|
3323
|
+
cookie?: never;
|
|
3324
|
+
};
|
|
3325
|
+
requestBody?: never;
|
|
2317
3326
|
responses: {
|
|
2318
3327
|
/** @description ok */
|
|
2319
3328
|
200: {
|
|
3329
|
+
headers: {
|
|
3330
|
+
[name: string]: unknown;
|
|
3331
|
+
};
|
|
2320
3332
|
content: {
|
|
2321
3333
|
'application/json': components['schemas']['ForceAcsSnapshotResponse'];
|
|
2322
3334
|
};
|
|
@@ -2325,8 +3337,13 @@ export interface operations {
|
|
|
2325
3337
|
500: components['responses']['500'];
|
|
2326
3338
|
};
|
|
2327
3339
|
};
|
|
2328
|
-
/** @description Returns the active amulet contracts for a given migration id and record time, in creation date ascending order, paged. */
|
|
2329
3340
|
getHoldingsStateAt: {
|
|
3341
|
+
parameters: {
|
|
3342
|
+
query?: never;
|
|
3343
|
+
header?: never;
|
|
3344
|
+
path?: never;
|
|
3345
|
+
cookie?: never;
|
|
3346
|
+
};
|
|
2330
3347
|
requestBody: {
|
|
2331
3348
|
content: {
|
|
2332
3349
|
'application/json': components['schemas']['HoldingsStateRequest'];
|
|
@@ -2335,6 +3352,9 @@ export interface operations {
|
|
|
2335
3352
|
responses: {
|
|
2336
3353
|
/** @description ok */
|
|
2337
3354
|
200: {
|
|
3355
|
+
headers: {
|
|
3356
|
+
[name: string]: unknown;
|
|
3357
|
+
};
|
|
2338
3358
|
content: {
|
|
2339
3359
|
'application/json': components['schemas']['AcsResponse'];
|
|
2340
3360
|
};
|
|
@@ -2344,11 +3364,13 @@ export interface operations {
|
|
|
2344
3364
|
500: components['responses']['500'];
|
|
2345
3365
|
};
|
|
2346
3366
|
};
|
|
2347
|
-
/**
|
|
2348
|
-
* @description Returns the summary of active amulet contracts for a given migration id and record time, for the given parties.
|
|
2349
|
-
* This is an aggregate of `/v0/holdings/state` by owner party ID with better performance than client-side computation.
|
|
2350
|
-
*/
|
|
2351
3367
|
getHoldingsSummaryAt: {
|
|
3368
|
+
parameters: {
|
|
3369
|
+
query?: never;
|
|
3370
|
+
header?: never;
|
|
3371
|
+
path?: never;
|
|
3372
|
+
cookie?: never;
|
|
3373
|
+
};
|
|
2352
3374
|
requestBody: {
|
|
2353
3375
|
content: {
|
|
2354
3376
|
'application/json': components['schemas']['HoldingsSummaryRequest'];
|
|
@@ -2357,6 +3379,9 @@ export interface operations {
|
|
|
2357
3379
|
responses: {
|
|
2358
3380
|
/** @description ok */
|
|
2359
3381
|
200: {
|
|
3382
|
+
headers: {
|
|
3383
|
+
[name: string]: unknown;
|
|
3384
|
+
};
|
|
2360
3385
|
content: {
|
|
2361
3386
|
'application/json': components['schemas']['HoldingsSummaryResponse'];
|
|
2362
3387
|
};
|
|
@@ -2366,49 +3391,55 @@ export interface operations {
|
|
|
2366
3391
|
500: components['responses']['500'];
|
|
2367
3392
|
};
|
|
2368
3393
|
};
|
|
2369
|
-
/**
|
|
2370
|
-
* @description Lists all non-expired ANS entries whose names are prefixed with the
|
|
2371
|
-
* `name_prefix`, up to `page_size` entries.
|
|
2372
|
-
*/
|
|
2373
3394
|
listAnsEntries: {
|
|
2374
3395
|
parameters: {
|
|
2375
3396
|
query: {
|
|
2376
3397
|
/**
|
|
2377
3398
|
* @description Every result's name will start with this substring; if empty or absent,
|
|
2378
|
-
*
|
|
2379
|
-
*
|
|
3399
|
+
* all entries will be listed.
|
|
3400
|
+
* Does not have to be a whole word or segment; any substring will be accepted.
|
|
2380
3401
|
*/
|
|
2381
3402
|
name_prefix?: string;
|
|
2382
3403
|
/**
|
|
2383
3404
|
* @description The maximum number of results returned.
|
|
2384
|
-
*
|
|
3405
|
+
* Older (but still non-expired) results are listed first.
|
|
2385
3406
|
*/
|
|
2386
3407
|
page_size: number;
|
|
2387
3408
|
};
|
|
3409
|
+
header?: never;
|
|
3410
|
+
path?: never;
|
|
3411
|
+
cookie?: never;
|
|
2388
3412
|
};
|
|
3413
|
+
requestBody?: never;
|
|
2389
3414
|
responses: {
|
|
2390
3415
|
/** @description ok */
|
|
2391
3416
|
200: {
|
|
3417
|
+
headers: {
|
|
3418
|
+
[name: string]: unknown;
|
|
3419
|
+
};
|
|
2392
3420
|
content: {
|
|
2393
3421
|
'application/json': components['schemas']['ListEntriesResponse'];
|
|
2394
3422
|
};
|
|
2395
3423
|
};
|
|
2396
3424
|
};
|
|
2397
3425
|
};
|
|
2398
|
-
/**
|
|
2399
|
-
* @description If present, the first ANS entry for user `party` according to
|
|
2400
|
-
* `name` lexicographic order.
|
|
2401
|
-
*/
|
|
2402
3426
|
lookupAnsEntryByParty: {
|
|
2403
3427
|
parameters: {
|
|
3428
|
+
query?: never;
|
|
3429
|
+
header?: never;
|
|
2404
3430
|
path: {
|
|
2405
3431
|
/** @description The user party ID that holds the ANS entry. */
|
|
2406
3432
|
party: string;
|
|
2407
3433
|
};
|
|
3434
|
+
cookie?: never;
|
|
2408
3435
|
};
|
|
3436
|
+
requestBody?: never;
|
|
2409
3437
|
responses: {
|
|
2410
3438
|
/** @description ok */
|
|
2411
3439
|
200: {
|
|
3440
|
+
headers: {
|
|
3441
|
+
[name: string]: unknown;
|
|
3442
|
+
};
|
|
2412
3443
|
content: {
|
|
2413
3444
|
'application/json': components['schemas']['LookupEntryByPartyResponse'];
|
|
2414
3445
|
};
|
|
@@ -2416,16 +3447,22 @@ export interface operations {
|
|
|
2416
3447
|
404: components['responses']['404'];
|
|
2417
3448
|
};
|
|
2418
3449
|
};
|
|
2419
|
-
/** @description If present, the ANS entry named exactly `name`. */
|
|
2420
3450
|
lookupAnsEntryByName: {
|
|
2421
3451
|
parameters: {
|
|
3452
|
+
query?: never;
|
|
3453
|
+
header?: never;
|
|
2422
3454
|
path: {
|
|
2423
3455
|
name: string;
|
|
2424
3456
|
};
|
|
3457
|
+
cookie?: never;
|
|
2425
3458
|
};
|
|
3459
|
+
requestBody?: never;
|
|
2426
3460
|
responses: {
|
|
2427
3461
|
/** @description ok */
|
|
2428
3462
|
200: {
|
|
3463
|
+
headers: {
|
|
3464
|
+
[name: string]: unknown;
|
|
3465
|
+
};
|
|
2429
3466
|
content: {
|
|
2430
3467
|
'application/json': components['schemas']['LookupEntryByNameResponse'];
|
|
2431
3468
|
};
|
|
@@ -2433,11 +3470,20 @@ export interface operations {
|
|
|
2433
3470
|
404: components['responses']['404'];
|
|
2434
3471
|
};
|
|
2435
3472
|
};
|
|
2436
|
-
/** @description The party ID of the DSO for the Splice network connected by this Scan app. */
|
|
2437
3473
|
getDsoPartyId: {
|
|
3474
|
+
parameters: {
|
|
3475
|
+
query?: never;
|
|
3476
|
+
header?: never;
|
|
3477
|
+
path?: never;
|
|
3478
|
+
cookie?: never;
|
|
3479
|
+
};
|
|
3480
|
+
requestBody?: never;
|
|
2438
3481
|
responses: {
|
|
2439
3482
|
/** @description ok */
|
|
2440
3483
|
200: {
|
|
3484
|
+
headers: {
|
|
3485
|
+
[name: string]: unknown;
|
|
3486
|
+
};
|
|
2441
3487
|
content: {
|
|
2442
3488
|
'application/json': components['schemas']['GetDsoPartyIdResponse'];
|
|
2443
3489
|
};
|
|
@@ -2445,6 +3491,12 @@ export interface operations {
|
|
|
2445
3491
|
};
|
|
2446
3492
|
};
|
|
2447
3493
|
getAmuletRules: {
|
|
3494
|
+
parameters: {
|
|
3495
|
+
query?: never;
|
|
3496
|
+
header?: never;
|
|
3497
|
+
path?: never;
|
|
3498
|
+
cookie?: never;
|
|
3499
|
+
};
|
|
2448
3500
|
requestBody: {
|
|
2449
3501
|
content: {
|
|
2450
3502
|
'application/json': components['schemas']['GetAmuletRulesRequest'];
|
|
@@ -2453,6 +3505,9 @@ export interface operations {
|
|
|
2453
3505
|
responses: {
|
|
2454
3506
|
/** @description ok */
|
|
2455
3507
|
200: {
|
|
3508
|
+
headers: {
|
|
3509
|
+
[name: string]: unknown;
|
|
3510
|
+
};
|
|
2456
3511
|
content: {
|
|
2457
3512
|
'application/json': components['schemas']['GetAmuletRulesResponse'];
|
|
2458
3513
|
};
|
|
@@ -2460,6 +3515,12 @@ export interface operations {
|
|
|
2460
3515
|
};
|
|
2461
3516
|
};
|
|
2462
3517
|
getExternalPartyAmuletRules: {
|
|
3518
|
+
parameters: {
|
|
3519
|
+
query?: never;
|
|
3520
|
+
header?: never;
|
|
3521
|
+
path?: never;
|
|
3522
|
+
cookie?: never;
|
|
3523
|
+
};
|
|
2463
3524
|
requestBody: {
|
|
2464
3525
|
content: {
|
|
2465
3526
|
'application/json': components['schemas']['GetExternalPartyAmuletRulesRequest'];
|
|
@@ -2468,6 +3529,9 @@ export interface operations {
|
|
|
2468
3529
|
responses: {
|
|
2469
3530
|
/** @description ok */
|
|
2470
3531
|
200: {
|
|
3532
|
+
headers: {
|
|
3533
|
+
[name: string]: unknown;
|
|
3534
|
+
};
|
|
2471
3535
|
content: {
|
|
2472
3536
|
'application/json': components['schemas']['GetExternalPartyAmuletRulesResponse'];
|
|
2473
3537
|
};
|
|
@@ -2475,6 +3539,12 @@ export interface operations {
|
|
|
2475
3539
|
};
|
|
2476
3540
|
};
|
|
2477
3541
|
getAnsRules: {
|
|
3542
|
+
parameters: {
|
|
3543
|
+
query?: never;
|
|
3544
|
+
header?: never;
|
|
3545
|
+
path?: never;
|
|
3546
|
+
cookie?: never;
|
|
3547
|
+
};
|
|
2478
3548
|
requestBody: {
|
|
2479
3549
|
content: {
|
|
2480
3550
|
'application/json': components['schemas']['GetAnsRulesRequest'];
|
|
@@ -2483,59 +3553,77 @@ export interface operations {
|
|
|
2483
3553
|
responses: {
|
|
2484
3554
|
/** @description ok */
|
|
2485
3555
|
200: {
|
|
3556
|
+
headers: {
|
|
3557
|
+
[name: string]: unknown;
|
|
3558
|
+
};
|
|
2486
3559
|
content: {
|
|
2487
3560
|
'application/json': components['schemas']['GetAnsRulesResponse'];
|
|
2488
3561
|
};
|
|
2489
3562
|
};
|
|
2490
3563
|
};
|
|
2491
3564
|
};
|
|
2492
|
-
/** @description List every `FeaturedAppRight` registered with the DSO on the ledger. */
|
|
2493
3565
|
listFeaturedAppRights: {
|
|
3566
|
+
parameters: {
|
|
3567
|
+
query?: never;
|
|
3568
|
+
header?: never;
|
|
3569
|
+
path?: never;
|
|
3570
|
+
cookie?: never;
|
|
3571
|
+
};
|
|
3572
|
+
requestBody?: never;
|
|
2494
3573
|
responses: {
|
|
2495
3574
|
/** @description ok */
|
|
2496
3575
|
200: {
|
|
3576
|
+
headers: {
|
|
3577
|
+
[name: string]: unknown;
|
|
3578
|
+
};
|
|
2497
3579
|
content: {
|
|
2498
3580
|
'application/json': components['schemas']['ListFeaturedAppRightsResponse'];
|
|
2499
3581
|
};
|
|
2500
3582
|
};
|
|
2501
3583
|
};
|
|
2502
3584
|
};
|
|
2503
|
-
/**
|
|
2504
|
-
* @description If `provider_party_id` has a `FeaturedAppRight` registered with the DSO,
|
|
2505
|
-
* return it; `featured_app_right` will be empty otherwise.
|
|
2506
|
-
*/
|
|
2507
3585
|
lookupFeaturedAppRight: {
|
|
2508
3586
|
parameters: {
|
|
3587
|
+
query?: never;
|
|
3588
|
+
header?: never;
|
|
2509
3589
|
path: {
|
|
2510
3590
|
provider_party_id: string;
|
|
2511
3591
|
};
|
|
3592
|
+
cookie?: never;
|
|
2512
3593
|
};
|
|
3594
|
+
requestBody?: never;
|
|
2513
3595
|
responses: {
|
|
2514
3596
|
/** @description ok */
|
|
2515
3597
|
200: {
|
|
3598
|
+
headers: {
|
|
3599
|
+
[name: string]: unknown;
|
|
3600
|
+
};
|
|
2516
3601
|
content: {
|
|
2517
3602
|
'application/json': components['schemas']['LookupFeaturedAppRightResponse'];
|
|
2518
3603
|
};
|
|
2519
3604
|
};
|
|
2520
3605
|
};
|
|
2521
3606
|
};
|
|
2522
|
-
/**
|
|
2523
|
-
* @description Get a list of top validators by number of rounds in which they collected
|
|
2524
|
-
* faucets, and basis statistics on their round collection history
|
|
2525
|
-
*/
|
|
2526
3607
|
getTopValidatorsByValidatorFaucets: {
|
|
2527
3608
|
parameters: {
|
|
2528
3609
|
query: {
|
|
2529
3610
|
/**
|
|
2530
3611
|
* @description Maximum number of validator records that may be returned in the
|
|
2531
|
-
*
|
|
3612
|
+
* response
|
|
2532
3613
|
*/
|
|
2533
3614
|
limit: number;
|
|
2534
3615
|
};
|
|
3616
|
+
header?: never;
|
|
3617
|
+
path?: never;
|
|
3618
|
+
cookie?: never;
|
|
2535
3619
|
};
|
|
3620
|
+
requestBody?: never;
|
|
2536
3621
|
responses: {
|
|
2537
3622
|
/** @description ok */
|
|
2538
3623
|
200: {
|
|
3624
|
+
headers: {
|
|
3625
|
+
[name: string]: unknown;
|
|
3626
|
+
};
|
|
2539
3627
|
content: {
|
|
2540
3628
|
'application/json': components['schemas']['GetTopValidatorsByValidatorFaucetsResponse'];
|
|
2541
3629
|
};
|
|
@@ -2544,16 +3632,22 @@ export interface operations {
|
|
|
2544
3632
|
404: components['responses']['404'];
|
|
2545
3633
|
};
|
|
2546
3634
|
};
|
|
2547
|
-
/** @description Lookup a TransferPreapproval by the receiver party. */
|
|
2548
3635
|
lookupTransferPreapprovalByParty: {
|
|
2549
3636
|
parameters: {
|
|
3637
|
+
query?: never;
|
|
3638
|
+
header?: never;
|
|
2550
3639
|
path: {
|
|
2551
3640
|
party: string;
|
|
2552
3641
|
};
|
|
3642
|
+
cookie?: never;
|
|
2553
3643
|
};
|
|
3644
|
+
requestBody?: never;
|
|
2554
3645
|
responses: {
|
|
2555
3646
|
/** @description ok */
|
|
2556
3647
|
200: {
|
|
3648
|
+
headers: {
|
|
3649
|
+
[name: string]: unknown;
|
|
3650
|
+
};
|
|
2557
3651
|
content: {
|
|
2558
3652
|
'application/json': components['schemas']['LookupTransferPreapprovalByPartyResponse'];
|
|
2559
3653
|
};
|
|
@@ -2561,16 +3655,22 @@ export interface operations {
|
|
|
2561
3655
|
404: components['responses']['404'];
|
|
2562
3656
|
};
|
|
2563
3657
|
};
|
|
2564
|
-
/** @description Lookup a TransferCommandCounter by the receiver party. */
|
|
2565
3658
|
lookupTransferCommandCounterByParty: {
|
|
2566
3659
|
parameters: {
|
|
3660
|
+
query?: never;
|
|
3661
|
+
header?: never;
|
|
2567
3662
|
path: {
|
|
2568
3663
|
party: string;
|
|
2569
3664
|
};
|
|
3665
|
+
cookie?: never;
|
|
2570
3666
|
};
|
|
3667
|
+
requestBody?: never;
|
|
2571
3668
|
responses: {
|
|
2572
3669
|
/** @description ok */
|
|
2573
3670
|
200: {
|
|
3671
|
+
headers: {
|
|
3672
|
+
[name: string]: unknown;
|
|
3673
|
+
};
|
|
2574
3674
|
content: {
|
|
2575
3675
|
'application/json': components['schemas']['LookupTransferCommandCounterByPartyResponse'];
|
|
2576
3676
|
};
|
|
@@ -2579,17 +3679,23 @@ export interface operations {
|
|
|
2579
3679
|
404: components['responses']['404'];
|
|
2580
3680
|
};
|
|
2581
3681
|
};
|
|
2582
|
-
/** @description Retrieve the status of all transfer commands (up to a limit of 100) of the given sender for the specified nonce. */
|
|
2583
3682
|
lookupTransferCommandStatus: {
|
|
2584
3683
|
parameters: {
|
|
2585
3684
|
query: {
|
|
2586
3685
|
sender: string;
|
|
2587
3686
|
nonce: number;
|
|
2588
3687
|
};
|
|
3688
|
+
header?: never;
|
|
3689
|
+
path?: never;
|
|
3690
|
+
cookie?: never;
|
|
2589
3691
|
};
|
|
3692
|
+
requestBody?: never;
|
|
2590
3693
|
responses: {
|
|
2591
3694
|
/** @description ok */
|
|
2592
3695
|
200: {
|
|
3696
|
+
headers: {
|
|
3697
|
+
[name: string]: unknown;
|
|
3698
|
+
};
|
|
2593
3699
|
content: {
|
|
2594
3700
|
'application/json': components['schemas']['LookupTransferCommandStatusResponse'];
|
|
2595
3701
|
};
|
|
@@ -2598,33 +3704,49 @@ export interface operations {
|
|
|
2598
3704
|
404: components['responses']['404'];
|
|
2599
3705
|
};
|
|
2600
3706
|
};
|
|
2601
|
-
/**
|
|
2602
|
-
* @description If the DSO has scheduled a synchronizer upgrade, return its planned time
|
|
2603
|
-
* and the new migration ID.
|
|
2604
|
-
*/
|
|
2605
3707
|
getMigrationSchedule: {
|
|
3708
|
+
parameters: {
|
|
3709
|
+
query?: never;
|
|
3710
|
+
header?: never;
|
|
3711
|
+
path?: never;
|
|
3712
|
+
cookie?: never;
|
|
3713
|
+
};
|
|
3714
|
+
requestBody?: never;
|
|
2606
3715
|
responses: {
|
|
2607
3716
|
/** @description ok */
|
|
2608
3717
|
200: {
|
|
3718
|
+
headers: {
|
|
3719
|
+
[name: string]: unknown;
|
|
3720
|
+
};
|
|
2609
3721
|
content: {
|
|
2610
3722
|
'application/json': components['schemas']['MigrationSchedule'];
|
|
2611
3723
|
};
|
|
2612
3724
|
};
|
|
2613
3725
|
/** @description No migration scheduled */
|
|
2614
3726
|
404: {
|
|
2615
|
-
|
|
3727
|
+
headers: {
|
|
3728
|
+
[name: string]: unknown;
|
|
3729
|
+
};
|
|
3730
|
+
content?: never;
|
|
2616
3731
|
};
|
|
2617
3732
|
};
|
|
2618
3733
|
};
|
|
2619
3734
|
getSynchronizerIdentities: {
|
|
2620
3735
|
parameters: {
|
|
3736
|
+
query?: never;
|
|
3737
|
+
header?: never;
|
|
2621
3738
|
path: {
|
|
2622
3739
|
domain_id_prefix: string;
|
|
2623
3740
|
};
|
|
3741
|
+
cookie?: never;
|
|
2624
3742
|
};
|
|
3743
|
+
requestBody?: never;
|
|
2625
3744
|
responses: {
|
|
2626
3745
|
/** @description ok */
|
|
2627
3746
|
200: {
|
|
3747
|
+
headers: {
|
|
3748
|
+
[name: string]: unknown;
|
|
3749
|
+
};
|
|
2628
3750
|
content: {
|
|
2629
3751
|
'application/json': components['schemas']['SynchronizerIdentities'];
|
|
2630
3752
|
};
|
|
@@ -2634,13 +3756,20 @@ export interface operations {
|
|
|
2634
3756
|
};
|
|
2635
3757
|
getSynchronizerBootstrappingTransactions: {
|
|
2636
3758
|
parameters: {
|
|
3759
|
+
query?: never;
|
|
3760
|
+
header?: never;
|
|
2637
3761
|
path: {
|
|
2638
3762
|
domain_id_prefix: string;
|
|
2639
3763
|
};
|
|
3764
|
+
cookie?: never;
|
|
2640
3765
|
};
|
|
3766
|
+
requestBody?: never;
|
|
2641
3767
|
responses: {
|
|
2642
3768
|
/** @description ok */
|
|
2643
3769
|
200: {
|
|
3770
|
+
headers: {
|
|
3771
|
+
[name: string]: unknown;
|
|
3772
|
+
};
|
|
2644
3773
|
content: {
|
|
2645
3774
|
'application/json': components['schemas']['SynchronizerBootstrappingTransactions'];
|
|
2646
3775
|
};
|
|
@@ -2648,11 +3777,20 @@ export interface operations {
|
|
|
2648
3777
|
404: components['responses']['404'];
|
|
2649
3778
|
};
|
|
2650
3779
|
};
|
|
2651
|
-
/** @description Retrieve the UI names of various elements of this Splice network. */
|
|
2652
3780
|
getSpliceInstanceNames: {
|
|
3781
|
+
parameters: {
|
|
3782
|
+
query?: never;
|
|
3783
|
+
header?: never;
|
|
3784
|
+
path?: never;
|
|
3785
|
+
cookie?: never;
|
|
3786
|
+
};
|
|
3787
|
+
requestBody?: never;
|
|
2653
3788
|
responses: {
|
|
2654
3789
|
/** @description ok */
|
|
2655
3790
|
200: {
|
|
3791
|
+
headers: {
|
|
3792
|
+
[name: string]: unknown;
|
|
3793
|
+
};
|
|
2656
3794
|
content: {
|
|
2657
3795
|
'application/json': components['schemas']['GetSpliceInstanceNamesResponse'];
|
|
2658
3796
|
};
|
|
@@ -2660,19 +3798,33 @@ export interface operations {
|
|
|
2660
3798
|
404: components['responses']['404'];
|
|
2661
3799
|
};
|
|
2662
3800
|
};
|
|
2663
|
-
/** @description Retrieve a list of the latest amulet price votes */
|
|
2664
3801
|
listAmuletPriceVotes: {
|
|
3802
|
+
parameters: {
|
|
3803
|
+
query?: never;
|
|
3804
|
+
header?: never;
|
|
3805
|
+
path?: never;
|
|
3806
|
+
cookie?: never;
|
|
3807
|
+
};
|
|
3808
|
+
requestBody?: never;
|
|
2665
3809
|
responses: {
|
|
2666
3810
|
/** @description ok */
|
|
2667
3811
|
200: {
|
|
3812
|
+
headers: {
|
|
3813
|
+
[name: string]: unknown;
|
|
3814
|
+
};
|
|
2668
3815
|
content: {
|
|
2669
3816
|
'application/json': components['schemas']['ListAmuletPriceVotesResponse'];
|
|
2670
3817
|
};
|
|
2671
3818
|
};
|
|
2672
3819
|
};
|
|
2673
3820
|
};
|
|
2674
|
-
/** @description Look up several `VoteRequest`\ s at once by their contract IDs. */
|
|
2675
3821
|
listVoteRequestsByTrackingCid: {
|
|
3822
|
+
parameters: {
|
|
3823
|
+
query?: never;
|
|
3824
|
+
header?: never;
|
|
3825
|
+
path?: never;
|
|
3826
|
+
cookie?: never;
|
|
3827
|
+
};
|
|
2676
3828
|
requestBody: {
|
|
2677
3829
|
content: {
|
|
2678
3830
|
'application/json': components['schemas']['BatchListVotesByVoteRequestsRequest'];
|
|
@@ -2681,39 +3833,60 @@ export interface operations {
|
|
|
2681
3833
|
responses: {
|
|
2682
3834
|
/** @description ok */
|
|
2683
3835
|
200: {
|
|
3836
|
+
headers: {
|
|
3837
|
+
[name: string]: unknown;
|
|
3838
|
+
};
|
|
2684
3839
|
content: {
|
|
2685
3840
|
'application/json': components['schemas']['ListVoteRequestByTrackingCidResponse'];
|
|
2686
3841
|
};
|
|
2687
3842
|
};
|
|
2688
3843
|
};
|
|
2689
3844
|
};
|
|
2690
|
-
/** @description Look up a `VoteRequest` by contract ID. */
|
|
2691
3845
|
lookupDsoRulesVoteRequest: {
|
|
2692
3846
|
parameters: {
|
|
3847
|
+
query?: never;
|
|
3848
|
+
header?: never;
|
|
2693
3849
|
path: {
|
|
2694
3850
|
vote_request_contract_id: string;
|
|
2695
3851
|
};
|
|
3852
|
+
cookie?: never;
|
|
2696
3853
|
};
|
|
3854
|
+
requestBody?: never;
|
|
2697
3855
|
responses: {
|
|
2698
3856
|
/** @description ok */
|
|
2699
3857
|
200: {
|
|
3858
|
+
headers: {
|
|
3859
|
+
[name: string]: unknown;
|
|
3860
|
+
};
|
|
2700
3861
|
content: {
|
|
2701
3862
|
'application/json': components['schemas']['LookupDsoRulesVoteRequestResponse'];
|
|
2702
3863
|
};
|
|
2703
3864
|
};
|
|
2704
3865
|
/** @description VoteRequest contract not found. */
|
|
2705
3866
|
404: {
|
|
3867
|
+
headers: {
|
|
3868
|
+
[name: string]: unknown;
|
|
3869
|
+
};
|
|
2706
3870
|
content: {
|
|
2707
3871
|
'application/json': components['schemas']['ErrorResponse'];
|
|
2708
3872
|
};
|
|
2709
3873
|
};
|
|
2710
3874
|
};
|
|
2711
3875
|
};
|
|
2712
|
-
/** @description List all active `VoteRequest`\ s. */
|
|
2713
3876
|
listDsoRulesVoteRequests: {
|
|
3877
|
+
parameters: {
|
|
3878
|
+
query?: never;
|
|
3879
|
+
header?: never;
|
|
3880
|
+
path?: never;
|
|
3881
|
+
cookie?: never;
|
|
3882
|
+
};
|
|
3883
|
+
requestBody?: never;
|
|
2714
3884
|
responses: {
|
|
2715
3885
|
/** @description ok */
|
|
2716
3886
|
200: {
|
|
3887
|
+
headers: {
|
|
3888
|
+
[name: string]: unknown;
|
|
3889
|
+
};
|
|
2717
3890
|
content: {
|
|
2718
3891
|
'application/json': components['schemas']['ListDsoRulesVoteRequestsResponse'];
|
|
2719
3892
|
};
|
|
@@ -2721,6 +3894,12 @@ export interface operations {
|
|
|
2721
3894
|
};
|
|
2722
3895
|
};
|
|
2723
3896
|
listVoteRequestResults: {
|
|
3897
|
+
parameters: {
|
|
3898
|
+
query?: never;
|
|
3899
|
+
header?: never;
|
|
3900
|
+
path?: never;
|
|
3901
|
+
cookie?: never;
|
|
3902
|
+
};
|
|
2724
3903
|
requestBody: {
|
|
2725
3904
|
content: {
|
|
2726
3905
|
'application/json': components['schemas']['ListVoteResultsRequest'];
|
|
@@ -2729,14 +3908,22 @@ export interface operations {
|
|
|
2729
3908
|
responses: {
|
|
2730
3909
|
/** @description ok */
|
|
2731
3910
|
200: {
|
|
3911
|
+
headers: {
|
|
3912
|
+
[name: string]: unknown;
|
|
3913
|
+
};
|
|
2732
3914
|
content: {
|
|
2733
3915
|
'application/json': components['schemas']['ListDsoRulesVoteResultsResponse'];
|
|
2734
3916
|
};
|
|
2735
3917
|
};
|
|
2736
3918
|
};
|
|
2737
3919
|
};
|
|
2738
|
-
/** @description List all previous synchronizer migrations in this Splice network's history. */
|
|
2739
3920
|
getMigrationInfo: {
|
|
3921
|
+
parameters: {
|
|
3922
|
+
query?: never;
|
|
3923
|
+
header?: never;
|
|
3924
|
+
path?: never;
|
|
3925
|
+
cookie?: never;
|
|
3926
|
+
};
|
|
2740
3927
|
requestBody: {
|
|
2741
3928
|
content: {
|
|
2742
3929
|
'application/json': components['schemas']['GetMigrationInfoRequest'];
|
|
@@ -2745,6 +3932,9 @@ export interface operations {
|
|
|
2745
3932
|
responses: {
|
|
2746
3933
|
/** @description ok */
|
|
2747
3934
|
200: {
|
|
3935
|
+
headers: {
|
|
3936
|
+
[name: string]: unknown;
|
|
3937
|
+
};
|
|
2748
3938
|
content: {
|
|
2749
3939
|
'application/json': components['schemas']['GetMigrationInfoResponse'];
|
|
2750
3940
|
};
|
|
@@ -2752,11 +3942,13 @@ export interface operations {
|
|
|
2752
3942
|
404: components['responses']['404'];
|
|
2753
3943
|
};
|
|
2754
3944
|
};
|
|
2755
|
-
/**
|
|
2756
|
-
* @description Retrieve transactions and synchronizer reassignments prior to the
|
|
2757
|
-
* request's specification.
|
|
2758
|
-
*/
|
|
2759
3945
|
getUpdatesBefore: {
|
|
3946
|
+
parameters: {
|
|
3947
|
+
query?: never;
|
|
3948
|
+
header?: never;
|
|
3949
|
+
path?: never;
|
|
3950
|
+
cookie?: never;
|
|
3951
|
+
};
|
|
2760
3952
|
requestBody: {
|
|
2761
3953
|
content: {
|
|
2762
3954
|
'application/json': components['schemas']['GetUpdatesBeforeRequest'];
|
|
@@ -2765,6 +3957,9 @@ export interface operations {
|
|
|
2765
3957
|
responses: {
|
|
2766
3958
|
/** @description ok */
|
|
2767
3959
|
200: {
|
|
3960
|
+
headers: {
|
|
3961
|
+
[name: string]: unknown;
|
|
3962
|
+
};
|
|
2768
3963
|
content: {
|
|
2769
3964
|
'application/json': components['schemas']['GetUpdatesBeforeResponse'];
|
|
2770
3965
|
};
|
|
@@ -2772,47 +3967,64 @@ export interface operations {
|
|
|
2772
3967
|
404: components['responses']['404'];
|
|
2773
3968
|
};
|
|
2774
3969
|
};
|
|
2775
|
-
/** @description Retrieve the status of the backfilling process. */
|
|
2776
3970
|
getBackfillingStatus: {
|
|
3971
|
+
parameters: {
|
|
3972
|
+
query?: never;
|
|
3973
|
+
header?: never;
|
|
3974
|
+
path?: never;
|
|
3975
|
+
cookie?: never;
|
|
3976
|
+
};
|
|
3977
|
+
requestBody?: never;
|
|
2777
3978
|
responses: {
|
|
2778
3979
|
/** @description ok */
|
|
2779
3980
|
200: {
|
|
3981
|
+
headers: {
|
|
3982
|
+
[name: string]: unknown;
|
|
3983
|
+
};
|
|
2780
3984
|
content: {
|
|
2781
3985
|
'application/json': components['schemas']['GetBackfillingStatusResponse'];
|
|
2782
3986
|
};
|
|
2783
3987
|
};
|
|
2784
3988
|
};
|
|
2785
3989
|
};
|
|
2786
|
-
/**
|
|
2787
|
-
* @deprecated
|
|
2788
|
-
* @description **Deprecated**. Fetch the current SV participant ACS snapshot for the DSO and `party`.
|
|
2789
|
-
*/
|
|
2790
3990
|
getAcsSnapshot: {
|
|
2791
3991
|
parameters: {
|
|
2792
3992
|
query?: {
|
|
2793
3993
|
record_time?: string;
|
|
2794
3994
|
};
|
|
3995
|
+
header?: never;
|
|
2795
3996
|
path: {
|
|
2796
3997
|
party: string;
|
|
2797
3998
|
};
|
|
3999
|
+
cookie?: never;
|
|
2798
4000
|
};
|
|
4001
|
+
requestBody?: never;
|
|
2799
4002
|
responses: {
|
|
2800
4003
|
/** @description ok */
|
|
2801
4004
|
200: {
|
|
4005
|
+
headers: {
|
|
4006
|
+
[name: string]: unknown;
|
|
4007
|
+
};
|
|
2802
4008
|
content: {
|
|
2803
4009
|
'application/json': components['schemas']['GetAcsSnapshotResponse'];
|
|
2804
4010
|
};
|
|
2805
4011
|
};
|
|
2806
4012
|
};
|
|
2807
4013
|
};
|
|
2808
|
-
/**
|
|
2809
|
-
* @deprecated
|
|
2810
|
-
* @description **Deprecated**. Retrieve the current earliest and latest rounds aggregated for this Scan.
|
|
2811
|
-
*/
|
|
2812
4014
|
getAggregatedRounds: {
|
|
4015
|
+
parameters: {
|
|
4016
|
+
query?: never;
|
|
4017
|
+
header?: never;
|
|
4018
|
+
path?: never;
|
|
4019
|
+
cookie?: never;
|
|
4020
|
+
};
|
|
4021
|
+
requestBody?: never;
|
|
2813
4022
|
responses: {
|
|
2814
4023
|
/** @description ok */
|
|
2815
4024
|
200: {
|
|
4025
|
+
headers: {
|
|
4026
|
+
[name: string]: unknown;
|
|
4027
|
+
};
|
|
2816
4028
|
content: {
|
|
2817
4029
|
'application/json': components['schemas']['GetAggregatedRoundsResponse'];
|
|
2818
4030
|
};
|
|
@@ -2820,11 +4032,13 @@ export interface operations {
|
|
|
2820
4032
|
404: components['responses']['404'];
|
|
2821
4033
|
};
|
|
2822
4034
|
};
|
|
2823
|
-
/**
|
|
2824
|
-
* @deprecated
|
|
2825
|
-
* @description **Deprecated**. List Amulet statistics for up to 200 closed rounds.
|
|
2826
|
-
*/
|
|
2827
4035
|
listRoundTotals: {
|
|
4036
|
+
parameters: {
|
|
4037
|
+
query?: never;
|
|
4038
|
+
header?: never;
|
|
4039
|
+
path?: never;
|
|
4040
|
+
cookie?: never;
|
|
4041
|
+
};
|
|
2828
4042
|
requestBody: {
|
|
2829
4043
|
content: {
|
|
2830
4044
|
'application/json': components['schemas']['ListRoundTotalsRequest'];
|
|
@@ -2833,6 +4047,9 @@ export interface operations {
|
|
|
2833
4047
|
responses: {
|
|
2834
4048
|
/** @description ok */
|
|
2835
4049
|
200: {
|
|
4050
|
+
headers: {
|
|
4051
|
+
[name: string]: unknown;
|
|
4052
|
+
};
|
|
2836
4053
|
content: {
|
|
2837
4054
|
'application/json': components['schemas']['ListRoundTotalsResponse'];
|
|
2838
4055
|
};
|
|
@@ -2842,11 +4059,13 @@ export interface operations {
|
|
|
2842
4059
|
500: components['responses']['500'];
|
|
2843
4060
|
};
|
|
2844
4061
|
};
|
|
2845
|
-
/**
|
|
2846
|
-
* @deprecated
|
|
2847
|
-
* @description **Deprecated**. Retrieve per-party Amulet statistics for up to 50 closed rounds.
|
|
2848
|
-
*/
|
|
2849
4062
|
listRoundPartyTotals: {
|
|
4063
|
+
parameters: {
|
|
4064
|
+
query?: never;
|
|
4065
|
+
header?: never;
|
|
4066
|
+
path?: never;
|
|
4067
|
+
cookie?: never;
|
|
4068
|
+
};
|
|
2850
4069
|
requestBody: {
|
|
2851
4070
|
content: {
|
|
2852
4071
|
'application/json': components['schemas']['ListRoundPartyTotalsRequest'];
|
|
@@ -2855,6 +4074,9 @@ export interface operations {
|
|
|
2855
4074
|
responses: {
|
|
2856
4075
|
/** @description ok */
|
|
2857
4076
|
200: {
|
|
4077
|
+
headers: {
|
|
4078
|
+
[name: string]: unknown;
|
|
4079
|
+
};
|
|
2858
4080
|
content: {
|
|
2859
4081
|
'application/json': components['schemas']['ListRoundPartyTotalsResponse'];
|
|
2860
4082
|
};
|
|
@@ -2864,19 +4086,22 @@ export interface operations {
|
|
|
2864
4086
|
500: components['responses']['500'];
|
|
2865
4087
|
};
|
|
2866
4088
|
};
|
|
2867
|
-
/**
|
|
2868
|
-
* @deprecated
|
|
2869
|
-
* @description **Deprecated**. Get the total balance of Amulet in the network
|
|
2870
|
-
*/
|
|
2871
4089
|
getTotalAmuletBalance: {
|
|
2872
4090
|
parameters: {
|
|
2873
4091
|
query: {
|
|
2874
4092
|
asOfEndOfRound: number;
|
|
2875
4093
|
};
|
|
4094
|
+
header?: never;
|
|
4095
|
+
path?: never;
|
|
4096
|
+
cookie?: never;
|
|
2876
4097
|
};
|
|
4098
|
+
requestBody?: never;
|
|
2877
4099
|
responses: {
|
|
2878
4100
|
/** @description ok */
|
|
2879
4101
|
200: {
|
|
4102
|
+
headers: {
|
|
4103
|
+
[name: string]: unknown;
|
|
4104
|
+
};
|
|
2880
4105
|
content: {
|
|
2881
4106
|
'application/json': components['schemas']['GetTotalAmuletBalanceResponse'];
|
|
2882
4107
|
};
|
|
@@ -2884,20 +4109,23 @@ export interface operations {
|
|
|
2884
4109
|
404: components['responses']['404'];
|
|
2885
4110
|
};
|
|
2886
4111
|
};
|
|
2887
|
-
/**
|
|
2888
|
-
* @deprecated
|
|
2889
|
-
* @description **Deprecated**, use /v0/holdings/summary with /v0/state/acs/snapshot-timestamp instead. Get the Amulet balance for a specific party at the end of a closed round
|
|
2890
|
-
*/
|
|
2891
4112
|
getWalletBalance: {
|
|
2892
4113
|
parameters: {
|
|
2893
4114
|
query: {
|
|
2894
4115
|
party_id: string;
|
|
2895
4116
|
asOfEndOfRound: number;
|
|
2896
4117
|
};
|
|
4118
|
+
header?: never;
|
|
4119
|
+
path?: never;
|
|
4120
|
+
cookie?: never;
|
|
2897
4121
|
};
|
|
4122
|
+
requestBody?: never;
|
|
2898
4123
|
responses: {
|
|
2899
4124
|
/** @description ok */
|
|
2900
4125
|
200: {
|
|
4126
|
+
headers: {
|
|
4127
|
+
[name: string]: unknown;
|
|
4128
|
+
};
|
|
2901
4129
|
content: {
|
|
2902
4130
|
'application/json': components['schemas']['GetWalletBalanceResponse'];
|
|
2903
4131
|
};
|
|
@@ -2905,19 +4133,22 @@ export interface operations {
|
|
|
2905
4133
|
404: components['responses']['404'];
|
|
2906
4134
|
};
|
|
2907
4135
|
};
|
|
2908
|
-
/**
|
|
2909
|
-
* @deprecated
|
|
2910
|
-
* @description **Deprecated**. Retrieve some information from the `AmuletRules` selected for the given round
|
|
2911
|
-
*/
|
|
2912
4136
|
getAmuletConfigForRound: {
|
|
2913
4137
|
parameters: {
|
|
2914
4138
|
query: {
|
|
2915
4139
|
round: number;
|
|
2916
4140
|
};
|
|
4141
|
+
header?: never;
|
|
4142
|
+
path?: never;
|
|
4143
|
+
cookie?: never;
|
|
2917
4144
|
};
|
|
4145
|
+
requestBody?: never;
|
|
2918
4146
|
responses: {
|
|
2919
4147
|
/** @description ok */
|
|
2920
4148
|
200: {
|
|
4149
|
+
headers: {
|
|
4150
|
+
[name: string]: unknown;
|
|
4151
|
+
};
|
|
2921
4152
|
content: {
|
|
2922
4153
|
'application/json': components['schemas']['GetAmuletConfigForRoundResponse'];
|
|
2923
4154
|
};
|
|
@@ -2925,15 +4156,20 @@ export interface operations {
|
|
|
2925
4156
|
404: components['responses']['404'];
|
|
2926
4157
|
};
|
|
2927
4158
|
};
|
|
2928
|
-
/**
|
|
2929
|
-
* @deprecated
|
|
2930
|
-
* @description **Deprecated**. Get the latest round number for which aggregated data is available and
|
|
2931
|
-
* the ledger effective time at which the round was closed.
|
|
2932
|
-
*/
|
|
2933
4159
|
getRoundOfLatestData: {
|
|
4160
|
+
parameters: {
|
|
4161
|
+
query?: never;
|
|
4162
|
+
header?: never;
|
|
4163
|
+
path?: never;
|
|
4164
|
+
cookie?: never;
|
|
4165
|
+
};
|
|
4166
|
+
requestBody?: never;
|
|
2934
4167
|
responses: {
|
|
2935
4168
|
/** @description ok */
|
|
2936
4169
|
200: {
|
|
4170
|
+
headers: {
|
|
4171
|
+
[name: string]: unknown;
|
|
4172
|
+
};
|
|
2937
4173
|
content: {
|
|
2938
4174
|
'application/json': components['schemas']['GetRoundOfLatestDataResponse'];
|
|
2939
4175
|
};
|
|
@@ -2941,19 +4177,22 @@ export interface operations {
|
|
|
2941
4177
|
404: components['responses']['404'];
|
|
2942
4178
|
};
|
|
2943
4179
|
};
|
|
2944
|
-
/**
|
|
2945
|
-
* @deprecated
|
|
2946
|
-
* @description **Deprecated**. Get the total rewards collected ever
|
|
2947
|
-
*/
|
|
2948
4180
|
getRewardsCollected: {
|
|
2949
4181
|
parameters: {
|
|
2950
4182
|
query?: {
|
|
2951
4183
|
round?: number;
|
|
2952
4184
|
};
|
|
4185
|
+
header?: never;
|
|
4186
|
+
path?: never;
|
|
4187
|
+
cookie?: never;
|
|
2953
4188
|
};
|
|
4189
|
+
requestBody?: never;
|
|
2954
4190
|
responses: {
|
|
2955
4191
|
/** @description ok */
|
|
2956
4192
|
200: {
|
|
4193
|
+
headers: {
|
|
4194
|
+
[name: string]: unknown;
|
|
4195
|
+
};
|
|
2957
4196
|
content: {
|
|
2958
4197
|
'application/json': components['schemas']['GetRewardsCollectedResponse'];
|
|
2959
4198
|
};
|
|
@@ -2961,21 +4200,23 @@ export interface operations {
|
|
|
2961
4200
|
404: components['responses']['404'];
|
|
2962
4201
|
};
|
|
2963
4202
|
};
|
|
2964
|
-
/**
|
|
2965
|
-
* @deprecated
|
|
2966
|
-
* @description **Deprecated**. Get a list of top-earning app providers, and the total earned app
|
|
2967
|
-
* rewards for each
|
|
2968
|
-
*/
|
|
2969
4203
|
getTopProvidersByAppRewards: {
|
|
2970
4204
|
parameters: {
|
|
2971
4205
|
query: {
|
|
2972
4206
|
round: number;
|
|
2973
4207
|
limit: number;
|
|
2974
4208
|
};
|
|
4209
|
+
header?: never;
|
|
4210
|
+
path?: never;
|
|
4211
|
+
cookie?: never;
|
|
2975
4212
|
};
|
|
4213
|
+
requestBody?: never;
|
|
2976
4214
|
responses: {
|
|
2977
4215
|
/** @description ok */
|
|
2978
4216
|
200: {
|
|
4217
|
+
headers: {
|
|
4218
|
+
[name: string]: unknown;
|
|
4219
|
+
};
|
|
2979
4220
|
content: {
|
|
2980
4221
|
'application/json': components['schemas']['GetTopProvidersByAppRewardsResponse'];
|
|
2981
4222
|
};
|
|
@@ -2984,21 +4225,23 @@ export interface operations {
|
|
|
2984
4225
|
404: components['responses']['404'];
|
|
2985
4226
|
};
|
|
2986
4227
|
};
|
|
2987
|
-
/**
|
|
2988
|
-
* @deprecated
|
|
2989
|
-
* @description **Deprecated**. Get a list of top-earning validators, and the total earned validator
|
|
2990
|
-
* rewards for each
|
|
2991
|
-
*/
|
|
2992
4228
|
getTopValidatorsByValidatorRewards: {
|
|
2993
4229
|
parameters: {
|
|
2994
4230
|
query: {
|
|
2995
4231
|
round: number;
|
|
2996
4232
|
limit: number;
|
|
2997
4233
|
};
|
|
4234
|
+
header?: never;
|
|
4235
|
+
path?: never;
|
|
4236
|
+
cookie?: never;
|
|
2998
4237
|
};
|
|
4238
|
+
requestBody?: never;
|
|
2999
4239
|
responses: {
|
|
3000
4240
|
/** @description ok */
|
|
3001
4241
|
200: {
|
|
4242
|
+
headers: {
|
|
4243
|
+
[name: string]: unknown;
|
|
4244
|
+
};
|
|
3002
4245
|
content: {
|
|
3003
4246
|
'application/json': components['schemas']['GetTopValidatorsByValidatorRewardsResponse'];
|
|
3004
4247
|
};
|
|
@@ -3007,21 +4250,23 @@ export interface operations {
|
|
|
3007
4250
|
404: components['responses']['404'];
|
|
3008
4251
|
};
|
|
3009
4252
|
};
|
|
3010
|
-
/**
|
|
3011
|
-
* @deprecated
|
|
3012
|
-
* @description **Deprecated**. Get a list of validators and their domain fees spends, sorted by the
|
|
3013
|
-
* amount of extra traffic purchased
|
|
3014
|
-
*/
|
|
3015
4253
|
getTopValidatorsByPurchasedTraffic: {
|
|
3016
4254
|
parameters: {
|
|
3017
4255
|
query: {
|
|
3018
4256
|
round: number;
|
|
3019
4257
|
limit: number;
|
|
3020
4258
|
};
|
|
4259
|
+
header?: never;
|
|
4260
|
+
path?: never;
|
|
4261
|
+
cookie?: never;
|
|
3021
4262
|
};
|
|
4263
|
+
requestBody?: never;
|
|
3022
4264
|
responses: {
|
|
3023
4265
|
/** @description ok */
|
|
3024
4266
|
200: {
|
|
4267
|
+
headers: {
|
|
4268
|
+
[name: string]: unknown;
|
|
4269
|
+
};
|
|
3025
4270
|
content: {
|
|
3026
4271
|
'application/json': components['schemas']['GetTopValidatorsByPurchasedTrafficResponse'];
|
|
3027
4272
|
};
|
|
@@ -3030,11 +4275,13 @@ export interface operations {
|
|
|
3030
4275
|
404: components['responses']['404'];
|
|
3031
4276
|
};
|
|
3032
4277
|
};
|
|
3033
|
-
/**
|
|
3034
|
-
* @deprecated
|
|
3035
|
-
* @description **Deprecated**. Lists activities in descending order, paged, optionally starting after a provided event id.
|
|
3036
|
-
*/
|
|
3037
4278
|
listActivity: {
|
|
4279
|
+
parameters: {
|
|
4280
|
+
query?: never;
|
|
4281
|
+
header?: never;
|
|
4282
|
+
path?: never;
|
|
4283
|
+
cookie?: never;
|
|
4284
|
+
};
|
|
3038
4285
|
requestBody: {
|
|
3039
4286
|
content: {
|
|
3040
4287
|
'application/json': components['schemas']['ListActivityRequest'];
|
|
@@ -3043,6 +4290,9 @@ export interface operations {
|
|
|
3043
4290
|
responses: {
|
|
3044
4291
|
/** @description ok */
|
|
3045
4292
|
200: {
|
|
4293
|
+
headers: {
|
|
4294
|
+
[name: string]: unknown;
|
|
4295
|
+
};
|
|
3046
4296
|
content: {
|
|
3047
4297
|
'application/json': components['schemas']['ListActivityResponse'];
|
|
3048
4298
|
};
|
|
@@ -3051,13 +4301,13 @@ export interface operations {
|
|
|
3051
4301
|
500: components['responses']['500'];
|
|
3052
4302
|
};
|
|
3053
4303
|
};
|
|
3054
|
-
/**
|
|
3055
|
-
* @deprecated
|
|
3056
|
-
* @description **Deprecated with known bugs that will not be fixed, use /v2/updates instead**.
|
|
3057
|
-
*
|
|
3058
|
-
* Lists transactions, by default in ascending order, paged, from ledger begin or optionally starting after a provided event id.
|
|
3059
|
-
*/
|
|
3060
4304
|
listTransactionHistory: {
|
|
4305
|
+
parameters: {
|
|
4306
|
+
query?: never;
|
|
4307
|
+
header?: never;
|
|
4308
|
+
path?: never;
|
|
4309
|
+
cookie?: never;
|
|
4310
|
+
};
|
|
3061
4311
|
requestBody: {
|
|
3062
4312
|
content: {
|
|
3063
4313
|
'application/json': components['schemas']['TransactionHistoryRequest'];
|
|
@@ -3066,6 +4316,9 @@ export interface operations {
|
|
|
3066
4316
|
responses: {
|
|
3067
4317
|
/** @description ok */
|
|
3068
4318
|
200: {
|
|
4319
|
+
headers: {
|
|
4320
|
+
[name: string]: unknown;
|
|
4321
|
+
};
|
|
3069
4322
|
content: {
|
|
3070
4323
|
'application/json': components['schemas']['TransactionHistoryResponse'];
|
|
3071
4324
|
};
|
|
@@ -3075,12 +4328,13 @@ export interface operations {
|
|
|
3075
4328
|
500: components['responses']['500'];
|
|
3076
4329
|
};
|
|
3077
4330
|
};
|
|
3078
|
-
/**
|
|
3079
|
-
* @deprecated
|
|
3080
|
-
* @description **Deprecated**, use /v2/updates instead.
|
|
3081
|
-
* Returns the update history in ascending order, paged, from ledger begin or optionally starting after a record time.
|
|
3082
|
-
*/
|
|
3083
4331
|
getUpdateHistory: {
|
|
4332
|
+
parameters: {
|
|
4333
|
+
query?: never;
|
|
4334
|
+
header?: never;
|
|
4335
|
+
path?: never;
|
|
4336
|
+
cookie?: never;
|
|
4337
|
+
};
|
|
3084
4338
|
requestBody: {
|
|
3085
4339
|
content: {
|
|
3086
4340
|
'application/json': components['schemas']['UpdateHistoryRequest'];
|
|
@@ -3089,6 +4343,9 @@ export interface operations {
|
|
|
3089
4343
|
responses: {
|
|
3090
4344
|
/** @description ok */
|
|
3091
4345
|
200: {
|
|
4346
|
+
headers: {
|
|
4347
|
+
[name: string]: unknown;
|
|
4348
|
+
};
|
|
3092
4349
|
content: {
|
|
3093
4350
|
'application/json': components['schemas']['UpdateHistoryResponse'];
|
|
3094
4351
|
};
|
|
@@ -3097,27 +4354,29 @@ export interface operations {
|
|
|
3097
4354
|
500: components['responses']['500'];
|
|
3098
4355
|
};
|
|
3099
4356
|
};
|
|
3100
|
-
/**
|
|
3101
|
-
* @deprecated
|
|
3102
|
-
* @description **Deprecated**, use /v2/updates/{update_id} instead.
|
|
3103
|
-
*/
|
|
3104
4357
|
getUpdateById: {
|
|
3105
4358
|
parameters: {
|
|
3106
4359
|
query?: {
|
|
3107
4360
|
/**
|
|
3108
4361
|
* @description Whether contract payload should be encoded into json using a lossless, but much harder to process, encoding.
|
|
3109
|
-
*
|
|
3110
|
-
*
|
|
4362
|
+
* This is mostly used for backend calls, and is not recommended for external users.
|
|
4363
|
+
* Optional and defaults to false.
|
|
3111
4364
|
*/
|
|
3112
4365
|
lossless?: boolean;
|
|
3113
4366
|
};
|
|
4367
|
+
header?: never;
|
|
3114
4368
|
path: {
|
|
3115
4369
|
update_id: string;
|
|
3116
4370
|
};
|
|
4371
|
+
cookie?: never;
|
|
3117
4372
|
};
|
|
4373
|
+
requestBody?: never;
|
|
3118
4374
|
responses: {
|
|
3119
4375
|
/** @description ok */
|
|
3120
4376
|
200: {
|
|
4377
|
+
headers: {
|
|
4378
|
+
[name: string]: unknown;
|
|
4379
|
+
};
|
|
3121
4380
|
content: {
|
|
3122
4381
|
'application/json': components['schemas']['UpdateHistoryItem'];
|
|
3123
4382
|
};
|
|
@@ -3128,9 +4387,19 @@ export interface operations {
|
|
|
3128
4387
|
};
|
|
3129
4388
|
};
|
|
3130
4389
|
featureSupport: {
|
|
4390
|
+
parameters: {
|
|
4391
|
+
query?: never;
|
|
4392
|
+
header?: never;
|
|
4393
|
+
path?: never;
|
|
4394
|
+
cookie?: never;
|
|
4395
|
+
};
|
|
4396
|
+
requestBody?: never;
|
|
3131
4397
|
responses: {
|
|
3132
4398
|
/** @description ok */
|
|
3133
4399
|
200: {
|
|
4400
|
+
headers: {
|
|
4401
|
+
[name: string]: unknown;
|
|
4402
|
+
};
|
|
3134
4403
|
content: {
|
|
3135
4404
|
'application/json': components['schemas']['FeatureSupportResponse'];
|
|
3136
4405
|
};
|
|
@@ -3139,6 +4408,12 @@ export interface operations {
|
|
|
3139
4408
|
};
|
|
3140
4409
|
};
|
|
3141
4410
|
getImportUpdates: {
|
|
4411
|
+
parameters: {
|
|
4412
|
+
query?: never;
|
|
4413
|
+
header?: never;
|
|
4414
|
+
path?: never;
|
|
4415
|
+
cookie?: never;
|
|
4416
|
+
};
|
|
3142
4417
|
requestBody: {
|
|
3143
4418
|
content: {
|
|
3144
4419
|
'application/json': components['schemas']['GetImportUpdatesRequest'];
|
|
@@ -3147,6 +4422,9 @@ export interface operations {
|
|
|
3147
4422
|
responses: {
|
|
3148
4423
|
/** @description ok */
|
|
3149
4424
|
200: {
|
|
4425
|
+
headers: {
|
|
4426
|
+
[name: string]: unknown;
|
|
4427
|
+
};
|
|
3150
4428
|
content: {
|
|
3151
4429
|
'application/json': components['schemas']['GetImportUpdatesResponse'];
|
|
3152
4430
|
};
|
|
@@ -3154,16 +4432,13 @@ export interface operations {
|
|
|
3154
4432
|
404: components['responses']['404'];
|
|
3155
4433
|
};
|
|
3156
4434
|
};
|
|
3157
|
-
/**
|
|
3158
|
-
* @description Returns the event history in ascending order, paged, from ledger begin or optionally starting after a record time.
|
|
3159
|
-
* An event bears some combination of a transaction, a contract reassignment, and a verdict.
|
|
3160
|
-
* Events are ordered lexicographically by `(migration id, record time)`.
|
|
3161
|
-
* For a given migration id, each event has a unique record time.
|
|
3162
|
-
* The record time ranges of different migrations may overlap, i.e.,
|
|
3163
|
-
* it is not guaranteed that the maximum record time of one migration is smaller than the minimum record time of the next migration,
|
|
3164
|
-
* and there may be two updates with the same record time but different migration ids.
|
|
3165
|
-
*/
|
|
3166
4435
|
getEventHistory: {
|
|
4436
|
+
parameters: {
|
|
4437
|
+
query?: never;
|
|
4438
|
+
header?: never;
|
|
4439
|
+
path?: never;
|
|
4440
|
+
cookie?: never;
|
|
4441
|
+
};
|
|
3167
4442
|
requestBody: {
|
|
3168
4443
|
content: {
|
|
3169
4444
|
'application/json': components['schemas']['EventHistoryRequest'];
|
|
@@ -3172,6 +4447,9 @@ export interface operations {
|
|
|
3172
4447
|
responses: {
|
|
3173
4448
|
/** @description ok */
|
|
3174
4449
|
200: {
|
|
4450
|
+
headers: {
|
|
4451
|
+
[name: string]: unknown;
|
|
4452
|
+
};
|
|
3175
4453
|
content: {
|
|
3176
4454
|
'application/json': components['schemas']['EventHistoryResponse'];
|
|
3177
4455
|
};
|
|
@@ -3180,22 +4458,24 @@ export interface operations {
|
|
|
3180
4458
|
500: components['responses']['500'];
|
|
3181
4459
|
};
|
|
3182
4460
|
};
|
|
3183
|
-
/**
|
|
3184
|
-
* @description Returns the event with the given update_id.
|
|
3185
|
-
* An event bears some combination of a transaction, a contract reassignment, and a verdict.
|
|
3186
|
-
*/
|
|
3187
4461
|
getEventById: {
|
|
3188
4462
|
parameters: {
|
|
3189
4463
|
query?: {
|
|
3190
4464
|
daml_value_encoding?: components['schemas']['DamlValueEncoding'];
|
|
3191
4465
|
};
|
|
4466
|
+
header?: never;
|
|
3192
4467
|
path: {
|
|
3193
4468
|
update_id: string;
|
|
3194
4469
|
};
|
|
4470
|
+
cookie?: never;
|
|
3195
4471
|
};
|
|
4472
|
+
requestBody?: never;
|
|
3196
4473
|
responses: {
|
|
3197
4474
|
/** @description ok */
|
|
3198
4475
|
200: {
|
|
4476
|
+
headers: {
|
|
4477
|
+
[name: string]: unknown;
|
|
4478
|
+
};
|
|
3199
4479
|
content: {
|
|
3200
4480
|
'application/json': components['schemas']['EventHistoryItem'];
|
|
3201
4481
|
};
|