@anastasia-labs/cardano-multiplatform-lib-nodejs 5.3.1-7 → 6.0.0-10
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/LICENSE +1 -1
- package/README.md +2 -2
- package/cardano_multiplatform_lib.d.ts +1663 -245
- package/cardano_multiplatform_lib.js +4427 -273
- package/cardano_multiplatform_lib_bg.wasm +0 -0
- package/package.json +3 -3
|
@@ -17,6 +17,18 @@ export function emip3_encrypt_with_password(password: string, salt: string, nonc
|
|
|
17
17
|
*/
|
|
18
18
|
export function emip3_decrypt_with_password(password: string, data: string): string;
|
|
19
19
|
/**
|
|
20
|
+
* encodes arbitrary bytes into chunks of 64 bytes (the limit for bytes) as a list to be valid Metadata
|
|
21
|
+
* @param {Uint8Array} bytes
|
|
22
|
+
* @returns {TransactionMetadatum}
|
|
23
|
+
*/
|
|
24
|
+
export function encode_arbitrary_bytes_as_metadatum(bytes: Uint8Array): TransactionMetadatum;
|
|
25
|
+
/**
|
|
26
|
+
* decodes from chunks of bytes in a list to a byte vector if that is the metadata format, otherwise returns None
|
|
27
|
+
* @param {TransactionMetadatum} metadata
|
|
28
|
+
* @returns {Uint8Array | undefined}
|
|
29
|
+
*/
|
|
30
|
+
export function decode_arbitrary_bytes_from_metadatum(metadata: TransactionMetadatum): Uint8Array | undefined;
|
|
31
|
+
/**
|
|
20
32
|
* @param {AuxiliaryData} auxiliary_data
|
|
21
33
|
* @returns {AuxiliaryDataHash}
|
|
22
34
|
*/
|
|
@@ -93,7 +105,7 @@ export function get_implicit_input(txbody: TransactionBody, pool_deposit: bigint
|
|
|
93
105
|
export function get_deposit(txbody: TransactionBody, pool_deposit: bigint, key_deposit: bigint): bigint;
|
|
94
106
|
/**
|
|
95
107
|
*
|
|
96
|
-
* * Min fee for JUST the script
|
|
108
|
+
* * Min fee for JUST the script, NOT including ref inputs
|
|
97
109
|
*
|
|
98
110
|
* @param {Transaction} tx
|
|
99
111
|
* @param {ExUnitPrices} ex_unit_prices
|
|
@@ -107,12 +119,17 @@ export function min_script_fee(tx: Transaction, ex_unit_prices: ExUnitPrices): b
|
|
|
107
119
|
*/
|
|
108
120
|
export function min_no_script_fee(tx: Transaction, linear_fee: LinearFee): bigint;
|
|
109
121
|
/**
|
|
122
|
+
*
|
|
123
|
+
* * Calculates the cost of all ref scripts
|
|
124
|
+
* * * `total_ref_script_size` - Total size (original, not hashes) of all ref scripts. Duplicate scripts are counted as many times as they occur
|
|
125
|
+
*
|
|
110
126
|
* @param {Transaction} tx
|
|
111
127
|
* @param {LinearFee} linear_fee
|
|
112
128
|
* @param {ExUnitPrices} ex_unit_prices
|
|
129
|
+
* @param {bigint} total_ref_script_size
|
|
113
130
|
* @returns {bigint}
|
|
114
131
|
*/
|
|
115
|
-
export function min_fee(tx: Transaction, linear_fee: LinearFee, ex_unit_prices: ExUnitPrices): bigint;
|
|
132
|
+
export function min_fee(tx: Transaction, linear_fee: LinearFee, ex_unit_prices: ExUnitPrices, total_ref_script_size: bigint): bigint;
|
|
116
133
|
/**
|
|
117
134
|
* Converts JSON to Metadata according to MetadataJsonSchema
|
|
118
135
|
* @param {string} json
|
|
@@ -159,18 +176,6 @@ export function make_vkey_witness(tx_body_hash: TransactionHash, sk: PrivateKey)
|
|
|
159
176
|
*/
|
|
160
177
|
export function min_ada_required(output: TransactionOutput, coins_per_utxo_byte: bigint): bigint;
|
|
161
178
|
/**
|
|
162
|
-
* encodes arbitrary bytes into chunks of 64 bytes (the limit for bytes) as a list to be valid Metadata
|
|
163
|
-
* @param {Uint8Array} bytes
|
|
164
|
-
* @returns {TransactionMetadatum}
|
|
165
|
-
*/
|
|
166
|
-
export function encode_arbitrary_bytes_as_metadatum(bytes: Uint8Array): TransactionMetadatum;
|
|
167
|
-
/**
|
|
168
|
-
* decodes from chunks of bytes in a list to a byte vector if that is the metadata format, otherwise returns None
|
|
169
|
-
* @param {TransactionMetadatum} metadata
|
|
170
|
-
* @returns {Uint8Array | undefined}
|
|
171
|
-
*/
|
|
172
|
-
export function decode_arbitrary_bytes_from_metadatum(metadata: TransactionMetadatum): Uint8Array | undefined;
|
|
173
|
-
/**
|
|
174
179
|
* @param {string} json
|
|
175
180
|
* @param {CardanoNodePlutusDatumSchema} schema
|
|
176
181
|
* @returns {PlutusData}
|
|
@@ -184,69 +189,79 @@ export function encode_json_str_to_plutus_datum(json: string, schema: CardanoNod
|
|
|
184
189
|
export function decode_plutus_datum_to_json_str(datum: PlutusData, schema: CardanoNodePlutusDatumSchema): string;
|
|
185
190
|
/**
|
|
186
191
|
*/
|
|
187
|
-
export enum
|
|
188
|
-
|
|
189
|
-
|
|
190
|
-
DetailedSchema = 2,
|
|
192
|
+
export enum CredentialKind {
|
|
193
|
+
PubKey = 0,
|
|
194
|
+
Script = 1,
|
|
191
195
|
}
|
|
192
196
|
/**
|
|
193
197
|
*/
|
|
194
|
-
export enum
|
|
195
|
-
|
|
196
|
-
|
|
198
|
+
export enum TransactionOutputKind {
|
|
199
|
+
AlonzoFormatTxOut = 0,
|
|
200
|
+
ConwayFormatTxOut = 1,
|
|
197
201
|
}
|
|
198
202
|
/**
|
|
199
203
|
*/
|
|
200
|
-
export enum
|
|
201
|
-
Single = 0,
|
|
202
|
-
Chunked = 1,
|
|
203
|
-
}
|
|
204
|
+
export enum CoinSelectionStrategyCIP2 {
|
|
204
205
|
/**
|
|
206
|
+
* Performs CIP2's Largest First ada-only selection. Will error if outputs contain non-ADA assets.
|
|
205
207
|
*/
|
|
206
|
-
|
|
207
|
-
Shelley = 0,
|
|
208
|
-
ShelleyMA = 1,
|
|
209
|
-
Conway = 2,
|
|
210
|
-
}
|
|
208
|
+
LargestFirst = 0,
|
|
211
209
|
/**
|
|
210
|
+
* Performs CIP2's Random Improve ada-only selection. Will error if outputs contain non-ADA assets.
|
|
212
211
|
*/
|
|
213
|
-
|
|
214
|
-
|
|
215
|
-
|
|
216
|
-
|
|
212
|
+
RandomImprove = 1,
|
|
213
|
+
/**
|
|
214
|
+
* Same as LargestFirst, but before adding ADA, will insert by largest-first for each asset type.
|
|
215
|
+
*/
|
|
216
|
+
LargestFirstMultiAsset = 2,
|
|
217
|
+
/**
|
|
218
|
+
* Same as RandomImprove, but before adding ADA, will insert by random-improve for each asset type.
|
|
219
|
+
*/
|
|
220
|
+
RandomImproveMultiAsset = 3,
|
|
217
221
|
}
|
|
218
222
|
/**
|
|
219
223
|
*/
|
|
220
|
-
export enum
|
|
221
|
-
|
|
222
|
-
|
|
223
|
-
|
|
224
|
+
export enum GovActionKind {
|
|
225
|
+
ParameterChangeAction = 0,
|
|
226
|
+
HardForkInitiationAction = 1,
|
|
227
|
+
TreasuryWithdrawalsAction = 2,
|
|
228
|
+
NoConfidence = 3,
|
|
229
|
+
UpdateCommittee = 4,
|
|
230
|
+
NewConstitution = 5,
|
|
231
|
+
InfoAction = 6,
|
|
224
232
|
}
|
|
225
233
|
/**
|
|
226
234
|
*/
|
|
227
|
-
export enum
|
|
228
|
-
|
|
229
|
-
|
|
235
|
+
export enum RedeemerTag {
|
|
236
|
+
Spend = 0,
|
|
237
|
+
Mint = 1,
|
|
238
|
+
Cert = 2,
|
|
239
|
+
Reward = 3,
|
|
240
|
+
Voting = 4,
|
|
241
|
+
Proposing = 5,
|
|
230
242
|
}
|
|
231
243
|
/**
|
|
232
244
|
*/
|
|
233
|
-
export enum
|
|
234
|
-
|
|
235
|
-
|
|
245
|
+
export enum ByronAddrType {
|
|
246
|
+
PublicKey = 0,
|
|
247
|
+
Script = 1,
|
|
248
|
+
Redeem = 2,
|
|
236
249
|
}
|
|
237
250
|
/**
|
|
238
251
|
*/
|
|
239
|
-
export enum
|
|
240
|
-
|
|
241
|
-
|
|
242
|
-
|
|
243
|
-
|
|
252
|
+
export enum VoterKind {
|
|
253
|
+
ConstitutionalCommitteeHotKeyHash = 0,
|
|
254
|
+
ConstitutionalCommitteeHotScriptHash = 1,
|
|
255
|
+
DRepKeyHash = 2,
|
|
256
|
+
DRepScriptHash = 3,
|
|
257
|
+
StakingPoolKeyHash = 4,
|
|
244
258
|
}
|
|
245
259
|
/**
|
|
246
260
|
*/
|
|
247
|
-
export enum
|
|
248
|
-
|
|
249
|
-
|
|
261
|
+
export enum Vote {
|
|
262
|
+
No = 0,
|
|
263
|
+
Yes = 1,
|
|
264
|
+
Abstain = 2,
|
|
250
265
|
}
|
|
251
266
|
/**
|
|
252
267
|
* Careful: this enum doesn't include the network ID part of the header
|
|
@@ -268,42 +283,15 @@ export enum AddressHeaderKind {
|
|
|
268
283
|
}
|
|
269
284
|
/**
|
|
270
285
|
*/
|
|
271
|
-
export enum
|
|
272
|
-
|
|
273
|
-
|
|
274
|
-
}
|
|
275
|
-
/**
|
|
276
|
-
*/
|
|
277
|
-
export enum Language {
|
|
278
|
-
PlutusV1 = 0,
|
|
279
|
-
PlutusV2 = 1,
|
|
280
|
-
PlutusV3 = 2,
|
|
281
|
-
}
|
|
282
|
-
/**
|
|
283
|
-
*/
|
|
284
|
-
export enum PlutusDataKind {
|
|
285
|
-
ConstrPlutusData = 0,
|
|
286
|
-
Map = 1,
|
|
287
|
-
List = 2,
|
|
288
|
-
Integer = 3,
|
|
289
|
-
Bytes = 4,
|
|
290
|
-
}
|
|
291
|
-
/**
|
|
292
|
-
*/
|
|
293
|
-
export enum SpendingDataKind {
|
|
294
|
-
SpendingDataPubKey = 0,
|
|
295
|
-
SpendingDataScript = 1,
|
|
296
|
-
SpendingDataRedeem = 2,
|
|
286
|
+
export enum DatumOptionKind {
|
|
287
|
+
Hash = 0,
|
|
288
|
+
Datum = 1,
|
|
297
289
|
}
|
|
298
290
|
/**
|
|
299
291
|
*/
|
|
300
|
-
export enum
|
|
301
|
-
|
|
302
|
-
|
|
303
|
-
ScriptAny = 2,
|
|
304
|
-
ScriptNOfK = 3,
|
|
305
|
-
ScriptInvalidBefore = 4,
|
|
306
|
-
ScriptInvalidHereafter = 5,
|
|
292
|
+
export enum RedeemersKind {
|
|
293
|
+
ArrLegacyRedeemer = 0,
|
|
294
|
+
MapRedeemerKeyToRedeemerVal = 1,
|
|
307
295
|
}
|
|
308
296
|
/**
|
|
309
297
|
*/
|
|
@@ -316,99 +304,9 @@ export enum AddressKind {
|
|
|
316
304
|
}
|
|
317
305
|
/**
|
|
318
306
|
*/
|
|
319
|
-
export enum
|
|
320
|
-
|
|
321
|
-
|
|
322
|
-
StakeDelegation = 2,
|
|
323
|
-
PoolRegistration = 3,
|
|
324
|
-
PoolRetirement = 4,
|
|
325
|
-
RegCert = 5,
|
|
326
|
-
UnregCert = 6,
|
|
327
|
-
VoteDelegCert = 7,
|
|
328
|
-
StakeVoteDelegCert = 8,
|
|
329
|
-
StakeRegDelegCert = 9,
|
|
330
|
-
VoteRegDelegCert = 10,
|
|
331
|
-
StakeVoteRegDelegCert = 11,
|
|
332
|
-
AuthCommitteeHotCert = 12,
|
|
333
|
-
ResignCommitteeColdCert = 13,
|
|
334
|
-
RegDrepCert = 14,
|
|
335
|
-
UnregDrepCert = 15,
|
|
336
|
-
UpdateDrepCert = 16,
|
|
337
|
-
}
|
|
338
|
-
/**
|
|
339
|
-
*/
|
|
340
|
-
export enum GovActionKind {
|
|
341
|
-
ParameterChangeAction = 0,
|
|
342
|
-
HardForkInitiationAction = 1,
|
|
343
|
-
TreasuryWithdrawalsAction = 2,
|
|
344
|
-
NoConfidence = 3,
|
|
345
|
-
UpdateCommittee = 4,
|
|
346
|
-
NewConstitution = 5,
|
|
347
|
-
InfoAction = 6,
|
|
348
|
-
}
|
|
349
|
-
/**
|
|
350
|
-
*/
|
|
351
|
-
export enum VoterKind {
|
|
352
|
-
ConstitutionalCommitteeHotKeyHash = 0,
|
|
353
|
-
ConstitutionalCommitteeHotScriptHash = 1,
|
|
354
|
-
DRepKeyHash = 2,
|
|
355
|
-
DRepScriptHash = 3,
|
|
356
|
-
StakingPoolKeyHash = 4,
|
|
357
|
-
}
|
|
358
|
-
/**
|
|
359
|
-
*/
|
|
360
|
-
export enum TransactionMetadatumKind {
|
|
361
|
-
Map = 0,
|
|
362
|
-
List = 1,
|
|
363
|
-
Int = 2,
|
|
364
|
-
Bytes = 3,
|
|
365
|
-
Text = 4,
|
|
366
|
-
}
|
|
367
|
-
/**
|
|
368
|
-
*/
|
|
369
|
-
export enum ByronAddrType {
|
|
370
|
-
PublicKey = 0,
|
|
371
|
-
Script = 1,
|
|
372
|
-
Redeem = 2,
|
|
373
|
-
}
|
|
374
|
-
/**
|
|
375
|
-
*/
|
|
376
|
-
export enum RedeemerTag {
|
|
377
|
-
Spend = 0,
|
|
378
|
-
Mint = 1,
|
|
379
|
-
Cert = 2,
|
|
380
|
-
Reward = 3,
|
|
381
|
-
Voting = 4,
|
|
382
|
-
Proposing = 5,
|
|
383
|
-
}
|
|
384
|
-
/**
|
|
385
|
-
*/
|
|
386
|
-
export enum RedeemersKind {
|
|
387
|
-
ArrLegacyRedeemer = 0,
|
|
388
|
-
MapRedeemerKeyToRedeemerVal = 1,
|
|
389
|
-
}
|
|
390
|
-
/**
|
|
391
|
-
*/
|
|
392
|
-
export enum DRepKind {
|
|
393
|
-
Key = 0,
|
|
394
|
-
Script = 1,
|
|
395
|
-
AlwaysAbstain = 2,
|
|
396
|
-
AlwaysNoConfidence = 3,
|
|
397
|
-
}
|
|
398
|
-
/**
|
|
399
|
-
* Which version of the CIP25 spec to use. See CIP25 for details.
|
|
400
|
-
* This will change how things are encoded but for the most part contains
|
|
401
|
-
* the same information.
|
|
402
|
-
*/
|
|
403
|
-
export enum CIP25Version {
|
|
404
|
-
/**
|
|
405
|
-
* Initial version of CIP25 with only string (utf8) asset names allowed.
|
|
406
|
-
*/
|
|
407
|
-
V1 = 0,
|
|
408
|
-
/**
|
|
409
|
-
* Second version of CIP25. Supports any type of asset names.
|
|
410
|
-
*/
|
|
411
|
-
V2 = 1,
|
|
307
|
+
export enum ChunkableStringKind {
|
|
308
|
+
Single = 0,
|
|
309
|
+
Chunked = 1,
|
|
412
310
|
}
|
|
413
311
|
/**
|
|
414
312
|
* JSON <-> PlutusData conversion schemas.
|
|
@@ -464,28 +362,120 @@ export enum CardanoNodePlutusDatumSchema {
|
|
|
464
362
|
}
|
|
465
363
|
/**
|
|
466
364
|
*/
|
|
467
|
-
export enum
|
|
365
|
+
export enum StakeDistributionKind {
|
|
366
|
+
SingleKey = 0,
|
|
367
|
+
BootstrapEra = 1,
|
|
368
|
+
}
|
|
468
369
|
/**
|
|
469
|
-
* Performs CIP2's Largest First ada-only selection. Will error if outputs contain non-ADA assets.
|
|
470
370
|
*/
|
|
471
|
-
|
|
371
|
+
export enum ChangeSelectionAlgo {
|
|
372
|
+
Default = 0,
|
|
373
|
+
}
|
|
472
374
|
/**
|
|
473
|
-
* Performs CIP2's Random Improve ada-only selection. Will error if outputs contain non-ADA assets.
|
|
474
375
|
*/
|
|
475
|
-
|
|
376
|
+
export enum Language {
|
|
377
|
+
PlutusV1 = 0,
|
|
378
|
+
PlutusV2 = 1,
|
|
379
|
+
PlutusV3 = 2,
|
|
380
|
+
}
|
|
476
381
|
/**
|
|
477
|
-
* Same as LargestFirst, but before adding ADA, will insert by largest-first for each asset type.
|
|
478
382
|
*/
|
|
479
|
-
|
|
383
|
+
export enum RelayKind {
|
|
384
|
+
SingleHostAddr = 0,
|
|
385
|
+
SingleHostName = 1,
|
|
386
|
+
MultiHostName = 2,
|
|
387
|
+
}
|
|
480
388
|
/**
|
|
481
|
-
* Same as RandomImprove, but before adding ADA, will insert by random-improve for each asset type.
|
|
482
389
|
*/
|
|
483
|
-
|
|
390
|
+
export enum PlutusDataKind {
|
|
391
|
+
ConstrPlutusData = 0,
|
|
392
|
+
Map = 1,
|
|
393
|
+
List = 2,
|
|
394
|
+
Integer = 3,
|
|
395
|
+
Bytes = 4,
|
|
484
396
|
}
|
|
485
397
|
/**
|
|
486
398
|
*/
|
|
487
|
-
export enum
|
|
488
|
-
|
|
399
|
+
export enum MetadataJsonSchema {
|
|
400
|
+
NoConversions = 0,
|
|
401
|
+
BasicConversions = 1,
|
|
402
|
+
DetailedSchema = 2,
|
|
403
|
+
}
|
|
404
|
+
/**
|
|
405
|
+
*/
|
|
406
|
+
export enum NativeScriptKind {
|
|
407
|
+
ScriptPubkey = 0,
|
|
408
|
+
ScriptAll = 1,
|
|
409
|
+
ScriptAny = 2,
|
|
410
|
+
ScriptNOfK = 3,
|
|
411
|
+
ScriptInvalidBefore = 4,
|
|
412
|
+
ScriptInvalidHereafter = 5,
|
|
413
|
+
}
|
|
414
|
+
/**
|
|
415
|
+
*/
|
|
416
|
+
export enum ScriptKind {
|
|
417
|
+
Native = 0,
|
|
418
|
+
PlutusV1 = 1,
|
|
419
|
+
PlutusV2 = 2,
|
|
420
|
+
PlutusV3 = 3,
|
|
421
|
+
}
|
|
422
|
+
/**
|
|
423
|
+
*/
|
|
424
|
+
export enum NonceKind {
|
|
425
|
+
Identity = 0,
|
|
426
|
+
Hash = 1,
|
|
427
|
+
}
|
|
428
|
+
/**
|
|
429
|
+
*/
|
|
430
|
+
export enum SpendingDataKind {
|
|
431
|
+
SpendingDataPubKey = 0,
|
|
432
|
+
SpendingDataScript = 1,
|
|
433
|
+
SpendingDataRedeem = 2,
|
|
434
|
+
}
|
|
435
|
+
/**
|
|
436
|
+
*/
|
|
437
|
+
export enum TransactionMetadatumKind {
|
|
438
|
+
Map = 0,
|
|
439
|
+
List = 1,
|
|
440
|
+
Int = 2,
|
|
441
|
+
Bytes = 3,
|
|
442
|
+
Text = 4,
|
|
443
|
+
}
|
|
444
|
+
/**
|
|
445
|
+
*/
|
|
446
|
+
export enum AuxiliaryDataKind {
|
|
447
|
+
Shelley = 0,
|
|
448
|
+
ShelleyMA = 1,
|
|
449
|
+
Conway = 2,
|
|
450
|
+
}
|
|
451
|
+
/**
|
|
452
|
+
*/
|
|
453
|
+
export enum DRepKind {
|
|
454
|
+
Key = 0,
|
|
455
|
+
Script = 1,
|
|
456
|
+
AlwaysAbstain = 2,
|
|
457
|
+
AlwaysNoConfidence = 3,
|
|
458
|
+
}
|
|
459
|
+
/**
|
|
460
|
+
*/
|
|
461
|
+
export enum CertificateKind {
|
|
462
|
+
StakeRegistration = 0,
|
|
463
|
+
StakeDeregistration = 1,
|
|
464
|
+
StakeDelegation = 2,
|
|
465
|
+
PoolRegistration = 3,
|
|
466
|
+
PoolRetirement = 4,
|
|
467
|
+
RegCert = 5,
|
|
468
|
+
UnregCert = 6,
|
|
469
|
+
VoteDelegCert = 7,
|
|
470
|
+
StakeVoteDelegCert = 8,
|
|
471
|
+
StakeRegDelegCert = 9,
|
|
472
|
+
VoteRegDelegCert = 10,
|
|
473
|
+
StakeVoteRegDelegCert = 11,
|
|
474
|
+
AuthCommitteeHotCert = 12,
|
|
475
|
+
ResignCommitteeColdCert = 13,
|
|
476
|
+
RegDrepCert = 14,
|
|
477
|
+
UnregDrepCert = 15,
|
|
478
|
+
UpdateDrepCert = 16,
|
|
489
479
|
}
|
|
490
480
|
/**
|
|
491
481
|
*/
|
|
@@ -494,6 +484,21 @@ export enum DelegationDistributionKind {
|
|
|
494
484
|
Legacy = 1,
|
|
495
485
|
}
|
|
496
486
|
/**
|
|
487
|
+
* Which version of the CIP25 spec to use. See CIP25 for details.
|
|
488
|
+
* This will change how things are encoded but for the most part contains
|
|
489
|
+
* the same information.
|
|
490
|
+
*/
|
|
491
|
+
export enum CIP25Version {
|
|
492
|
+
/**
|
|
493
|
+
* Initial version of CIP25 with only string (utf8) asset names allowed.
|
|
494
|
+
*/
|
|
495
|
+
V1 = 0,
|
|
496
|
+
/**
|
|
497
|
+
* Second version of CIP25. Supports any type of asset names.
|
|
498
|
+
*/
|
|
499
|
+
V2 = 1,
|
|
500
|
+
}
|
|
501
|
+
/**
|
|
497
502
|
*/
|
|
498
503
|
export class AddrAttributes {
|
|
499
504
|
free(): void;
|
|
@@ -861,6 +866,13 @@ export class AlonzoFormatTxOut {
|
|
|
861
866
|
to_cbor_bytes(): Uint8Array;
|
|
862
867
|
/**
|
|
863
868
|
*
|
|
869
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
870
|
+
*
|
|
871
|
+
* @returns {Uint8Array}
|
|
872
|
+
*/
|
|
873
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
874
|
+
/**
|
|
875
|
+
*
|
|
864
876
|
* * Create this type from CBOR bytes
|
|
865
877
|
*
|
|
866
878
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -878,6 +890,13 @@ export class AlonzoFormatTxOut {
|
|
|
878
890
|
to_cbor_hex(): string;
|
|
879
891
|
/**
|
|
880
892
|
*
|
|
893
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
894
|
+
*
|
|
895
|
+
* @returns {string}
|
|
896
|
+
*/
|
|
897
|
+
to_canonical_cbor_hex(): string;
|
|
898
|
+
/**
|
|
899
|
+
*
|
|
881
900
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
882
901
|
* * This is useful for interfacing with CIP30
|
|
883
902
|
*
|
|
@@ -936,6 +955,13 @@ export class Anchor {
|
|
|
936
955
|
to_cbor_bytes(): Uint8Array;
|
|
937
956
|
/**
|
|
938
957
|
*
|
|
958
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
959
|
+
*
|
|
960
|
+
* @returns {Uint8Array}
|
|
961
|
+
*/
|
|
962
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
963
|
+
/**
|
|
964
|
+
*
|
|
939
965
|
* * Create this type from CBOR bytes
|
|
940
966
|
*
|
|
941
967
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -953,6 +979,13 @@ export class Anchor {
|
|
|
953
979
|
to_cbor_hex(): string;
|
|
954
980
|
/**
|
|
955
981
|
*
|
|
982
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
983
|
+
*
|
|
984
|
+
* @returns {string}
|
|
985
|
+
*/
|
|
986
|
+
to_canonical_cbor_hex(): string;
|
|
987
|
+
/**
|
|
988
|
+
*
|
|
956
989
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
957
990
|
* * This is useful for interfacing with CIP30
|
|
958
991
|
*
|
|
@@ -1039,97 +1072,111 @@ export class AssetName {
|
|
|
1039
1072
|
free(): void;
|
|
1040
1073
|
/**
|
|
1041
1074
|
*
|
|
1042
|
-
*
|
|
1043
|
-
*
|
|
1044
|
-
*
|
|
1045
|
-
*
|
|
1075
|
+
* * Serialize this type to CBOR bytes
|
|
1076
|
+
* * This type type supports encoding preservation so this will preserve round-trip CBOR formats.
|
|
1077
|
+
* * If created from scratch the CBOR will be canonical.
|
|
1078
|
+
*
|
|
1079
|
+
* @returns {Uint8Array}
|
|
1046
1080
|
*/
|
|
1047
|
-
|
|
1081
|
+
to_cbor_bytes(): Uint8Array;
|
|
1048
1082
|
/**
|
|
1049
1083
|
*
|
|
1050
|
-
*
|
|
1051
|
-
*
|
|
1052
|
-
* @returns {
|
|
1084
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
1085
|
+
*
|
|
1086
|
+
* @returns {Uint8Array}
|
|
1053
1087
|
*/
|
|
1054
|
-
|
|
1088
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
1055
1089
|
/**
|
|
1056
1090
|
*
|
|
1057
|
-
* *
|
|
1091
|
+
* * Create this type from CBOR bytes
|
|
1058
1092
|
*
|
|
1059
|
-
* @
|
|
1093
|
+
* @param {Uint8Array} cbor_bytes
|
|
1094
|
+
* @returns {AssetName}
|
|
1060
1095
|
*/
|
|
1061
|
-
|
|
1096
|
+
static from_cbor_bytes(cbor_bytes: Uint8Array): AssetName;
|
|
1062
1097
|
/**
|
|
1063
1098
|
*
|
|
1064
|
-
* *
|
|
1099
|
+
* * Serialize this type to CBOR bytes encoded as a hex string (useful for working with CIP30).
|
|
1100
|
+
* * This type type supports encoding preservation so this will preserve round-trip CBOR formats.
|
|
1101
|
+
* * If created from scratch the CBOR will be canonical.
|
|
1065
1102
|
*
|
|
1066
|
-
* @
|
|
1067
|
-
* @returns {AssetName}
|
|
1103
|
+
* @returns {string}
|
|
1068
1104
|
*/
|
|
1069
|
-
|
|
1105
|
+
to_cbor_hex(): string;
|
|
1070
1106
|
/**
|
|
1071
1107
|
*
|
|
1072
|
-
* *
|
|
1108
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
1073
1109
|
*
|
|
1074
1110
|
* @returns {string}
|
|
1075
1111
|
*/
|
|
1076
|
-
|
|
1112
|
+
to_canonical_cbor_hex(): string;
|
|
1077
1113
|
/**
|
|
1078
1114
|
*
|
|
1079
|
-
* *
|
|
1115
|
+
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
1116
|
+
* * This is useful for interfacing with CIP30
|
|
1080
1117
|
*
|
|
1081
|
-
* @param {string}
|
|
1118
|
+
* @param {string} cbor_bytes
|
|
1082
1119
|
* @returns {AssetName}
|
|
1083
1120
|
*/
|
|
1084
|
-
static
|
|
1121
|
+
static from_cbor_hex(cbor_bytes: string): AssetName;
|
|
1122
|
+
/**
|
|
1123
|
+
* @returns {string}
|
|
1124
|
+
*/
|
|
1125
|
+
to_json(): string;
|
|
1126
|
+
/**
|
|
1127
|
+
* @returns {any}
|
|
1128
|
+
*/
|
|
1129
|
+
to_js_value(): any;
|
|
1130
|
+
/**
|
|
1131
|
+
* @param {string} json
|
|
1132
|
+
* @returns {AssetName}
|
|
1133
|
+
*/
|
|
1134
|
+
static from_json(json: string): AssetName;
|
|
1085
1135
|
/**
|
|
1086
1136
|
*
|
|
1087
|
-
*
|
|
1088
|
-
*
|
|
1089
|
-
*
|
|
1137
|
+
* * Create an AssetName from utf8 string. 64 byte (not char!) maximum.
|
|
1138
|
+
*
|
|
1139
|
+
* @param {string} utf8_str
|
|
1140
|
+
* @returns {AssetName}
|
|
1141
|
+
*/
|
|
1142
|
+
static from_str(utf8_str: string): AssetName;
|
|
1143
|
+
/**
|
|
1144
|
+
*
|
|
1145
|
+
* * AssetName as a utf8 string if it's possible. Will error if the asset is not utf8
|
|
1146
|
+
*
|
|
1147
|
+
* @returns {string}
|
|
1148
|
+
*/
|
|
1149
|
+
to_str(): string;
|
|
1150
|
+
/**
|
|
1151
|
+
*
|
|
1152
|
+
* * Direct raw bytes without any CBOR structure
|
|
1090
1153
|
*
|
|
1091
1154
|
* @returns {Uint8Array}
|
|
1092
1155
|
*/
|
|
1093
|
-
|
|
1156
|
+
to_raw_bytes(): Uint8Array;
|
|
1094
1157
|
/**
|
|
1095
1158
|
*
|
|
1096
|
-
* *
|
|
1159
|
+
* * Parse from the direct raw bytes, without any CBOR structure
|
|
1097
1160
|
*
|
|
1098
|
-
* @param {Uint8Array}
|
|
1161
|
+
* @param {Uint8Array} bytes
|
|
1099
1162
|
* @returns {AssetName}
|
|
1100
1163
|
*/
|
|
1101
|
-
static
|
|
1164
|
+
static from_raw_bytes(bytes: Uint8Array): AssetName;
|
|
1102
1165
|
/**
|
|
1103
1166
|
*
|
|
1104
|
-
* *
|
|
1105
|
-
* * This type type supports encoding preservation so this will preserve round-trip CBOR formats.
|
|
1106
|
-
* * If created from scratch the CBOR will be canonical.
|
|
1167
|
+
* * Direct raw bytes without any CBOR structure, as a hex-encoded string
|
|
1107
1168
|
*
|
|
1108
1169
|
* @returns {string}
|
|
1109
1170
|
*/
|
|
1110
|
-
|
|
1171
|
+
to_hex(): string;
|
|
1111
1172
|
/**
|
|
1112
1173
|
*
|
|
1113
|
-
* *
|
|
1114
|
-
* * This is useful for interfacing with CIP30
|
|
1174
|
+
* * Parse from a hex string of the direct raw bytes, without any CBOR structure
|
|
1115
1175
|
*
|
|
1116
|
-
* @param {string}
|
|
1117
|
-
* @returns {AssetName}
|
|
1118
|
-
*/
|
|
1119
|
-
static from_cbor_hex(cbor_bytes: string): AssetName;
|
|
1120
|
-
/**
|
|
1121
|
-
* @returns {string}
|
|
1122
|
-
*/
|
|
1123
|
-
to_json(): string;
|
|
1124
|
-
/**
|
|
1125
|
-
* @returns {any}
|
|
1126
|
-
*/
|
|
1127
|
-
to_js_value(): any;
|
|
1128
|
-
/**
|
|
1129
|
-
* @param {string} json
|
|
1176
|
+
* @param {string} input
|
|
1130
1177
|
* @returns {AssetName}
|
|
1131
1178
|
*/
|
|
1132
|
-
static
|
|
1179
|
+
static from_hex(input: string): AssetName;
|
|
1133
1180
|
}
|
|
1134
1181
|
/**
|
|
1135
1182
|
*/
|
|
@@ -1168,6 +1215,13 @@ export class AuthCommitteeHotCert {
|
|
|
1168
1215
|
to_cbor_bytes(): Uint8Array;
|
|
1169
1216
|
/**
|
|
1170
1217
|
*
|
|
1218
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
1219
|
+
*
|
|
1220
|
+
* @returns {Uint8Array}
|
|
1221
|
+
*/
|
|
1222
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
1223
|
+
/**
|
|
1224
|
+
*
|
|
1171
1225
|
* * Create this type from CBOR bytes
|
|
1172
1226
|
*
|
|
1173
1227
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -1185,6 +1239,13 @@ export class AuthCommitteeHotCert {
|
|
|
1185
1239
|
to_cbor_hex(): string;
|
|
1186
1240
|
/**
|
|
1187
1241
|
*
|
|
1242
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
1243
|
+
*
|
|
1244
|
+
* @returns {string}
|
|
1245
|
+
*/
|
|
1246
|
+
to_canonical_cbor_hex(): string;
|
|
1247
|
+
/**
|
|
1248
|
+
*
|
|
1188
1249
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
1189
1250
|
* * This is useful for interfacing with CIP30
|
|
1190
1251
|
*
|
|
@@ -1283,6 +1344,13 @@ export class AuxiliaryData {
|
|
|
1283
1344
|
to_cbor_bytes(): Uint8Array;
|
|
1284
1345
|
/**
|
|
1285
1346
|
*
|
|
1347
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
1348
|
+
*
|
|
1349
|
+
* @returns {Uint8Array}
|
|
1350
|
+
*/
|
|
1351
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
1352
|
+
/**
|
|
1353
|
+
*
|
|
1286
1354
|
* * Create this type from CBOR bytes
|
|
1287
1355
|
*
|
|
1288
1356
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -1300,6 +1368,13 @@ export class AuxiliaryData {
|
|
|
1300
1368
|
to_cbor_hex(): string;
|
|
1301
1369
|
/**
|
|
1302
1370
|
*
|
|
1371
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
1372
|
+
*
|
|
1373
|
+
* @returns {string}
|
|
1374
|
+
*/
|
|
1375
|
+
to_canonical_cbor_hex(): string;
|
|
1376
|
+
/**
|
|
1377
|
+
*
|
|
1303
1378
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
1304
1379
|
* * This is useful for interfacing with CIP30
|
|
1305
1380
|
*
|
|
@@ -1445,6 +1520,13 @@ export class BigInteger {
|
|
|
1445
1520
|
to_cbor_bytes(): Uint8Array;
|
|
1446
1521
|
/**
|
|
1447
1522
|
*
|
|
1523
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
1524
|
+
*
|
|
1525
|
+
* @returns {Uint8Array}
|
|
1526
|
+
*/
|
|
1527
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
1528
|
+
/**
|
|
1529
|
+
*
|
|
1448
1530
|
* * Create this type from CBOR bytes
|
|
1449
1531
|
*
|
|
1450
1532
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -1462,6 +1544,13 @@ export class BigInteger {
|
|
|
1462
1544
|
to_cbor_hex(): string;
|
|
1463
1545
|
/**
|
|
1464
1546
|
*
|
|
1547
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
1548
|
+
*
|
|
1549
|
+
* @returns {string}
|
|
1550
|
+
*/
|
|
1551
|
+
to_canonical_cbor_hex(): string;
|
|
1552
|
+
/**
|
|
1553
|
+
*
|
|
1465
1554
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
1466
1555
|
* * This is useful for interfacing with CIP30
|
|
1467
1556
|
*
|
|
@@ -1670,6 +1759,13 @@ export class Block {
|
|
|
1670
1759
|
to_cbor_bytes(): Uint8Array;
|
|
1671
1760
|
/**
|
|
1672
1761
|
*
|
|
1762
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
1763
|
+
*
|
|
1764
|
+
* @returns {Uint8Array}
|
|
1765
|
+
*/
|
|
1766
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
1767
|
+
/**
|
|
1768
|
+
*
|
|
1673
1769
|
* * Create this type from CBOR bytes
|
|
1674
1770
|
*
|
|
1675
1771
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -1687,6 +1783,13 @@ export class Block {
|
|
|
1687
1783
|
to_cbor_hex(): string;
|
|
1688
1784
|
/**
|
|
1689
1785
|
*
|
|
1786
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
1787
|
+
*
|
|
1788
|
+
* @returns {string}
|
|
1789
|
+
*/
|
|
1790
|
+
to_canonical_cbor_hex(): string;
|
|
1791
|
+
/**
|
|
1792
|
+
*
|
|
1690
1793
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
1691
1794
|
* * This is useful for interfacing with CIP30
|
|
1692
1795
|
*
|
|
@@ -1846,6 +1949,13 @@ export class BootstrapWitness {
|
|
|
1846
1949
|
to_cbor_bytes(): Uint8Array;
|
|
1847
1950
|
/**
|
|
1848
1951
|
*
|
|
1952
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
1953
|
+
*
|
|
1954
|
+
* @returns {Uint8Array}
|
|
1955
|
+
*/
|
|
1956
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
1957
|
+
/**
|
|
1958
|
+
*
|
|
1849
1959
|
* * Create this type from CBOR bytes
|
|
1850
1960
|
*
|
|
1851
1961
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -1863,6 +1973,13 @@ export class BootstrapWitness {
|
|
|
1863
1973
|
to_cbor_hex(): string;
|
|
1864
1974
|
/**
|
|
1865
1975
|
*
|
|
1976
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
1977
|
+
*
|
|
1978
|
+
* @returns {string}
|
|
1979
|
+
*/
|
|
1980
|
+
to_canonical_cbor_hex(): string;
|
|
1981
|
+
/**
|
|
1982
|
+
*
|
|
1866
1983
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
1867
1984
|
* * This is useful for interfacing with CIP30
|
|
1868
1985
|
*
|
|
@@ -2666,6 +2783,13 @@ export class CIP36Delegation {
|
|
|
2666
2783
|
to_cbor_bytes(): Uint8Array;
|
|
2667
2784
|
/**
|
|
2668
2785
|
*
|
|
2786
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
2787
|
+
*
|
|
2788
|
+
* @returns {Uint8Array}
|
|
2789
|
+
*/
|
|
2790
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
2791
|
+
/**
|
|
2792
|
+
*
|
|
2669
2793
|
* * Create this type from CBOR bytes
|
|
2670
2794
|
*
|
|
2671
2795
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -2683,6 +2807,13 @@ export class CIP36Delegation {
|
|
|
2683
2807
|
to_cbor_hex(): string;
|
|
2684
2808
|
/**
|
|
2685
2809
|
*
|
|
2810
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
2811
|
+
*
|
|
2812
|
+
* @returns {string}
|
|
2813
|
+
*/
|
|
2814
|
+
to_canonical_cbor_hex(): string;
|
|
2815
|
+
/**
|
|
2816
|
+
*
|
|
2686
2817
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
2687
2818
|
* * This is useful for interfacing with CIP30
|
|
2688
2819
|
*
|
|
@@ -2733,6 +2864,13 @@ export class CIP36DelegationDistribution {
|
|
|
2733
2864
|
to_cbor_bytes(): Uint8Array;
|
|
2734
2865
|
/**
|
|
2735
2866
|
*
|
|
2867
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
2868
|
+
*
|
|
2869
|
+
* @returns {Uint8Array}
|
|
2870
|
+
*/
|
|
2871
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
2872
|
+
/**
|
|
2873
|
+
*
|
|
2736
2874
|
* * Create this type from CBOR bytes
|
|
2737
2875
|
*
|
|
2738
2876
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -2750,6 +2888,13 @@ export class CIP36DelegationDistribution {
|
|
|
2750
2888
|
to_cbor_hex(): string;
|
|
2751
2889
|
/**
|
|
2752
2890
|
*
|
|
2891
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
2892
|
+
*
|
|
2893
|
+
* @returns {string}
|
|
2894
|
+
*/
|
|
2895
|
+
to_canonical_cbor_hex(): string;
|
|
2896
|
+
/**
|
|
2897
|
+
*
|
|
2753
2898
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
2754
2899
|
* * This is useful for interfacing with CIP30
|
|
2755
2900
|
*
|
|
@@ -2862,6 +3007,13 @@ export class CIP36DeregistrationWitness {
|
|
|
2862
3007
|
to_cbor_bytes(): Uint8Array;
|
|
2863
3008
|
/**
|
|
2864
3009
|
*
|
|
3010
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
3011
|
+
*
|
|
3012
|
+
* @returns {Uint8Array}
|
|
3013
|
+
*/
|
|
3014
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
3015
|
+
/**
|
|
3016
|
+
*
|
|
2865
3017
|
* * Create this type from CBOR bytes
|
|
2866
3018
|
*
|
|
2867
3019
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -2879,6 +3031,13 @@ export class CIP36DeregistrationWitness {
|
|
|
2879
3031
|
to_cbor_hex(): string;
|
|
2880
3032
|
/**
|
|
2881
3033
|
*
|
|
3034
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
3035
|
+
*
|
|
3036
|
+
* @returns {string}
|
|
3037
|
+
*/
|
|
3038
|
+
to_canonical_cbor_hex(): string;
|
|
3039
|
+
/**
|
|
3040
|
+
*
|
|
2882
3041
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
2883
3042
|
* * This is useful for interfacing with CIP30
|
|
2884
3043
|
*
|
|
@@ -2924,6 +3083,13 @@ export class CIP36KeyDeregistration {
|
|
|
2924
3083
|
to_cbor_bytes(): Uint8Array;
|
|
2925
3084
|
/**
|
|
2926
3085
|
*
|
|
3086
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
3087
|
+
*
|
|
3088
|
+
* @returns {Uint8Array}
|
|
3089
|
+
*/
|
|
3090
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
3091
|
+
/**
|
|
3092
|
+
*
|
|
2927
3093
|
* * Create this type from CBOR bytes
|
|
2928
3094
|
*
|
|
2929
3095
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -2941,6 +3107,13 @@ export class CIP36KeyDeregistration {
|
|
|
2941
3107
|
to_cbor_hex(): string;
|
|
2942
3108
|
/**
|
|
2943
3109
|
*
|
|
3110
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
3111
|
+
*
|
|
3112
|
+
* @returns {string}
|
|
3113
|
+
*/
|
|
3114
|
+
to_canonical_cbor_hex(): string;
|
|
3115
|
+
/**
|
|
3116
|
+
*
|
|
2944
3117
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
2945
3118
|
* * This is useful for interfacing with CIP30
|
|
2946
3119
|
*
|
|
@@ -2993,6 +3166,13 @@ export class CIP36KeyRegistration {
|
|
|
2993
3166
|
to_cbor_bytes(): Uint8Array;
|
|
2994
3167
|
/**
|
|
2995
3168
|
*
|
|
3169
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
3170
|
+
*
|
|
3171
|
+
* @returns {Uint8Array}
|
|
3172
|
+
*/
|
|
3173
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
3174
|
+
/**
|
|
3175
|
+
*
|
|
2996
3176
|
* * Create this type from CBOR bytes
|
|
2997
3177
|
*
|
|
2998
3178
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -3010,6 +3190,13 @@ export class CIP36KeyRegistration {
|
|
|
3010
3190
|
to_cbor_hex(): string;
|
|
3011
3191
|
/**
|
|
3012
3192
|
*
|
|
3193
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
3194
|
+
*
|
|
3195
|
+
* @returns {string}
|
|
3196
|
+
*/
|
|
3197
|
+
to_canonical_cbor_hex(): string;
|
|
3198
|
+
/**
|
|
3199
|
+
*
|
|
3013
3200
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
3014
3201
|
* * This is useful for interfacing with CIP30
|
|
3015
3202
|
*
|
|
@@ -3102,6 +3289,13 @@ export class CIP36RegistrationWitness {
|
|
|
3102
3289
|
to_cbor_bytes(): Uint8Array;
|
|
3103
3290
|
/**
|
|
3104
3291
|
*
|
|
3292
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
3293
|
+
*
|
|
3294
|
+
* @returns {Uint8Array}
|
|
3295
|
+
*/
|
|
3296
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
3297
|
+
/**
|
|
3298
|
+
*
|
|
3105
3299
|
* * Create this type from CBOR bytes
|
|
3106
3300
|
*
|
|
3107
3301
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -3119,6 +3313,13 @@ export class CIP36RegistrationWitness {
|
|
|
3119
3313
|
to_cbor_hex(): string;
|
|
3120
3314
|
/**
|
|
3121
3315
|
*
|
|
3316
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
3317
|
+
*
|
|
3318
|
+
* @returns {string}
|
|
3319
|
+
*/
|
|
3320
|
+
to_canonical_cbor_hex(): string;
|
|
3321
|
+
/**
|
|
3322
|
+
*
|
|
3122
3323
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
3123
3324
|
* * This is useful for interfacing with CIP30
|
|
3124
3325
|
*
|
|
@@ -3164,6 +3365,13 @@ export class Certificate {
|
|
|
3164
3365
|
to_cbor_bytes(): Uint8Array;
|
|
3165
3366
|
/**
|
|
3166
3367
|
*
|
|
3368
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
3369
|
+
*
|
|
3370
|
+
* @returns {Uint8Array}
|
|
3371
|
+
*/
|
|
3372
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
3373
|
+
/**
|
|
3374
|
+
*
|
|
3167
3375
|
* * Create this type from CBOR bytes
|
|
3168
3376
|
*
|
|
3169
3377
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -3181,6 +3389,13 @@ export class Certificate {
|
|
|
3181
3389
|
to_cbor_hex(): string;
|
|
3182
3390
|
/**
|
|
3183
3391
|
*
|
|
3392
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
3393
|
+
*
|
|
3394
|
+
* @returns {string}
|
|
3395
|
+
*/
|
|
3396
|
+
to_canonical_cbor_hex(): string;
|
|
3397
|
+
/**
|
|
3398
|
+
*
|
|
3184
3399
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
3185
3400
|
* * This is useful for interfacing with CIP30
|
|
3186
3401
|
*
|
|
@@ -3453,6 +3668,13 @@ export class Constitution {
|
|
|
3453
3668
|
to_cbor_bytes(): Uint8Array;
|
|
3454
3669
|
/**
|
|
3455
3670
|
*
|
|
3671
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
3672
|
+
*
|
|
3673
|
+
* @returns {Uint8Array}
|
|
3674
|
+
*/
|
|
3675
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
3676
|
+
/**
|
|
3677
|
+
*
|
|
3456
3678
|
* * Create this type from CBOR bytes
|
|
3457
3679
|
*
|
|
3458
3680
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -3470,6 +3692,13 @@ export class Constitution {
|
|
|
3470
3692
|
to_cbor_hex(): string;
|
|
3471
3693
|
/**
|
|
3472
3694
|
*
|
|
3695
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
3696
|
+
*
|
|
3697
|
+
* @returns {string}
|
|
3698
|
+
*/
|
|
3699
|
+
to_canonical_cbor_hex(): string;
|
|
3700
|
+
/**
|
|
3701
|
+
*
|
|
3473
3702
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
3474
3703
|
* * This is useful for interfacing with CIP30
|
|
3475
3704
|
*
|
|
@@ -3520,6 +3749,13 @@ export class ConstrPlutusData {
|
|
|
3520
3749
|
to_cbor_bytes(): Uint8Array;
|
|
3521
3750
|
/**
|
|
3522
3751
|
*
|
|
3752
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
3753
|
+
*
|
|
3754
|
+
* @returns {Uint8Array}
|
|
3755
|
+
*/
|
|
3756
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
3757
|
+
/**
|
|
3758
|
+
*
|
|
3523
3759
|
* * Create this type from CBOR bytes
|
|
3524
3760
|
*
|
|
3525
3761
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -3537,6 +3773,13 @@ export class ConstrPlutusData {
|
|
|
3537
3773
|
to_cbor_hex(): string;
|
|
3538
3774
|
/**
|
|
3539
3775
|
*
|
|
3776
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
3777
|
+
*
|
|
3778
|
+
* @returns {string}
|
|
3779
|
+
*/
|
|
3780
|
+
to_canonical_cbor_hex(): string;
|
|
3781
|
+
/**
|
|
3782
|
+
*
|
|
3540
3783
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
3541
3784
|
* * This is useful for interfacing with CIP30
|
|
3542
3785
|
*
|
|
@@ -3587,6 +3830,13 @@ export class ConwayFormatAuxData {
|
|
|
3587
3830
|
to_cbor_bytes(): Uint8Array;
|
|
3588
3831
|
/**
|
|
3589
3832
|
*
|
|
3833
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
3834
|
+
*
|
|
3835
|
+
* @returns {Uint8Array}
|
|
3836
|
+
*/
|
|
3837
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
3838
|
+
/**
|
|
3839
|
+
*
|
|
3590
3840
|
* * Create this type from CBOR bytes
|
|
3591
3841
|
*
|
|
3592
3842
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -3604,6 +3854,13 @@ export class ConwayFormatAuxData {
|
|
|
3604
3854
|
to_cbor_hex(): string;
|
|
3605
3855
|
/**
|
|
3606
3856
|
*
|
|
3857
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
3858
|
+
*
|
|
3859
|
+
* @returns {string}
|
|
3860
|
+
*/
|
|
3861
|
+
to_canonical_cbor_hex(): string;
|
|
3862
|
+
/**
|
|
3863
|
+
*
|
|
3607
3864
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
3608
3865
|
* * This is useful for interfacing with CIP30
|
|
3609
3866
|
*
|
|
@@ -3684,6 +3941,13 @@ export class ConwayFormatTxOut {
|
|
|
3684
3941
|
to_cbor_bytes(): Uint8Array;
|
|
3685
3942
|
/**
|
|
3686
3943
|
*
|
|
3944
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
3945
|
+
*
|
|
3946
|
+
* @returns {Uint8Array}
|
|
3947
|
+
*/
|
|
3948
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
3949
|
+
/**
|
|
3950
|
+
*
|
|
3687
3951
|
* * Create this type from CBOR bytes
|
|
3688
3952
|
*
|
|
3689
3953
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -3701,6 +3965,13 @@ export class ConwayFormatTxOut {
|
|
|
3701
3965
|
to_cbor_hex(): string;
|
|
3702
3966
|
/**
|
|
3703
3967
|
*
|
|
3968
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
3969
|
+
*
|
|
3970
|
+
* @returns {string}
|
|
3971
|
+
*/
|
|
3972
|
+
to_canonical_cbor_hex(): string;
|
|
3973
|
+
/**
|
|
3974
|
+
*
|
|
3704
3975
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
3705
3976
|
* * This is useful for interfacing with CIP30
|
|
3706
3977
|
*
|
|
@@ -3767,6 +4038,13 @@ export class CostModels {
|
|
|
3767
4038
|
to_cbor_bytes(): Uint8Array;
|
|
3768
4039
|
/**
|
|
3769
4040
|
*
|
|
4041
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
4042
|
+
*
|
|
4043
|
+
* @returns {Uint8Array}
|
|
4044
|
+
*/
|
|
4045
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
4046
|
+
/**
|
|
4047
|
+
*
|
|
3770
4048
|
* * Create this type from CBOR bytes
|
|
3771
4049
|
*
|
|
3772
4050
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -3784,6 +4062,13 @@ export class CostModels {
|
|
|
3784
4062
|
to_cbor_hex(): string;
|
|
3785
4063
|
/**
|
|
3786
4064
|
*
|
|
4065
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
4066
|
+
*
|
|
4067
|
+
* @returns {string}
|
|
4068
|
+
*/
|
|
4069
|
+
to_canonical_cbor_hex(): string;
|
|
4070
|
+
/**
|
|
4071
|
+
*
|
|
3787
4072
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
3788
4073
|
* * This is useful for interfacing with CIP30
|
|
3789
4074
|
*
|
|
@@ -3847,6 +4132,13 @@ export class Credential {
|
|
|
3847
4132
|
to_cbor_bytes(): Uint8Array;
|
|
3848
4133
|
/**
|
|
3849
4134
|
*
|
|
4135
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
4136
|
+
*
|
|
4137
|
+
* @returns {Uint8Array}
|
|
4138
|
+
*/
|
|
4139
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
4140
|
+
/**
|
|
4141
|
+
*
|
|
3850
4142
|
* * Create this type from CBOR bytes
|
|
3851
4143
|
*
|
|
3852
4144
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -3864,6 +4156,13 @@ export class Credential {
|
|
|
3864
4156
|
to_cbor_hex(): string;
|
|
3865
4157
|
/**
|
|
3866
4158
|
*
|
|
4159
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
4160
|
+
*
|
|
4161
|
+
* @returns {string}
|
|
4162
|
+
*/
|
|
4163
|
+
to_canonical_cbor_hex(): string;
|
|
4164
|
+
/**
|
|
4165
|
+
*
|
|
3867
4166
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
3868
4167
|
* * This is useful for interfacing with CIP30
|
|
3869
4168
|
*
|
|
@@ -3922,6 +4221,13 @@ export class DNSName {
|
|
|
3922
4221
|
to_cbor_bytes(): Uint8Array;
|
|
3923
4222
|
/**
|
|
3924
4223
|
*
|
|
4224
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
4225
|
+
*
|
|
4226
|
+
* @returns {Uint8Array}
|
|
4227
|
+
*/
|
|
4228
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
4229
|
+
/**
|
|
4230
|
+
*
|
|
3925
4231
|
* * Create this type from CBOR bytes
|
|
3926
4232
|
*
|
|
3927
4233
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -3939,6 +4245,13 @@ export class DNSName {
|
|
|
3939
4245
|
to_cbor_hex(): string;
|
|
3940
4246
|
/**
|
|
3941
4247
|
*
|
|
4248
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
4249
|
+
*
|
|
4250
|
+
* @returns {string}
|
|
4251
|
+
*/
|
|
4252
|
+
to_canonical_cbor_hex(): string;
|
|
4253
|
+
/**
|
|
4254
|
+
*
|
|
3942
4255
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
3943
4256
|
* * This is useful for interfacing with CIP30
|
|
3944
4257
|
*
|
|
@@ -3979,6 +4292,13 @@ export class DRep {
|
|
|
3979
4292
|
to_cbor_bytes(): Uint8Array;
|
|
3980
4293
|
/**
|
|
3981
4294
|
*
|
|
4295
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
4296
|
+
*
|
|
4297
|
+
* @returns {Uint8Array}
|
|
4298
|
+
*/
|
|
4299
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
4300
|
+
/**
|
|
4301
|
+
*
|
|
3982
4302
|
* * Create this type from CBOR bytes
|
|
3983
4303
|
*
|
|
3984
4304
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -3996,6 +4316,13 @@ export class DRep {
|
|
|
3996
4316
|
to_cbor_hex(): string;
|
|
3997
4317
|
/**
|
|
3998
4318
|
*
|
|
4319
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
4320
|
+
*
|
|
4321
|
+
* @returns {string}
|
|
4322
|
+
*/
|
|
4323
|
+
to_canonical_cbor_hex(): string;
|
|
4324
|
+
/**
|
|
4325
|
+
*
|
|
3999
4326
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
4000
4327
|
* * This is useful for interfacing with CIP30
|
|
4001
4328
|
*
|
|
@@ -4062,6 +4389,13 @@ export class DRepVotingThresholds {
|
|
|
4062
4389
|
to_cbor_bytes(): Uint8Array;
|
|
4063
4390
|
/**
|
|
4064
4391
|
*
|
|
4392
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
4393
|
+
*
|
|
4394
|
+
* @returns {Uint8Array}
|
|
4395
|
+
*/
|
|
4396
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
4397
|
+
/**
|
|
4398
|
+
*
|
|
4065
4399
|
* * Create this type from CBOR bytes
|
|
4066
4400
|
*
|
|
4067
4401
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -4079,6 +4413,13 @@ export class DRepVotingThresholds {
|
|
|
4079
4413
|
to_cbor_hex(): string;
|
|
4080
4414
|
/**
|
|
4081
4415
|
*
|
|
4416
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
4417
|
+
*
|
|
4418
|
+
* @returns {string}
|
|
4419
|
+
*/
|
|
4420
|
+
to_canonical_cbor_hex(): string;
|
|
4421
|
+
/**
|
|
4422
|
+
*
|
|
4082
4423
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
4083
4424
|
* * This is useful for interfacing with CIP30
|
|
4084
4425
|
*
|
|
@@ -4205,13 +4546,20 @@ export class DatumOption {
|
|
|
4205
4546
|
free(): void;
|
|
4206
4547
|
/**
|
|
4207
4548
|
*
|
|
4208
|
-
* * Serialize this type to CBOR bytes
|
|
4209
|
-
* * This type type supports encoding preservation so this will preserve round-trip CBOR formats.
|
|
4210
|
-
* * If created from scratch the CBOR will be canonical.
|
|
4549
|
+
* * Serialize this type to CBOR bytes
|
|
4550
|
+
* * This type type supports encoding preservation so this will preserve round-trip CBOR formats.
|
|
4551
|
+
* * If created from scratch the CBOR will be canonical.
|
|
4552
|
+
*
|
|
4553
|
+
* @returns {Uint8Array}
|
|
4554
|
+
*/
|
|
4555
|
+
to_cbor_bytes(): Uint8Array;
|
|
4556
|
+
/**
|
|
4557
|
+
*
|
|
4558
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
4211
4559
|
*
|
|
4212
4560
|
* @returns {Uint8Array}
|
|
4213
4561
|
*/
|
|
4214
|
-
|
|
4562
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
4215
4563
|
/**
|
|
4216
4564
|
*
|
|
4217
4565
|
* * Create this type from CBOR bytes
|
|
@@ -4231,6 +4579,13 @@ export class DatumOption {
|
|
|
4231
4579
|
to_cbor_hex(): string;
|
|
4232
4580
|
/**
|
|
4233
4581
|
*
|
|
4582
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
4583
|
+
*
|
|
4584
|
+
* @returns {string}
|
|
4585
|
+
*/
|
|
4586
|
+
to_canonical_cbor_hex(): string;
|
|
4587
|
+
/**
|
|
4588
|
+
*
|
|
4234
4589
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
4235
4590
|
* * This is useful for interfacing with CIP30
|
|
4236
4591
|
*
|
|
@@ -4428,6 +4783,13 @@ export class ExUnitPrices {
|
|
|
4428
4783
|
to_cbor_bytes(): Uint8Array;
|
|
4429
4784
|
/**
|
|
4430
4785
|
*
|
|
4786
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
4787
|
+
*
|
|
4788
|
+
* @returns {Uint8Array}
|
|
4789
|
+
*/
|
|
4790
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
4791
|
+
/**
|
|
4792
|
+
*
|
|
4431
4793
|
* * Create this type from CBOR bytes
|
|
4432
4794
|
*
|
|
4433
4795
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -4445,6 +4807,13 @@ export class ExUnitPrices {
|
|
|
4445
4807
|
to_cbor_hex(): string;
|
|
4446
4808
|
/**
|
|
4447
4809
|
*
|
|
4810
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
4811
|
+
*
|
|
4812
|
+
* @returns {string}
|
|
4813
|
+
*/
|
|
4814
|
+
to_canonical_cbor_hex(): string;
|
|
4815
|
+
/**
|
|
4816
|
+
*
|
|
4448
4817
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
4449
4818
|
* * This is useful for interfacing with CIP30
|
|
4450
4819
|
*
|
|
@@ -4500,6 +4869,13 @@ export class ExUnits {
|
|
|
4500
4869
|
to_cbor_bytes(): Uint8Array;
|
|
4501
4870
|
/**
|
|
4502
4871
|
*
|
|
4872
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
4873
|
+
*
|
|
4874
|
+
* @returns {Uint8Array}
|
|
4875
|
+
*/
|
|
4876
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
4877
|
+
/**
|
|
4878
|
+
*
|
|
4503
4879
|
* * Create this type from CBOR bytes
|
|
4504
4880
|
*
|
|
4505
4881
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -4517,6 +4893,13 @@ export class ExUnits {
|
|
|
4517
4893
|
to_cbor_hex(): string;
|
|
4518
4894
|
/**
|
|
4519
4895
|
*
|
|
4896
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
4897
|
+
*
|
|
4898
|
+
* @returns {string}
|
|
4899
|
+
*/
|
|
4900
|
+
to_canonical_cbor_hex(): string;
|
|
4901
|
+
/**
|
|
4902
|
+
*
|
|
4520
4903
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
4521
4904
|
* * This is useful for interfacing with CIP30
|
|
4522
4905
|
*
|
|
@@ -4683,6 +5066,13 @@ export class GovAction {
|
|
|
4683
5066
|
to_cbor_bytes(): Uint8Array;
|
|
4684
5067
|
/**
|
|
4685
5068
|
*
|
|
5069
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
5070
|
+
*
|
|
5071
|
+
* @returns {Uint8Array}
|
|
5072
|
+
*/
|
|
5073
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
5074
|
+
/**
|
|
5075
|
+
*
|
|
4686
5076
|
* * Create this type from CBOR bytes
|
|
4687
5077
|
*
|
|
4688
5078
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -4700,6 +5090,13 @@ export class GovAction {
|
|
|
4700
5090
|
to_cbor_hex(): string;
|
|
4701
5091
|
/**
|
|
4702
5092
|
*
|
|
5093
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
5094
|
+
*
|
|
5095
|
+
* @returns {string}
|
|
5096
|
+
*/
|
|
5097
|
+
to_canonical_cbor_hex(): string;
|
|
5098
|
+
/**
|
|
5099
|
+
*
|
|
4703
5100
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
4704
5101
|
* * This is useful for interfacing with CIP30
|
|
4705
5102
|
*
|
|
@@ -4806,6 +5203,13 @@ export class GovActionId {
|
|
|
4806
5203
|
to_cbor_bytes(): Uint8Array;
|
|
4807
5204
|
/**
|
|
4808
5205
|
*
|
|
5206
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
5207
|
+
*
|
|
5208
|
+
* @returns {Uint8Array}
|
|
5209
|
+
*/
|
|
5210
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
5211
|
+
/**
|
|
5212
|
+
*
|
|
4809
5213
|
* * Create this type from CBOR bytes
|
|
4810
5214
|
*
|
|
4811
5215
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -4823,6 +5227,13 @@ export class GovActionId {
|
|
|
4823
5227
|
to_cbor_hex(): string;
|
|
4824
5228
|
/**
|
|
4825
5229
|
*
|
|
5230
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
5231
|
+
*
|
|
5232
|
+
* @returns {string}
|
|
5233
|
+
*/
|
|
5234
|
+
to_canonical_cbor_hex(): string;
|
|
5235
|
+
/**
|
|
5236
|
+
*
|
|
4826
5237
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
4827
5238
|
* * This is useful for interfacing with CIP30
|
|
4828
5239
|
*
|
|
@@ -4939,6 +5350,13 @@ export class HardForkInitiationAction {
|
|
|
4939
5350
|
to_cbor_bytes(): Uint8Array;
|
|
4940
5351
|
/**
|
|
4941
5352
|
*
|
|
5353
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
5354
|
+
*
|
|
5355
|
+
* @returns {Uint8Array}
|
|
5356
|
+
*/
|
|
5357
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
5358
|
+
/**
|
|
5359
|
+
*
|
|
4942
5360
|
* * Create this type from CBOR bytes
|
|
4943
5361
|
*
|
|
4944
5362
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -4956,6 +5374,13 @@ export class HardForkInitiationAction {
|
|
|
4956
5374
|
to_cbor_hex(): string;
|
|
4957
5375
|
/**
|
|
4958
5376
|
*
|
|
5377
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
5378
|
+
*
|
|
5379
|
+
* @returns {string}
|
|
5380
|
+
*/
|
|
5381
|
+
to_canonical_cbor_hex(): string;
|
|
5382
|
+
/**
|
|
5383
|
+
*
|
|
4959
5384
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
4960
5385
|
* * This is useful for interfacing with CIP30
|
|
4961
5386
|
*
|
|
@@ -5006,6 +5431,13 @@ export class Header {
|
|
|
5006
5431
|
to_cbor_bytes(): Uint8Array;
|
|
5007
5432
|
/**
|
|
5008
5433
|
*
|
|
5434
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
5435
|
+
*
|
|
5436
|
+
* @returns {Uint8Array}
|
|
5437
|
+
*/
|
|
5438
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
5439
|
+
/**
|
|
5440
|
+
*
|
|
5009
5441
|
* * Create this type from CBOR bytes
|
|
5010
5442
|
*
|
|
5011
5443
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -5023,6 +5455,13 @@ export class Header {
|
|
|
5023
5455
|
to_cbor_hex(): string;
|
|
5024
5456
|
/**
|
|
5025
5457
|
*
|
|
5458
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
5459
|
+
*
|
|
5460
|
+
* @returns {string}
|
|
5461
|
+
*/
|
|
5462
|
+
to_canonical_cbor_hex(): string;
|
|
5463
|
+
/**
|
|
5464
|
+
*
|
|
5026
5465
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
5027
5466
|
* * This is useful for interfacing with CIP30
|
|
5028
5467
|
*
|
|
@@ -5073,6 +5512,13 @@ export class HeaderBody {
|
|
|
5073
5512
|
to_cbor_bytes(): Uint8Array;
|
|
5074
5513
|
/**
|
|
5075
5514
|
*
|
|
5515
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
5516
|
+
*
|
|
5517
|
+
* @returns {Uint8Array}
|
|
5518
|
+
*/
|
|
5519
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
5520
|
+
/**
|
|
5521
|
+
*
|
|
5076
5522
|
* * Create this type from CBOR bytes
|
|
5077
5523
|
*
|
|
5078
5524
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -5090,6 +5536,13 @@ export class HeaderBody {
|
|
|
5090
5536
|
to_cbor_hex(): string;
|
|
5091
5537
|
/**
|
|
5092
5538
|
*
|
|
5539
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
5540
|
+
*
|
|
5541
|
+
* @returns {string}
|
|
5542
|
+
*/
|
|
5543
|
+
to_canonical_cbor_hex(): string;
|
|
5544
|
+
/**
|
|
5545
|
+
*
|
|
5093
5546
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
5094
5547
|
* * This is useful for interfacing with CIP30
|
|
5095
5548
|
*
|
|
@@ -5257,6 +5710,13 @@ export class Ipv4 {
|
|
|
5257
5710
|
to_cbor_bytes(): Uint8Array;
|
|
5258
5711
|
/**
|
|
5259
5712
|
*
|
|
5713
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
5714
|
+
*
|
|
5715
|
+
* @returns {Uint8Array}
|
|
5716
|
+
*/
|
|
5717
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
5718
|
+
/**
|
|
5719
|
+
*
|
|
5260
5720
|
* * Create this type from CBOR bytes
|
|
5261
5721
|
*
|
|
5262
5722
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -5274,6 +5734,13 @@ export class Ipv4 {
|
|
|
5274
5734
|
to_cbor_hex(): string;
|
|
5275
5735
|
/**
|
|
5276
5736
|
*
|
|
5737
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
5738
|
+
*
|
|
5739
|
+
* @returns {string}
|
|
5740
|
+
*/
|
|
5741
|
+
to_canonical_cbor_hex(): string;
|
|
5742
|
+
/**
|
|
5743
|
+
*
|
|
5277
5744
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
5278
5745
|
* * This is useful for interfacing with CIP30
|
|
5279
5746
|
*
|
|
@@ -5314,6 +5781,13 @@ export class Ipv6 {
|
|
|
5314
5781
|
to_cbor_bytes(): Uint8Array;
|
|
5315
5782
|
/**
|
|
5316
5783
|
*
|
|
5784
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
5785
|
+
*
|
|
5786
|
+
* @returns {Uint8Array}
|
|
5787
|
+
*/
|
|
5788
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
5789
|
+
/**
|
|
5790
|
+
*
|
|
5317
5791
|
* * Create this type from CBOR bytes
|
|
5318
5792
|
*
|
|
5319
5793
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -5331,6 +5805,13 @@ export class Ipv6 {
|
|
|
5331
5805
|
to_cbor_hex(): string;
|
|
5332
5806
|
/**
|
|
5333
5807
|
*
|
|
5808
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
5809
|
+
*
|
|
5810
|
+
* @returns {string}
|
|
5811
|
+
*/
|
|
5812
|
+
to_canonical_cbor_hex(): string;
|
|
5813
|
+
/**
|
|
5814
|
+
*
|
|
5334
5815
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
5335
5816
|
* * This is useful for interfacing with CIP30
|
|
5336
5817
|
*
|
|
@@ -5371,6 +5852,13 @@ export class KESSignature {
|
|
|
5371
5852
|
to_cbor_bytes(): Uint8Array;
|
|
5372
5853
|
/**
|
|
5373
5854
|
*
|
|
5855
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
5856
|
+
*
|
|
5857
|
+
* @returns {Uint8Array}
|
|
5858
|
+
*/
|
|
5859
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
5860
|
+
/**
|
|
5861
|
+
*
|
|
5374
5862
|
* * Create this type from CBOR bytes
|
|
5375
5863
|
*
|
|
5376
5864
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -5388,6 +5876,13 @@ export class KESSignature {
|
|
|
5388
5876
|
to_cbor_hex(): string;
|
|
5389
5877
|
/**
|
|
5390
5878
|
*
|
|
5879
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
5880
|
+
*
|
|
5881
|
+
* @returns {string}
|
|
5882
|
+
*/
|
|
5883
|
+
to_canonical_cbor_hex(): string;
|
|
5884
|
+
/**
|
|
5885
|
+
*
|
|
5391
5886
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
5392
5887
|
* * This is useful for interfacing with CIP30
|
|
5393
5888
|
*
|
|
@@ -5504,6 +5999,13 @@ export class LegacyRedeemer {
|
|
|
5504
5999
|
to_cbor_bytes(): Uint8Array;
|
|
5505
6000
|
/**
|
|
5506
6001
|
*
|
|
6002
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
6003
|
+
*
|
|
6004
|
+
* @returns {Uint8Array}
|
|
6005
|
+
*/
|
|
6006
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
6007
|
+
/**
|
|
6008
|
+
*
|
|
5507
6009
|
* * Create this type from CBOR bytes
|
|
5508
6010
|
*
|
|
5509
6011
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -5521,6 +6023,13 @@ export class LegacyRedeemer {
|
|
|
5521
6023
|
to_cbor_hex(): string;
|
|
5522
6024
|
/**
|
|
5523
6025
|
*
|
|
6026
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
6027
|
+
*
|
|
6028
|
+
* @returns {string}
|
|
6029
|
+
*/
|
|
6030
|
+
to_canonical_cbor_hex(): string;
|
|
6031
|
+
/**
|
|
6032
|
+
*
|
|
5524
6033
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
5525
6034
|
* * This is useful for interfacing with CIP30
|
|
5526
6035
|
*
|
|
@@ -5595,19 +6104,31 @@ export class LegacyRedeemerList {
|
|
|
5595
6104
|
export class LinearFee {
|
|
5596
6105
|
free(): void;
|
|
5597
6106
|
/**
|
|
6107
|
+
*
|
|
6108
|
+
* * * `coefficient` - minfee_a from protocol params
|
|
6109
|
+
* * * `constant` - minfee_b from protocol params
|
|
6110
|
+
* * * `ref_script_cost_per_bytes` - min_fee_ref_script_cost_per_byte from protocol params. New in Conway
|
|
6111
|
+
*
|
|
5598
6112
|
* @param {bigint} coefficient
|
|
5599
6113
|
* @param {bigint} constant
|
|
6114
|
+
* @param {bigint} ref_script_cost_per_byte
|
|
5600
6115
|
* @returns {LinearFee}
|
|
5601
6116
|
*/
|
|
5602
|
-
static new(coefficient: bigint, constant: bigint): LinearFee;
|
|
6117
|
+
static new(coefficient: bigint, constant: bigint, ref_script_cost_per_byte: bigint): LinearFee;
|
|
6118
|
+
/**
|
|
6119
|
+
* minfee_a
|
|
6120
|
+
* @returns {bigint}
|
|
6121
|
+
*/
|
|
6122
|
+
coefficient(): bigint;
|
|
5603
6123
|
/**
|
|
6124
|
+
* minfee_b
|
|
5604
6125
|
* @returns {bigint}
|
|
5605
6126
|
*/
|
|
5606
6127
|
constant(): bigint;
|
|
5607
6128
|
/**
|
|
5608
6129
|
* @returns {bigint}
|
|
5609
6130
|
*/
|
|
5610
|
-
|
|
6131
|
+
ref_script_cost_per_byte(): bigint;
|
|
5611
6132
|
}
|
|
5612
6133
|
/**
|
|
5613
6134
|
*/
|
|
@@ -6208,6 +6729,13 @@ export class MultiHostName {
|
|
|
6208
6729
|
to_cbor_bytes(): Uint8Array;
|
|
6209
6730
|
/**
|
|
6210
6731
|
*
|
|
6732
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
6733
|
+
*
|
|
6734
|
+
* @returns {Uint8Array}
|
|
6735
|
+
*/
|
|
6736
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
6737
|
+
/**
|
|
6738
|
+
*
|
|
6211
6739
|
* * Create this type from CBOR bytes
|
|
6212
6740
|
*
|
|
6213
6741
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -6225,6 +6753,13 @@ export class MultiHostName {
|
|
|
6225
6753
|
to_cbor_hex(): string;
|
|
6226
6754
|
/**
|
|
6227
6755
|
*
|
|
6756
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
6757
|
+
*
|
|
6758
|
+
* @returns {string}
|
|
6759
|
+
*/
|
|
6760
|
+
to_canonical_cbor_hex(): string;
|
|
6761
|
+
/**
|
|
6762
|
+
*
|
|
6228
6763
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
6229
6764
|
* * This is useful for interfacing with CIP30
|
|
6230
6765
|
*
|
|
@@ -6289,6 +6824,13 @@ export class NativeScript {
|
|
|
6289
6824
|
to_cbor_bytes(): Uint8Array;
|
|
6290
6825
|
/**
|
|
6291
6826
|
*
|
|
6827
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
6828
|
+
*
|
|
6829
|
+
* @returns {Uint8Array}
|
|
6830
|
+
*/
|
|
6831
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
6832
|
+
/**
|
|
6833
|
+
*
|
|
6292
6834
|
* * Create this type from CBOR bytes
|
|
6293
6835
|
*
|
|
6294
6836
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -6306,6 +6848,13 @@ export class NativeScript {
|
|
|
6306
6848
|
to_cbor_hex(): string;
|
|
6307
6849
|
/**
|
|
6308
6850
|
*
|
|
6851
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
6852
|
+
*
|
|
6853
|
+
* @returns {string}
|
|
6854
|
+
*/
|
|
6855
|
+
to_canonical_cbor_hex(): string;
|
|
6856
|
+
/**
|
|
6857
|
+
*
|
|
6309
6858
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
6310
6859
|
* * This is useful for interfacing with CIP30
|
|
6311
6860
|
*
|
|
@@ -6447,6 +6996,13 @@ export class NetworkId {
|
|
|
6447
6996
|
to_cbor_bytes(): Uint8Array;
|
|
6448
6997
|
/**
|
|
6449
6998
|
*
|
|
6999
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
7000
|
+
*
|
|
7001
|
+
* @returns {Uint8Array}
|
|
7002
|
+
*/
|
|
7003
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
7004
|
+
/**
|
|
7005
|
+
*
|
|
6450
7006
|
* * Create this type from CBOR bytes
|
|
6451
7007
|
*
|
|
6452
7008
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -6464,6 +7020,13 @@ export class NetworkId {
|
|
|
6464
7020
|
to_cbor_hex(): string;
|
|
6465
7021
|
/**
|
|
6466
7022
|
*
|
|
7023
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
7024
|
+
*
|
|
7025
|
+
* @returns {string}
|
|
7026
|
+
*/
|
|
7027
|
+
to_canonical_cbor_hex(): string;
|
|
7028
|
+
/**
|
|
7029
|
+
*
|
|
6467
7030
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
6468
7031
|
* * This is useful for interfacing with CIP30
|
|
6469
7032
|
*
|
|
@@ -6557,6 +7120,13 @@ export class NewConstitution {
|
|
|
6557
7120
|
to_cbor_bytes(): Uint8Array;
|
|
6558
7121
|
/**
|
|
6559
7122
|
*
|
|
7123
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
7124
|
+
*
|
|
7125
|
+
* @returns {Uint8Array}
|
|
7126
|
+
*/
|
|
7127
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
7128
|
+
/**
|
|
7129
|
+
*
|
|
6560
7130
|
* * Create this type from CBOR bytes
|
|
6561
7131
|
*
|
|
6562
7132
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -6574,6 +7144,13 @@ export class NewConstitution {
|
|
|
6574
7144
|
to_cbor_hex(): string;
|
|
6575
7145
|
/**
|
|
6576
7146
|
*
|
|
7147
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
7148
|
+
*
|
|
7149
|
+
* @returns {string}
|
|
7150
|
+
*/
|
|
7151
|
+
to_canonical_cbor_hex(): string;
|
|
7152
|
+
/**
|
|
7153
|
+
*
|
|
6577
7154
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
6578
7155
|
* * This is useful for interfacing with CIP30
|
|
6579
7156
|
*
|
|
@@ -6624,6 +7201,13 @@ export class NoConfidence {
|
|
|
6624
7201
|
to_cbor_bytes(): Uint8Array;
|
|
6625
7202
|
/**
|
|
6626
7203
|
*
|
|
7204
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
7205
|
+
*
|
|
7206
|
+
* @returns {Uint8Array}
|
|
7207
|
+
*/
|
|
7208
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
7209
|
+
/**
|
|
7210
|
+
*
|
|
6627
7211
|
* * Create this type from CBOR bytes
|
|
6628
7212
|
*
|
|
6629
7213
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -6641,6 +7225,13 @@ export class NoConfidence {
|
|
|
6641
7225
|
to_cbor_hex(): string;
|
|
6642
7226
|
/**
|
|
6643
7227
|
*
|
|
7228
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
7229
|
+
*
|
|
7230
|
+
* @returns {string}
|
|
7231
|
+
*/
|
|
7232
|
+
to_canonical_cbor_hex(): string;
|
|
7233
|
+
/**
|
|
7234
|
+
*
|
|
6644
7235
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
6645
7236
|
* * This is useful for interfacing with CIP30
|
|
6646
7237
|
*
|
|
@@ -6686,6 +7277,13 @@ export class Nonce {
|
|
|
6686
7277
|
to_cbor_bytes(): Uint8Array;
|
|
6687
7278
|
/**
|
|
6688
7279
|
*
|
|
7280
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
7281
|
+
*
|
|
7282
|
+
* @returns {Uint8Array}
|
|
7283
|
+
*/
|
|
7284
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
7285
|
+
/**
|
|
7286
|
+
*
|
|
6689
7287
|
* * Create this type from CBOR bytes
|
|
6690
7288
|
*
|
|
6691
7289
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -6703,6 +7301,13 @@ export class Nonce {
|
|
|
6703
7301
|
to_cbor_hex(): string;
|
|
6704
7302
|
/**
|
|
6705
7303
|
*
|
|
7304
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
7305
|
+
*
|
|
7306
|
+
* @returns {string}
|
|
7307
|
+
*/
|
|
7308
|
+
to_canonical_cbor_hex(): string;
|
|
7309
|
+
/**
|
|
7310
|
+
*
|
|
6706
7311
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
6707
7312
|
* * This is useful for interfacing with CIP30
|
|
6708
7313
|
*
|
|
@@ -6801,6 +7406,13 @@ export class OperationalCert {
|
|
|
6801
7406
|
to_cbor_bytes(): Uint8Array;
|
|
6802
7407
|
/**
|
|
6803
7408
|
*
|
|
7409
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
7410
|
+
*
|
|
7411
|
+
* @returns {Uint8Array}
|
|
7412
|
+
*/
|
|
7413
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
7414
|
+
/**
|
|
7415
|
+
*
|
|
6804
7416
|
* * Create this type from CBOR bytes
|
|
6805
7417
|
*
|
|
6806
7418
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -6818,6 +7430,13 @@ export class OperationalCert {
|
|
|
6818
7430
|
to_cbor_hex(): string;
|
|
6819
7431
|
/**
|
|
6820
7432
|
*
|
|
7433
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
7434
|
+
*
|
|
7435
|
+
* @returns {string}
|
|
7436
|
+
*/
|
|
7437
|
+
to_canonical_cbor_hex(): string;
|
|
7438
|
+
/**
|
|
7439
|
+
*
|
|
6821
7440
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
6822
7441
|
* * This is useful for interfacing with CIP30
|
|
6823
7442
|
*
|
|
@@ -6878,6 +7497,13 @@ export class ParameterChangeAction {
|
|
|
6878
7497
|
to_cbor_bytes(): Uint8Array;
|
|
6879
7498
|
/**
|
|
6880
7499
|
*
|
|
7500
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
7501
|
+
*
|
|
7502
|
+
* @returns {Uint8Array}
|
|
7503
|
+
*/
|
|
7504
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
7505
|
+
/**
|
|
7506
|
+
*
|
|
6881
7507
|
* * Create this type from CBOR bytes
|
|
6882
7508
|
*
|
|
6883
7509
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -6895,6 +7521,13 @@ export class ParameterChangeAction {
|
|
|
6895
7521
|
to_cbor_hex(): string;
|
|
6896
7522
|
/**
|
|
6897
7523
|
*
|
|
7524
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
7525
|
+
*
|
|
7526
|
+
* @returns {string}
|
|
7527
|
+
*/
|
|
7528
|
+
to_canonical_cbor_hex(): string;
|
|
7529
|
+
/**
|
|
7530
|
+
*
|
|
6898
7531
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
6899
7532
|
* * This is useful for interfacing with CIP30
|
|
6900
7533
|
*
|
|
@@ -6973,6 +7606,13 @@ export class PlutusData {
|
|
|
6973
7606
|
to_cbor_bytes(): Uint8Array;
|
|
6974
7607
|
/**
|
|
6975
7608
|
*
|
|
7609
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
7610
|
+
*
|
|
7611
|
+
* @returns {Uint8Array}
|
|
7612
|
+
*/
|
|
7613
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
7614
|
+
/**
|
|
7615
|
+
*
|
|
6976
7616
|
* * Create this type from CBOR bytes
|
|
6977
7617
|
*
|
|
6978
7618
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -6990,6 +7630,13 @@ export class PlutusData {
|
|
|
6990
7630
|
to_cbor_hex(): string;
|
|
6991
7631
|
/**
|
|
6992
7632
|
*
|
|
7633
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
7634
|
+
*
|
|
7635
|
+
* @returns {string}
|
|
7636
|
+
*/
|
|
7637
|
+
to_canonical_cbor_hex(): string;
|
|
7638
|
+
/**
|
|
7639
|
+
*
|
|
6993
7640
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
6994
7641
|
* * This is useful for interfacing with CIP30
|
|
6995
7642
|
*
|
|
@@ -7097,6 +7744,13 @@ export class PlutusMap {
|
|
|
7097
7744
|
to_cbor_bytes(): Uint8Array;
|
|
7098
7745
|
/**
|
|
7099
7746
|
*
|
|
7747
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
7748
|
+
*
|
|
7749
|
+
* @returns {Uint8Array}
|
|
7750
|
+
*/
|
|
7751
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
7752
|
+
/**
|
|
7753
|
+
*
|
|
7100
7754
|
* * Create this type from CBOR bytes
|
|
7101
7755
|
*
|
|
7102
7756
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -7114,6 +7768,13 @@ export class PlutusMap {
|
|
|
7114
7768
|
to_cbor_hex(): string;
|
|
7115
7769
|
/**
|
|
7116
7770
|
*
|
|
7771
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
7772
|
+
*
|
|
7773
|
+
* @returns {string}
|
|
7774
|
+
*/
|
|
7775
|
+
to_canonical_cbor_hex(): string;
|
|
7776
|
+
/**
|
|
7777
|
+
*
|
|
7117
7778
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
7118
7779
|
* * This is useful for interfacing with CIP30
|
|
7119
7780
|
*
|
|
@@ -7267,6 +7928,13 @@ export class PlutusV1Script {
|
|
|
7267
7928
|
to_cbor_bytes(): Uint8Array;
|
|
7268
7929
|
/**
|
|
7269
7930
|
*
|
|
7931
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
7932
|
+
*
|
|
7933
|
+
* @returns {Uint8Array}
|
|
7934
|
+
*/
|
|
7935
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
7936
|
+
/**
|
|
7937
|
+
*
|
|
7270
7938
|
* * Create this type from CBOR bytes
|
|
7271
7939
|
*
|
|
7272
7940
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -7284,6 +7952,13 @@ export class PlutusV1Script {
|
|
|
7284
7952
|
to_cbor_hex(): string;
|
|
7285
7953
|
/**
|
|
7286
7954
|
*
|
|
7955
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
7956
|
+
*
|
|
7957
|
+
* @returns {string}
|
|
7958
|
+
*/
|
|
7959
|
+
to_canonical_cbor_hex(): string;
|
|
7960
|
+
/**
|
|
7961
|
+
*
|
|
7287
7962
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
7288
7963
|
* * This is useful for interfacing with CIP30
|
|
7289
7964
|
*
|
|
@@ -7376,6 +8051,13 @@ export class PlutusV2Script {
|
|
|
7376
8051
|
to_cbor_bytes(): Uint8Array;
|
|
7377
8052
|
/**
|
|
7378
8053
|
*
|
|
8054
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
8055
|
+
*
|
|
8056
|
+
* @returns {Uint8Array}
|
|
8057
|
+
*/
|
|
8058
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
8059
|
+
/**
|
|
8060
|
+
*
|
|
7379
8061
|
* * Create this type from CBOR bytes
|
|
7380
8062
|
*
|
|
7381
8063
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -7393,6 +8075,13 @@ export class PlutusV2Script {
|
|
|
7393
8075
|
to_cbor_hex(): string;
|
|
7394
8076
|
/**
|
|
7395
8077
|
*
|
|
8078
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
8079
|
+
*
|
|
8080
|
+
* @returns {string}
|
|
8081
|
+
*/
|
|
8082
|
+
to_canonical_cbor_hex(): string;
|
|
8083
|
+
/**
|
|
8084
|
+
*
|
|
7396
8085
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
7397
8086
|
* * This is useful for interfacing with CIP30
|
|
7398
8087
|
*
|
|
@@ -7485,6 +8174,13 @@ export class PlutusV3Script {
|
|
|
7485
8174
|
to_cbor_bytes(): Uint8Array;
|
|
7486
8175
|
/**
|
|
7487
8176
|
*
|
|
8177
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
8178
|
+
*
|
|
8179
|
+
* @returns {Uint8Array}
|
|
8180
|
+
*/
|
|
8181
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
8182
|
+
/**
|
|
8183
|
+
*
|
|
7488
8184
|
* * Create this type from CBOR bytes
|
|
7489
8185
|
*
|
|
7490
8186
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -7502,6 +8198,13 @@ export class PlutusV3Script {
|
|
|
7502
8198
|
to_cbor_hex(): string;
|
|
7503
8199
|
/**
|
|
7504
8200
|
*
|
|
8201
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
8202
|
+
*
|
|
8203
|
+
* @returns {string}
|
|
8204
|
+
*/
|
|
8205
|
+
to_canonical_cbor_hex(): string;
|
|
8206
|
+
/**
|
|
8207
|
+
*
|
|
7505
8208
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
7506
8209
|
* * This is useful for interfacing with CIP30
|
|
7507
8210
|
*
|
|
@@ -7620,6 +8323,13 @@ export class PoolMetadata {
|
|
|
7620
8323
|
to_cbor_bytes(): Uint8Array;
|
|
7621
8324
|
/**
|
|
7622
8325
|
*
|
|
8326
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
8327
|
+
*
|
|
8328
|
+
* @returns {Uint8Array}
|
|
8329
|
+
*/
|
|
8330
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
8331
|
+
/**
|
|
8332
|
+
*
|
|
7623
8333
|
* * Create this type from CBOR bytes
|
|
7624
8334
|
*
|
|
7625
8335
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -7637,6 +8347,13 @@ export class PoolMetadata {
|
|
|
7637
8347
|
to_cbor_hex(): string;
|
|
7638
8348
|
/**
|
|
7639
8349
|
*
|
|
8350
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
8351
|
+
*
|
|
8352
|
+
* @returns {string}
|
|
8353
|
+
*/
|
|
8354
|
+
to_canonical_cbor_hex(): string;
|
|
8355
|
+
/**
|
|
8356
|
+
*
|
|
7640
8357
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
7641
8358
|
* * This is useful for interfacing with CIP30
|
|
7642
8359
|
*
|
|
@@ -7732,6 +8449,13 @@ export class PoolParams {
|
|
|
7732
8449
|
to_cbor_bytes(): Uint8Array;
|
|
7733
8450
|
/**
|
|
7734
8451
|
*
|
|
8452
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
8453
|
+
*
|
|
8454
|
+
* @returns {Uint8Array}
|
|
8455
|
+
*/
|
|
8456
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
8457
|
+
/**
|
|
8458
|
+
*
|
|
7735
8459
|
* * Create this type from CBOR bytes
|
|
7736
8460
|
*
|
|
7737
8461
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -7749,6 +8473,13 @@ export class PoolParams {
|
|
|
7749
8473
|
to_cbor_hex(): string;
|
|
7750
8474
|
/**
|
|
7751
8475
|
*
|
|
8476
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
8477
|
+
*
|
|
8478
|
+
* @returns {string}
|
|
8479
|
+
*/
|
|
8480
|
+
to_canonical_cbor_hex(): string;
|
|
8481
|
+
/**
|
|
8482
|
+
*
|
|
7752
8483
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
7753
8484
|
* * This is useful for interfacing with CIP30
|
|
7754
8485
|
*
|
|
@@ -7834,6 +8565,13 @@ export class PoolRegistration {
|
|
|
7834
8565
|
to_cbor_bytes(): Uint8Array;
|
|
7835
8566
|
/**
|
|
7836
8567
|
*
|
|
8568
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
8569
|
+
*
|
|
8570
|
+
* @returns {Uint8Array}
|
|
8571
|
+
*/
|
|
8572
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
8573
|
+
/**
|
|
8574
|
+
*
|
|
7837
8575
|
* * Create this type from CBOR bytes
|
|
7838
8576
|
*
|
|
7839
8577
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -7851,6 +8589,13 @@ export class PoolRegistration {
|
|
|
7851
8589
|
to_cbor_hex(): string;
|
|
7852
8590
|
/**
|
|
7853
8591
|
*
|
|
8592
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
8593
|
+
*
|
|
8594
|
+
* @returns {string}
|
|
8595
|
+
*/
|
|
8596
|
+
to_canonical_cbor_hex(): string;
|
|
8597
|
+
/**
|
|
8598
|
+
*
|
|
7854
8599
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
7855
8600
|
* * This is useful for interfacing with CIP30
|
|
7856
8601
|
*
|
|
@@ -7896,6 +8641,13 @@ export class PoolRetirement {
|
|
|
7896
8641
|
to_cbor_bytes(): Uint8Array;
|
|
7897
8642
|
/**
|
|
7898
8643
|
*
|
|
8644
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
8645
|
+
*
|
|
8646
|
+
* @returns {Uint8Array}
|
|
8647
|
+
*/
|
|
8648
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
8649
|
+
/**
|
|
8650
|
+
*
|
|
7899
8651
|
* * Create this type from CBOR bytes
|
|
7900
8652
|
*
|
|
7901
8653
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -7913,6 +8665,13 @@ export class PoolRetirement {
|
|
|
7913
8665
|
to_cbor_hex(): string;
|
|
7914
8666
|
/**
|
|
7915
8667
|
*
|
|
8668
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
8669
|
+
*
|
|
8670
|
+
* @returns {string}
|
|
8671
|
+
*/
|
|
8672
|
+
to_canonical_cbor_hex(): string;
|
|
8673
|
+
/**
|
|
8674
|
+
*
|
|
7916
8675
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
7917
8676
|
* * This is useful for interfacing with CIP30
|
|
7918
8677
|
*
|
|
@@ -7963,6 +8722,13 @@ export class PoolVotingThresholds {
|
|
|
7963
8722
|
to_cbor_bytes(): Uint8Array;
|
|
7964
8723
|
/**
|
|
7965
8724
|
*
|
|
8725
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
8726
|
+
*
|
|
8727
|
+
* @returns {Uint8Array}
|
|
8728
|
+
*/
|
|
8729
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
8730
|
+
/**
|
|
8731
|
+
*
|
|
7966
8732
|
* * Create this type from CBOR bytes
|
|
7967
8733
|
*
|
|
7968
8734
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -7980,6 +8746,13 @@ export class PoolVotingThresholds {
|
|
|
7980
8746
|
to_cbor_hex(): string;
|
|
7981
8747
|
/**
|
|
7982
8748
|
*
|
|
8749
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
8750
|
+
*
|
|
8751
|
+
* @returns {string}
|
|
8752
|
+
*/
|
|
8753
|
+
to_canonical_cbor_hex(): string;
|
|
8754
|
+
/**
|
|
8755
|
+
*
|
|
7983
8756
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
7984
8757
|
* * This is useful for interfacing with CIP30
|
|
7985
8758
|
*
|
|
@@ -8143,6 +8916,13 @@ export class ProposalProcedure {
|
|
|
8143
8916
|
to_cbor_bytes(): Uint8Array;
|
|
8144
8917
|
/**
|
|
8145
8918
|
*
|
|
8919
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
8920
|
+
*
|
|
8921
|
+
* @returns {Uint8Array}
|
|
8922
|
+
*/
|
|
8923
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
8924
|
+
/**
|
|
8925
|
+
*
|
|
8146
8926
|
* * Create this type from CBOR bytes
|
|
8147
8927
|
*
|
|
8148
8928
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -8160,6 +8940,13 @@ export class ProposalProcedure {
|
|
|
8160
8940
|
to_cbor_hex(): string;
|
|
8161
8941
|
/**
|
|
8162
8942
|
*
|
|
8943
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
8944
|
+
*
|
|
8945
|
+
* @returns {string}
|
|
8946
|
+
*/
|
|
8947
|
+
to_canonical_cbor_hex(): string;
|
|
8948
|
+
/**
|
|
8949
|
+
*
|
|
8163
8950
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
8164
8951
|
* * This is useful for interfacing with CIP30
|
|
8165
8952
|
*
|
|
@@ -8256,6 +9043,13 @@ export class ProtocolParamUpdate {
|
|
|
8256
9043
|
to_cbor_bytes(): Uint8Array;
|
|
8257
9044
|
/**
|
|
8258
9045
|
*
|
|
9046
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
9047
|
+
*
|
|
9048
|
+
* @returns {Uint8Array}
|
|
9049
|
+
*/
|
|
9050
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
9051
|
+
/**
|
|
9052
|
+
*
|
|
8259
9053
|
* * Create this type from CBOR bytes
|
|
8260
9054
|
*
|
|
8261
9055
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -8273,6 +9067,13 @@ export class ProtocolParamUpdate {
|
|
|
8273
9067
|
to_cbor_hex(): string;
|
|
8274
9068
|
/**
|
|
8275
9069
|
*
|
|
9070
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
9071
|
+
*
|
|
9072
|
+
* @returns {string}
|
|
9073
|
+
*/
|
|
9074
|
+
to_canonical_cbor_hex(): string;
|
|
9075
|
+
/**
|
|
9076
|
+
*
|
|
8276
9077
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
8277
9078
|
* * This is useful for interfacing with CIP30
|
|
8278
9079
|
*
|
|
@@ -8553,6 +9354,13 @@ export class ProtocolVersion {
|
|
|
8553
9354
|
to_cbor_bytes(): Uint8Array;
|
|
8554
9355
|
/**
|
|
8555
9356
|
*
|
|
9357
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
9358
|
+
*
|
|
9359
|
+
* @returns {Uint8Array}
|
|
9360
|
+
*/
|
|
9361
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
9362
|
+
/**
|
|
9363
|
+
*
|
|
8556
9364
|
* * Create this type from CBOR bytes
|
|
8557
9365
|
*
|
|
8558
9366
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -8570,6 +9378,13 @@ export class ProtocolVersion {
|
|
|
8570
9378
|
to_cbor_hex(): string;
|
|
8571
9379
|
/**
|
|
8572
9380
|
*
|
|
9381
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
9382
|
+
*
|
|
9383
|
+
* @returns {string}
|
|
9384
|
+
*/
|
|
9385
|
+
to_canonical_cbor_hex(): string;
|
|
9386
|
+
/**
|
|
9387
|
+
*
|
|
8573
9388
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
8574
9389
|
* * This is useful for interfacing with CIP30
|
|
8575
9390
|
*
|
|
@@ -8659,6 +9474,13 @@ export class Rational {
|
|
|
8659
9474
|
to_cbor_bytes(): Uint8Array;
|
|
8660
9475
|
/**
|
|
8661
9476
|
*
|
|
9477
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
9478
|
+
*
|
|
9479
|
+
* @returns {Uint8Array}
|
|
9480
|
+
*/
|
|
9481
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
9482
|
+
/**
|
|
9483
|
+
*
|
|
8662
9484
|
* * Create this type from CBOR bytes
|
|
8663
9485
|
*
|
|
8664
9486
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -8676,6 +9498,13 @@ export class Rational {
|
|
|
8676
9498
|
to_cbor_hex(): string;
|
|
8677
9499
|
/**
|
|
8678
9500
|
*
|
|
9501
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
9502
|
+
*
|
|
9503
|
+
* @returns {string}
|
|
9504
|
+
*/
|
|
9505
|
+
to_canonical_cbor_hex(): string;
|
|
9506
|
+
/**
|
|
9507
|
+
*
|
|
8679
9508
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
8680
9509
|
* * This is useful for interfacing with CIP30
|
|
8681
9510
|
*
|
|
@@ -8726,6 +9555,13 @@ export class RedeemerKey {
|
|
|
8726
9555
|
to_cbor_bytes(): Uint8Array;
|
|
8727
9556
|
/**
|
|
8728
9557
|
*
|
|
9558
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
9559
|
+
*
|
|
9560
|
+
* @returns {Uint8Array}
|
|
9561
|
+
*/
|
|
9562
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
9563
|
+
/**
|
|
9564
|
+
*
|
|
8729
9565
|
* * Create this type from CBOR bytes
|
|
8730
9566
|
*
|
|
8731
9567
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -8743,6 +9579,13 @@ export class RedeemerKey {
|
|
|
8743
9579
|
to_cbor_hex(): string;
|
|
8744
9580
|
/**
|
|
8745
9581
|
*
|
|
9582
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
9583
|
+
*
|
|
9584
|
+
* @returns {string}
|
|
9585
|
+
*/
|
|
9586
|
+
to_canonical_cbor_hex(): string;
|
|
9587
|
+
/**
|
|
9588
|
+
*
|
|
8746
9589
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
8747
9590
|
* * This is useful for interfacing with CIP30
|
|
8748
9591
|
*
|
|
@@ -8865,6 +9708,13 @@ export class RedeemerVal {
|
|
|
8865
9708
|
to_cbor_bytes(): Uint8Array;
|
|
8866
9709
|
/**
|
|
8867
9710
|
*
|
|
9711
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
9712
|
+
*
|
|
9713
|
+
* @returns {Uint8Array}
|
|
9714
|
+
*/
|
|
9715
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
9716
|
+
/**
|
|
9717
|
+
*
|
|
8868
9718
|
* * Create this type from CBOR bytes
|
|
8869
9719
|
*
|
|
8870
9720
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -8882,6 +9732,13 @@ export class RedeemerVal {
|
|
|
8882
9732
|
to_cbor_hex(): string;
|
|
8883
9733
|
/**
|
|
8884
9734
|
*
|
|
9735
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
9736
|
+
*
|
|
9737
|
+
* @returns {string}
|
|
9738
|
+
*/
|
|
9739
|
+
to_canonical_cbor_hex(): string;
|
|
9740
|
+
/**
|
|
9741
|
+
*
|
|
8885
9742
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
8886
9743
|
* * This is useful for interfacing with CIP30
|
|
8887
9744
|
*
|
|
@@ -8952,6 +9809,13 @@ export class Redeemers {
|
|
|
8952
9809
|
to_cbor_bytes(): Uint8Array;
|
|
8953
9810
|
/**
|
|
8954
9811
|
*
|
|
9812
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
9813
|
+
*
|
|
9814
|
+
* @returns {Uint8Array}
|
|
9815
|
+
*/
|
|
9816
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
9817
|
+
/**
|
|
9818
|
+
*
|
|
8955
9819
|
* * Create this type from CBOR bytes
|
|
8956
9820
|
*
|
|
8957
9821
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -8969,6 +9833,13 @@ export class Redeemers {
|
|
|
8969
9833
|
to_cbor_hex(): string;
|
|
8970
9834
|
/**
|
|
8971
9835
|
*
|
|
9836
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
9837
|
+
*
|
|
9838
|
+
* @returns {string}
|
|
9839
|
+
*/
|
|
9840
|
+
to_canonical_cbor_hex(): string;
|
|
9841
|
+
/**
|
|
9842
|
+
*
|
|
8972
9843
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
8973
9844
|
* * This is useful for interfacing with CIP30
|
|
8974
9845
|
*
|
|
@@ -9027,6 +9898,13 @@ export class RegCert {
|
|
|
9027
9898
|
to_cbor_bytes(): Uint8Array;
|
|
9028
9899
|
/**
|
|
9029
9900
|
*
|
|
9901
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
9902
|
+
*
|
|
9903
|
+
* @returns {Uint8Array}
|
|
9904
|
+
*/
|
|
9905
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
9906
|
+
/**
|
|
9907
|
+
*
|
|
9030
9908
|
* * Create this type from CBOR bytes
|
|
9031
9909
|
*
|
|
9032
9910
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -9044,6 +9922,13 @@ export class RegCert {
|
|
|
9044
9922
|
to_cbor_hex(): string;
|
|
9045
9923
|
/**
|
|
9046
9924
|
*
|
|
9925
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
9926
|
+
*
|
|
9927
|
+
* @returns {string}
|
|
9928
|
+
*/
|
|
9929
|
+
to_canonical_cbor_hex(): string;
|
|
9930
|
+
/**
|
|
9931
|
+
*
|
|
9047
9932
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
9048
9933
|
* * This is useful for interfacing with CIP30
|
|
9049
9934
|
*
|
|
@@ -9094,6 +9979,13 @@ export class RegDrepCert {
|
|
|
9094
9979
|
to_cbor_bytes(): Uint8Array;
|
|
9095
9980
|
/**
|
|
9096
9981
|
*
|
|
9982
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
9983
|
+
*
|
|
9984
|
+
* @returns {Uint8Array}
|
|
9985
|
+
*/
|
|
9986
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
9987
|
+
/**
|
|
9988
|
+
*
|
|
9097
9989
|
* * Create this type from CBOR bytes
|
|
9098
9990
|
*
|
|
9099
9991
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -9111,6 +10003,13 @@ export class RegDrepCert {
|
|
|
9111
10003
|
to_cbor_hex(): string;
|
|
9112
10004
|
/**
|
|
9113
10005
|
*
|
|
10006
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
10007
|
+
*
|
|
10008
|
+
* @returns {string}
|
|
10009
|
+
*/
|
|
10010
|
+
to_canonical_cbor_hex(): string;
|
|
10011
|
+
/**
|
|
10012
|
+
*
|
|
9114
10013
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
9115
10014
|
* * This is useful for interfacing with CIP30
|
|
9116
10015
|
*
|
|
@@ -9166,6 +10065,13 @@ export class Relay {
|
|
|
9166
10065
|
to_cbor_bytes(): Uint8Array;
|
|
9167
10066
|
/**
|
|
9168
10067
|
*
|
|
10068
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
10069
|
+
*
|
|
10070
|
+
* @returns {Uint8Array}
|
|
10071
|
+
*/
|
|
10072
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
10073
|
+
/**
|
|
10074
|
+
*
|
|
9169
10075
|
* * Create this type from CBOR bytes
|
|
9170
10076
|
*
|
|
9171
10077
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -9183,6 +10089,13 @@ export class Relay {
|
|
|
9183
10089
|
to_cbor_hex(): string;
|
|
9184
10090
|
/**
|
|
9185
10091
|
*
|
|
10092
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
10093
|
+
*
|
|
10094
|
+
* @returns {string}
|
|
10095
|
+
*/
|
|
10096
|
+
to_canonical_cbor_hex(): string;
|
|
10097
|
+
/**
|
|
10098
|
+
*
|
|
9186
10099
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
9187
10100
|
* * This is useful for interfacing with CIP30
|
|
9188
10101
|
*
|
|
@@ -9316,6 +10229,13 @@ export class ResignCommitteeColdCert {
|
|
|
9316
10229
|
to_cbor_bytes(): Uint8Array;
|
|
9317
10230
|
/**
|
|
9318
10231
|
*
|
|
10232
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
10233
|
+
*
|
|
10234
|
+
* @returns {Uint8Array}
|
|
10235
|
+
*/
|
|
10236
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
10237
|
+
/**
|
|
10238
|
+
*
|
|
9319
10239
|
* * Create this type from CBOR bytes
|
|
9320
10240
|
*
|
|
9321
10241
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -9333,6 +10253,13 @@ export class ResignCommitteeColdCert {
|
|
|
9333
10253
|
to_cbor_hex(): string;
|
|
9334
10254
|
/**
|
|
9335
10255
|
*
|
|
10256
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
10257
|
+
*
|
|
10258
|
+
* @returns {string}
|
|
10259
|
+
*/
|
|
10260
|
+
to_canonical_cbor_hex(): string;
|
|
10261
|
+
/**
|
|
10262
|
+
*
|
|
9336
10263
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
9337
10264
|
* * This is useful for interfacing with CIP30
|
|
9338
10265
|
*
|
|
@@ -9454,6 +10381,13 @@ export class Script {
|
|
|
9454
10381
|
to_cbor_bytes(): Uint8Array;
|
|
9455
10382
|
/**
|
|
9456
10383
|
*
|
|
10384
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
10385
|
+
*
|
|
10386
|
+
* @returns {Uint8Array}
|
|
10387
|
+
*/
|
|
10388
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
10389
|
+
/**
|
|
10390
|
+
*
|
|
9457
10391
|
* * Create this type from CBOR bytes
|
|
9458
10392
|
*
|
|
9459
10393
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -9471,6 +10405,13 @@ export class Script {
|
|
|
9471
10405
|
to_cbor_hex(): string;
|
|
9472
10406
|
/**
|
|
9473
10407
|
*
|
|
10408
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
10409
|
+
*
|
|
10410
|
+
* @returns {string}
|
|
10411
|
+
*/
|
|
10412
|
+
to_canonical_cbor_hex(): string;
|
|
10413
|
+
/**
|
|
10414
|
+
*
|
|
9474
10415
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
9475
10416
|
* * This is useful for interfacing with CIP30
|
|
9476
10417
|
*
|
|
@@ -9547,6 +10488,13 @@ export class ScriptAll {
|
|
|
9547
10488
|
to_cbor_bytes(): Uint8Array;
|
|
9548
10489
|
/**
|
|
9549
10490
|
*
|
|
10491
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
10492
|
+
*
|
|
10493
|
+
* @returns {Uint8Array}
|
|
10494
|
+
*/
|
|
10495
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
10496
|
+
/**
|
|
10497
|
+
*
|
|
9550
10498
|
* * Create this type from CBOR bytes
|
|
9551
10499
|
*
|
|
9552
10500
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -9564,6 +10512,13 @@ export class ScriptAll {
|
|
|
9564
10512
|
to_cbor_hex(): string;
|
|
9565
10513
|
/**
|
|
9566
10514
|
*
|
|
10515
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
10516
|
+
*
|
|
10517
|
+
* @returns {string}
|
|
10518
|
+
*/
|
|
10519
|
+
to_canonical_cbor_hex(): string;
|
|
10520
|
+
/**
|
|
10521
|
+
*
|
|
9567
10522
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
9568
10523
|
* * This is useful for interfacing with CIP30
|
|
9569
10524
|
*
|
|
@@ -9609,6 +10564,13 @@ export class ScriptAny {
|
|
|
9609
10564
|
to_cbor_bytes(): Uint8Array;
|
|
9610
10565
|
/**
|
|
9611
10566
|
*
|
|
10567
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
10568
|
+
*
|
|
10569
|
+
* @returns {Uint8Array}
|
|
10570
|
+
*/
|
|
10571
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
10572
|
+
/**
|
|
10573
|
+
*
|
|
9612
10574
|
* * Create this type from CBOR bytes
|
|
9613
10575
|
*
|
|
9614
10576
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -9626,6 +10588,13 @@ export class ScriptAny {
|
|
|
9626
10588
|
to_cbor_hex(): string;
|
|
9627
10589
|
/**
|
|
9628
10590
|
*
|
|
10591
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
10592
|
+
*
|
|
10593
|
+
* @returns {string}
|
|
10594
|
+
*/
|
|
10595
|
+
to_canonical_cbor_hex(): string;
|
|
10596
|
+
/**
|
|
10597
|
+
*
|
|
9629
10598
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
9630
10599
|
* * This is useful for interfacing with CIP30
|
|
9631
10600
|
*
|
|
@@ -9761,6 +10730,13 @@ export class ScriptInvalidBefore {
|
|
|
9761
10730
|
to_cbor_bytes(): Uint8Array;
|
|
9762
10731
|
/**
|
|
9763
10732
|
*
|
|
10733
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
10734
|
+
*
|
|
10735
|
+
* @returns {Uint8Array}
|
|
10736
|
+
*/
|
|
10737
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
10738
|
+
/**
|
|
10739
|
+
*
|
|
9764
10740
|
* * Create this type from CBOR bytes
|
|
9765
10741
|
*
|
|
9766
10742
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -9778,6 +10754,13 @@ export class ScriptInvalidBefore {
|
|
|
9778
10754
|
to_cbor_hex(): string;
|
|
9779
10755
|
/**
|
|
9780
10756
|
*
|
|
10757
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
10758
|
+
*
|
|
10759
|
+
* @returns {string}
|
|
10760
|
+
*/
|
|
10761
|
+
to_canonical_cbor_hex(): string;
|
|
10762
|
+
/**
|
|
10763
|
+
*
|
|
9781
10764
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
9782
10765
|
* * This is useful for interfacing with CIP30
|
|
9783
10766
|
*
|
|
@@ -9823,6 +10806,13 @@ export class ScriptInvalidHereafter {
|
|
|
9823
10806
|
to_cbor_bytes(): Uint8Array;
|
|
9824
10807
|
/**
|
|
9825
10808
|
*
|
|
10809
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
10810
|
+
*
|
|
10811
|
+
* @returns {Uint8Array}
|
|
10812
|
+
*/
|
|
10813
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
10814
|
+
/**
|
|
10815
|
+
*
|
|
9826
10816
|
* * Create this type from CBOR bytes
|
|
9827
10817
|
*
|
|
9828
10818
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -9840,6 +10830,13 @@ export class ScriptInvalidHereafter {
|
|
|
9840
10830
|
to_cbor_hex(): string;
|
|
9841
10831
|
/**
|
|
9842
10832
|
*
|
|
10833
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
10834
|
+
*
|
|
10835
|
+
* @returns {string}
|
|
10836
|
+
*/
|
|
10837
|
+
to_canonical_cbor_hex(): string;
|
|
10838
|
+
/**
|
|
10839
|
+
*
|
|
9843
10840
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
9844
10841
|
* * This is useful for interfacing with CIP30
|
|
9845
10842
|
*
|
|
@@ -9885,6 +10882,13 @@ export class ScriptNOfK {
|
|
|
9885
10882
|
to_cbor_bytes(): Uint8Array;
|
|
9886
10883
|
/**
|
|
9887
10884
|
*
|
|
10885
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
10886
|
+
*
|
|
10887
|
+
* @returns {Uint8Array}
|
|
10888
|
+
*/
|
|
10889
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
10890
|
+
/**
|
|
10891
|
+
*
|
|
9888
10892
|
* * Create this type from CBOR bytes
|
|
9889
10893
|
*
|
|
9890
10894
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -9902,6 +10906,13 @@ export class ScriptNOfK {
|
|
|
9902
10906
|
to_cbor_hex(): string;
|
|
9903
10907
|
/**
|
|
9904
10908
|
*
|
|
10909
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
10910
|
+
*
|
|
10911
|
+
* @returns {string}
|
|
10912
|
+
*/
|
|
10913
|
+
to_canonical_cbor_hex(): string;
|
|
10914
|
+
/**
|
|
10915
|
+
*
|
|
9905
10916
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
9906
10917
|
* * This is useful for interfacing with CIP30
|
|
9907
10918
|
*
|
|
@@ -9952,6 +10963,13 @@ export class ScriptPubkey {
|
|
|
9952
10963
|
to_cbor_bytes(): Uint8Array;
|
|
9953
10964
|
/**
|
|
9954
10965
|
*
|
|
10966
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
10967
|
+
*
|
|
10968
|
+
* @returns {Uint8Array}
|
|
10969
|
+
*/
|
|
10970
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
10971
|
+
/**
|
|
10972
|
+
*
|
|
9955
10973
|
* * Create this type from CBOR bytes
|
|
9956
10974
|
*
|
|
9957
10975
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -9969,6 +10987,13 @@ export class ScriptPubkey {
|
|
|
9969
10987
|
to_cbor_hex(): string;
|
|
9970
10988
|
/**
|
|
9971
10989
|
*
|
|
10990
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
10991
|
+
*
|
|
10992
|
+
* @returns {string}
|
|
10993
|
+
*/
|
|
10994
|
+
to_canonical_cbor_hex(): string;
|
|
10995
|
+
/**
|
|
10996
|
+
*
|
|
9972
10997
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
9973
10998
|
* * This is useful for interfacing with CIP30
|
|
9974
10999
|
*
|
|
@@ -10014,6 +11039,13 @@ export class ShelleyMAFormatAuxData {
|
|
|
10014
11039
|
to_cbor_bytes(): Uint8Array;
|
|
10015
11040
|
/**
|
|
10016
11041
|
*
|
|
11042
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
11043
|
+
*
|
|
11044
|
+
* @returns {Uint8Array}
|
|
11045
|
+
*/
|
|
11046
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
11047
|
+
/**
|
|
11048
|
+
*
|
|
10017
11049
|
* * Create this type from CBOR bytes
|
|
10018
11050
|
*
|
|
10019
11051
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -10031,6 +11063,13 @@ export class ShelleyMAFormatAuxData {
|
|
|
10031
11063
|
to_cbor_hex(): string;
|
|
10032
11064
|
/**
|
|
10033
11065
|
*
|
|
11066
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
11067
|
+
*
|
|
11068
|
+
* @returns {string}
|
|
11069
|
+
*/
|
|
11070
|
+
to_canonical_cbor_hex(): string;
|
|
11071
|
+
/**
|
|
11072
|
+
*
|
|
10034
11073
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
10035
11074
|
* * This is useful for interfacing with CIP30
|
|
10036
11075
|
*
|
|
@@ -10175,6 +11214,13 @@ export class SingleHostAddr {
|
|
|
10175
11214
|
to_cbor_bytes(): Uint8Array;
|
|
10176
11215
|
/**
|
|
10177
11216
|
*
|
|
11217
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
11218
|
+
*
|
|
11219
|
+
* @returns {Uint8Array}
|
|
11220
|
+
*/
|
|
11221
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
11222
|
+
/**
|
|
11223
|
+
*
|
|
10178
11224
|
* * Create this type from CBOR bytes
|
|
10179
11225
|
*
|
|
10180
11226
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -10192,6 +11238,13 @@ export class SingleHostAddr {
|
|
|
10192
11238
|
to_cbor_hex(): string;
|
|
10193
11239
|
/**
|
|
10194
11240
|
*
|
|
11241
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
11242
|
+
*
|
|
11243
|
+
* @returns {string}
|
|
11244
|
+
*/
|
|
11245
|
+
to_canonical_cbor_hex(): string;
|
|
11246
|
+
/**
|
|
11247
|
+
*
|
|
10195
11248
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
10196
11249
|
* * This is useful for interfacing with CIP30
|
|
10197
11250
|
*
|
|
@@ -10244,7 +11297,14 @@ export class SingleHostName {
|
|
|
10244
11297
|
*
|
|
10245
11298
|
* @returns {Uint8Array}
|
|
10246
11299
|
*/
|
|
10247
|
-
to_cbor_bytes(): Uint8Array;
|
|
11300
|
+
to_cbor_bytes(): Uint8Array;
|
|
11301
|
+
/**
|
|
11302
|
+
*
|
|
11303
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
11304
|
+
*
|
|
11305
|
+
* @returns {Uint8Array}
|
|
11306
|
+
*/
|
|
11307
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
10248
11308
|
/**
|
|
10249
11309
|
*
|
|
10250
11310
|
* * Create this type from CBOR bytes
|
|
@@ -10264,6 +11324,13 @@ export class SingleHostName {
|
|
|
10264
11324
|
to_cbor_hex(): string;
|
|
10265
11325
|
/**
|
|
10266
11326
|
*
|
|
11327
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
11328
|
+
*
|
|
11329
|
+
* @returns {string}
|
|
11330
|
+
*/
|
|
11331
|
+
to_canonical_cbor_hex(): string;
|
|
11332
|
+
/**
|
|
11333
|
+
*
|
|
10267
11334
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
10268
11335
|
* * This is useful for interfacing with CIP30
|
|
10269
11336
|
*
|
|
@@ -10520,6 +11587,13 @@ export class StakeDelegation {
|
|
|
10520
11587
|
to_cbor_bytes(): Uint8Array;
|
|
10521
11588
|
/**
|
|
10522
11589
|
*
|
|
11590
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
11591
|
+
*
|
|
11592
|
+
* @returns {Uint8Array}
|
|
11593
|
+
*/
|
|
11594
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
11595
|
+
/**
|
|
11596
|
+
*
|
|
10523
11597
|
* * Create this type from CBOR bytes
|
|
10524
11598
|
*
|
|
10525
11599
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -10537,6 +11611,13 @@ export class StakeDelegation {
|
|
|
10537
11611
|
to_cbor_hex(): string;
|
|
10538
11612
|
/**
|
|
10539
11613
|
*
|
|
11614
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
11615
|
+
*
|
|
11616
|
+
* @returns {string}
|
|
11617
|
+
*/
|
|
11618
|
+
to_canonical_cbor_hex(): string;
|
|
11619
|
+
/**
|
|
11620
|
+
*
|
|
10540
11621
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
10541
11622
|
* * This is useful for interfacing with CIP30
|
|
10542
11623
|
*
|
|
@@ -10587,6 +11668,13 @@ export class StakeDeregistration {
|
|
|
10587
11668
|
to_cbor_bytes(): Uint8Array;
|
|
10588
11669
|
/**
|
|
10589
11670
|
*
|
|
11671
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
11672
|
+
*
|
|
11673
|
+
* @returns {Uint8Array}
|
|
11674
|
+
*/
|
|
11675
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
11676
|
+
/**
|
|
11677
|
+
*
|
|
10590
11678
|
* * Create this type from CBOR bytes
|
|
10591
11679
|
*
|
|
10592
11680
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -10604,6 +11692,13 @@ export class StakeDeregistration {
|
|
|
10604
11692
|
to_cbor_hex(): string;
|
|
10605
11693
|
/**
|
|
10606
11694
|
*
|
|
11695
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
11696
|
+
*
|
|
11697
|
+
* @returns {string}
|
|
11698
|
+
*/
|
|
11699
|
+
to_canonical_cbor_hex(): string;
|
|
11700
|
+
/**
|
|
11701
|
+
*
|
|
10607
11702
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
10608
11703
|
* * This is useful for interfacing with CIP30
|
|
10609
11704
|
*
|
|
@@ -10706,6 +11801,13 @@ export class StakeRegDelegCert {
|
|
|
10706
11801
|
to_cbor_bytes(): Uint8Array;
|
|
10707
11802
|
/**
|
|
10708
11803
|
*
|
|
11804
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
11805
|
+
*
|
|
11806
|
+
* @returns {Uint8Array}
|
|
11807
|
+
*/
|
|
11808
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
11809
|
+
/**
|
|
11810
|
+
*
|
|
10709
11811
|
* * Create this type from CBOR bytes
|
|
10710
11812
|
*
|
|
10711
11813
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -10723,6 +11825,13 @@ export class StakeRegDelegCert {
|
|
|
10723
11825
|
to_cbor_hex(): string;
|
|
10724
11826
|
/**
|
|
10725
11827
|
*
|
|
11828
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
11829
|
+
*
|
|
11830
|
+
* @returns {string}
|
|
11831
|
+
*/
|
|
11832
|
+
to_canonical_cbor_hex(): string;
|
|
11833
|
+
/**
|
|
11834
|
+
*
|
|
10726
11835
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
10727
11836
|
* * This is useful for interfacing with CIP30
|
|
10728
11837
|
*
|
|
@@ -10778,6 +11887,13 @@ export class StakeRegistration {
|
|
|
10778
11887
|
to_cbor_bytes(): Uint8Array;
|
|
10779
11888
|
/**
|
|
10780
11889
|
*
|
|
11890
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
11891
|
+
*
|
|
11892
|
+
* @returns {Uint8Array}
|
|
11893
|
+
*/
|
|
11894
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
11895
|
+
/**
|
|
11896
|
+
*
|
|
10781
11897
|
* * Create this type from CBOR bytes
|
|
10782
11898
|
*
|
|
10783
11899
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -10795,6 +11911,13 @@ export class StakeRegistration {
|
|
|
10795
11911
|
to_cbor_hex(): string;
|
|
10796
11912
|
/**
|
|
10797
11913
|
*
|
|
11914
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
11915
|
+
*
|
|
11916
|
+
* @returns {string}
|
|
11917
|
+
*/
|
|
11918
|
+
to_canonical_cbor_hex(): string;
|
|
11919
|
+
/**
|
|
11920
|
+
*
|
|
10798
11921
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
10799
11922
|
* * This is useful for interfacing with CIP30
|
|
10800
11923
|
*
|
|
@@ -10840,6 +11963,13 @@ export class StakeVoteDelegCert {
|
|
|
10840
11963
|
to_cbor_bytes(): Uint8Array;
|
|
10841
11964
|
/**
|
|
10842
11965
|
*
|
|
11966
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
11967
|
+
*
|
|
11968
|
+
* @returns {Uint8Array}
|
|
11969
|
+
*/
|
|
11970
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
11971
|
+
/**
|
|
11972
|
+
*
|
|
10843
11973
|
* * Create this type from CBOR bytes
|
|
10844
11974
|
*
|
|
10845
11975
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -10857,6 +11987,13 @@ export class StakeVoteDelegCert {
|
|
|
10857
11987
|
to_cbor_hex(): string;
|
|
10858
11988
|
/**
|
|
10859
11989
|
*
|
|
11990
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
11991
|
+
*
|
|
11992
|
+
* @returns {string}
|
|
11993
|
+
*/
|
|
11994
|
+
to_canonical_cbor_hex(): string;
|
|
11995
|
+
/**
|
|
11996
|
+
*
|
|
10860
11997
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
10861
11998
|
* * This is useful for interfacing with CIP30
|
|
10862
11999
|
*
|
|
@@ -10912,6 +12049,13 @@ export class StakeVoteRegDelegCert {
|
|
|
10912
12049
|
to_cbor_bytes(): Uint8Array;
|
|
10913
12050
|
/**
|
|
10914
12051
|
*
|
|
12052
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
12053
|
+
*
|
|
12054
|
+
* @returns {Uint8Array}
|
|
12055
|
+
*/
|
|
12056
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
12057
|
+
/**
|
|
12058
|
+
*
|
|
10915
12059
|
* * Create this type from CBOR bytes
|
|
10916
12060
|
*
|
|
10917
12061
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -10929,6 +12073,13 @@ export class StakeVoteRegDelegCert {
|
|
|
10929
12073
|
to_cbor_hex(): string;
|
|
10930
12074
|
/**
|
|
10931
12075
|
*
|
|
12076
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
12077
|
+
*
|
|
12078
|
+
* @returns {string}
|
|
12079
|
+
*/
|
|
12080
|
+
to_canonical_cbor_hex(): string;
|
|
12081
|
+
/**
|
|
12082
|
+
*
|
|
10932
12083
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
10933
12084
|
* * This is useful for interfacing with CIP30
|
|
10934
12085
|
*
|
|
@@ -11039,6 +12190,13 @@ export class Transaction {
|
|
|
11039
12190
|
to_cbor_bytes(): Uint8Array;
|
|
11040
12191
|
/**
|
|
11041
12192
|
*
|
|
12193
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
12194
|
+
*
|
|
12195
|
+
* @returns {Uint8Array}
|
|
12196
|
+
*/
|
|
12197
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
12198
|
+
/**
|
|
12199
|
+
*
|
|
11042
12200
|
* * Create this type from CBOR bytes
|
|
11043
12201
|
*
|
|
11044
12202
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -11056,6 +12214,13 @@ export class Transaction {
|
|
|
11056
12214
|
to_cbor_hex(): string;
|
|
11057
12215
|
/**
|
|
11058
12216
|
*
|
|
12217
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
12218
|
+
*
|
|
12219
|
+
* @returns {string}
|
|
12220
|
+
*/
|
|
12221
|
+
to_canonical_cbor_hex(): string;
|
|
12222
|
+
/**
|
|
12223
|
+
*
|
|
11059
12224
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
11060
12225
|
* * This is useful for interfacing with CIP30
|
|
11061
12226
|
*
|
|
@@ -11116,6 +12281,13 @@ export class TransactionBody {
|
|
|
11116
12281
|
to_cbor_bytes(): Uint8Array;
|
|
11117
12282
|
/**
|
|
11118
12283
|
*
|
|
12284
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
12285
|
+
*
|
|
12286
|
+
* @returns {Uint8Array}
|
|
12287
|
+
*/
|
|
12288
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
12289
|
+
/**
|
|
12290
|
+
*
|
|
11119
12291
|
* * Create this type from CBOR bytes
|
|
11120
12292
|
*
|
|
11121
12293
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -11133,6 +12305,13 @@ export class TransactionBody {
|
|
|
11133
12305
|
to_cbor_hex(): string;
|
|
11134
12306
|
/**
|
|
11135
12307
|
*
|
|
12308
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
12309
|
+
*
|
|
12310
|
+
* @returns {string}
|
|
12311
|
+
*/
|
|
12312
|
+
to_canonical_cbor_hex(): string;
|
|
12313
|
+
/**
|
|
12314
|
+
*
|
|
11136
12315
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
11137
12316
|
* * This is useful for interfacing with CIP30
|
|
11138
12317
|
*
|
|
@@ -11361,6 +12540,7 @@ export class TransactionBuilder {
|
|
|
11361
12540
|
*/
|
|
11362
12541
|
fee_for_input(result: InputBuilderResult): bigint;
|
|
11363
12542
|
/**
|
|
12543
|
+
* Add a reference input. Must be called BEFORE adding anything (inputs, certs, etc) that refer to this reference input.
|
|
11364
12544
|
* @param {TransactionUnspentOutput} utxo
|
|
11365
12545
|
*/
|
|
11366
12546
|
add_reference_input(utxo: TransactionUnspentOutput): void;
|
|
@@ -11669,6 +12849,13 @@ export class TransactionInput {
|
|
|
11669
12849
|
to_cbor_bytes(): Uint8Array;
|
|
11670
12850
|
/**
|
|
11671
12851
|
*
|
|
12852
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
12853
|
+
*
|
|
12854
|
+
* @returns {Uint8Array}
|
|
12855
|
+
*/
|
|
12856
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
12857
|
+
/**
|
|
12858
|
+
*
|
|
11672
12859
|
* * Create this type from CBOR bytes
|
|
11673
12860
|
*
|
|
11674
12861
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -11686,6 +12873,13 @@ export class TransactionInput {
|
|
|
11686
12873
|
to_cbor_hex(): string;
|
|
11687
12874
|
/**
|
|
11688
12875
|
*
|
|
12876
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
12877
|
+
*
|
|
12878
|
+
* @returns {string}
|
|
12879
|
+
*/
|
|
12880
|
+
to_canonical_cbor_hex(): string;
|
|
12881
|
+
/**
|
|
12882
|
+
*
|
|
11689
12883
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
11690
12884
|
* * This is useful for interfacing with CIP30
|
|
11691
12885
|
*
|
|
@@ -11913,6 +13107,13 @@ export class TransactionOutput {
|
|
|
11913
13107
|
to_cbor_bytes(): Uint8Array;
|
|
11914
13108
|
/**
|
|
11915
13109
|
*
|
|
13110
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
13111
|
+
*
|
|
13112
|
+
* @returns {Uint8Array}
|
|
13113
|
+
*/
|
|
13114
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
13115
|
+
/**
|
|
13116
|
+
*
|
|
11916
13117
|
* * Create this type from CBOR bytes
|
|
11917
13118
|
*
|
|
11918
13119
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -11930,6 +13131,13 @@ export class TransactionOutput {
|
|
|
11930
13131
|
to_cbor_hex(): string;
|
|
11931
13132
|
/**
|
|
11932
13133
|
*
|
|
13134
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
13135
|
+
*
|
|
13136
|
+
* @returns {string}
|
|
13137
|
+
*/
|
|
13138
|
+
to_canonical_cbor_hex(): string;
|
|
13139
|
+
/**
|
|
13140
|
+
*
|
|
11933
13141
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
11934
13142
|
* * This is useful for interfacing with CIP30
|
|
11935
13143
|
*
|
|
@@ -12132,6 +13340,13 @@ export class TransactionWitnessSet {
|
|
|
12132
13340
|
to_cbor_bytes(): Uint8Array;
|
|
12133
13341
|
/**
|
|
12134
13342
|
*
|
|
13343
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
13344
|
+
*
|
|
13345
|
+
* @returns {Uint8Array}
|
|
13346
|
+
*/
|
|
13347
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
13348
|
+
/**
|
|
13349
|
+
*
|
|
12135
13350
|
* * Create this type from CBOR bytes
|
|
12136
13351
|
*
|
|
12137
13352
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -12149,6 +13364,13 @@ export class TransactionWitnessSet {
|
|
|
12149
13364
|
to_cbor_hex(): string;
|
|
12150
13365
|
/**
|
|
12151
13366
|
*
|
|
13367
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
13368
|
+
*
|
|
13369
|
+
* @returns {string}
|
|
13370
|
+
*/
|
|
13371
|
+
to_canonical_cbor_hex(): string;
|
|
13372
|
+
/**
|
|
13373
|
+
*
|
|
12152
13374
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
12153
13375
|
* * This is useful for interfacing with CIP30
|
|
12154
13376
|
*
|
|
@@ -12349,6 +13571,13 @@ export class TreasuryWithdrawalsAction {
|
|
|
12349
13571
|
to_cbor_bytes(): Uint8Array;
|
|
12350
13572
|
/**
|
|
12351
13573
|
*
|
|
13574
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
13575
|
+
*
|
|
13576
|
+
* @returns {Uint8Array}
|
|
13577
|
+
*/
|
|
13578
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
13579
|
+
/**
|
|
13580
|
+
*
|
|
12352
13581
|
* * Create this type from CBOR bytes
|
|
12353
13582
|
*
|
|
12354
13583
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -12366,6 +13595,13 @@ export class TreasuryWithdrawalsAction {
|
|
|
12366
13595
|
to_cbor_hex(): string;
|
|
12367
13596
|
/**
|
|
12368
13597
|
*
|
|
13598
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
13599
|
+
*
|
|
13600
|
+
* @returns {string}
|
|
13601
|
+
*/
|
|
13602
|
+
to_canonical_cbor_hex(): string;
|
|
13603
|
+
/**
|
|
13604
|
+
*
|
|
12369
13605
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
12370
13606
|
* * This is useful for interfacing with CIP30
|
|
12371
13607
|
*
|
|
@@ -12451,6 +13687,13 @@ export class UnitInterval {
|
|
|
12451
13687
|
to_cbor_bytes(): Uint8Array;
|
|
12452
13688
|
/**
|
|
12453
13689
|
*
|
|
13690
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
13691
|
+
*
|
|
13692
|
+
* @returns {Uint8Array}
|
|
13693
|
+
*/
|
|
13694
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
13695
|
+
/**
|
|
13696
|
+
*
|
|
12454
13697
|
* * Create this type from CBOR bytes
|
|
12455
13698
|
*
|
|
12456
13699
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -12468,6 +13711,13 @@ export class UnitInterval {
|
|
|
12468
13711
|
to_cbor_hex(): string;
|
|
12469
13712
|
/**
|
|
12470
13713
|
*
|
|
13714
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
13715
|
+
*
|
|
13716
|
+
* @returns {string}
|
|
13717
|
+
*/
|
|
13718
|
+
to_canonical_cbor_hex(): string;
|
|
13719
|
+
/**
|
|
13720
|
+
*
|
|
12471
13721
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
12472
13722
|
* * This is useful for interfacing with CIP30
|
|
12473
13723
|
*
|
|
@@ -12518,6 +13768,13 @@ export class UnregCert {
|
|
|
12518
13768
|
to_cbor_bytes(): Uint8Array;
|
|
12519
13769
|
/**
|
|
12520
13770
|
*
|
|
13771
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
13772
|
+
*
|
|
13773
|
+
* @returns {Uint8Array}
|
|
13774
|
+
*/
|
|
13775
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
13776
|
+
/**
|
|
13777
|
+
*
|
|
12521
13778
|
* * Create this type from CBOR bytes
|
|
12522
13779
|
*
|
|
12523
13780
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -12535,6 +13792,13 @@ export class UnregCert {
|
|
|
12535
13792
|
to_cbor_hex(): string;
|
|
12536
13793
|
/**
|
|
12537
13794
|
*
|
|
13795
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
13796
|
+
*
|
|
13797
|
+
* @returns {string}
|
|
13798
|
+
*/
|
|
13799
|
+
to_canonical_cbor_hex(): string;
|
|
13800
|
+
/**
|
|
13801
|
+
*
|
|
12538
13802
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
12539
13803
|
* * This is useful for interfacing with CIP30
|
|
12540
13804
|
*
|
|
@@ -12585,6 +13849,13 @@ export class UnregDrepCert {
|
|
|
12585
13849
|
to_cbor_bytes(): Uint8Array;
|
|
12586
13850
|
/**
|
|
12587
13851
|
*
|
|
13852
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
13853
|
+
*
|
|
13854
|
+
* @returns {Uint8Array}
|
|
13855
|
+
*/
|
|
13856
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
13857
|
+
/**
|
|
13858
|
+
*
|
|
12588
13859
|
* * Create this type from CBOR bytes
|
|
12589
13860
|
*
|
|
12590
13861
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -12602,6 +13873,13 @@ export class UnregDrepCert {
|
|
|
12602
13873
|
to_cbor_hex(): string;
|
|
12603
13874
|
/**
|
|
12604
13875
|
*
|
|
13876
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
13877
|
+
*
|
|
13878
|
+
* @returns {string}
|
|
13879
|
+
*/
|
|
13880
|
+
to_canonical_cbor_hex(): string;
|
|
13881
|
+
/**
|
|
13882
|
+
*
|
|
12605
13883
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
12606
13884
|
* * This is useful for interfacing with CIP30
|
|
12607
13885
|
*
|
|
@@ -12666,6 +13944,13 @@ export class UpdateCommittee {
|
|
|
12666
13944
|
to_cbor_bytes(): Uint8Array;
|
|
12667
13945
|
/**
|
|
12668
13946
|
*
|
|
13947
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
13948
|
+
*
|
|
13949
|
+
* @returns {Uint8Array}
|
|
13950
|
+
*/
|
|
13951
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
13952
|
+
/**
|
|
13953
|
+
*
|
|
12669
13954
|
* * Create this type from CBOR bytes
|
|
12670
13955
|
*
|
|
12671
13956
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -12683,6 +13968,13 @@ export class UpdateCommittee {
|
|
|
12683
13968
|
to_cbor_hex(): string;
|
|
12684
13969
|
/**
|
|
12685
13970
|
*
|
|
13971
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
13972
|
+
*
|
|
13973
|
+
* @returns {string}
|
|
13974
|
+
*/
|
|
13975
|
+
to_canonical_cbor_hex(): string;
|
|
13976
|
+
/**
|
|
13977
|
+
*
|
|
12686
13978
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
12687
13979
|
* * This is useful for interfacing with CIP30
|
|
12688
13980
|
*
|
|
@@ -12743,6 +14035,13 @@ export class UpdateDrepCert {
|
|
|
12743
14035
|
to_cbor_bytes(): Uint8Array;
|
|
12744
14036
|
/**
|
|
12745
14037
|
*
|
|
14038
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
14039
|
+
*
|
|
14040
|
+
* @returns {Uint8Array}
|
|
14041
|
+
*/
|
|
14042
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
14043
|
+
/**
|
|
14044
|
+
*
|
|
12746
14045
|
* * Create this type from CBOR bytes
|
|
12747
14046
|
*
|
|
12748
14047
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -12760,6 +14059,13 @@ export class UpdateDrepCert {
|
|
|
12760
14059
|
to_cbor_hex(): string;
|
|
12761
14060
|
/**
|
|
12762
14061
|
*
|
|
14062
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
14063
|
+
*
|
|
14064
|
+
* @returns {string}
|
|
14065
|
+
*/
|
|
14066
|
+
to_canonical_cbor_hex(): string;
|
|
14067
|
+
/**
|
|
14068
|
+
*
|
|
12763
14069
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
12764
14070
|
* * This is useful for interfacing with CIP30
|
|
12765
14071
|
*
|
|
@@ -12810,6 +14116,13 @@ export class Url {
|
|
|
12810
14116
|
to_cbor_bytes(): Uint8Array;
|
|
12811
14117
|
/**
|
|
12812
14118
|
*
|
|
14119
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
14120
|
+
*
|
|
14121
|
+
* @returns {Uint8Array}
|
|
14122
|
+
*/
|
|
14123
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
14124
|
+
/**
|
|
14125
|
+
*
|
|
12813
14126
|
* * Create this type from CBOR bytes
|
|
12814
14127
|
*
|
|
12815
14128
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -12827,6 +14140,13 @@ export class Url {
|
|
|
12827
14140
|
to_cbor_hex(): string;
|
|
12828
14141
|
/**
|
|
12829
14142
|
*
|
|
14143
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
14144
|
+
*
|
|
14145
|
+
* @returns {string}
|
|
14146
|
+
*/
|
|
14147
|
+
to_canonical_cbor_hex(): string;
|
|
14148
|
+
/**
|
|
14149
|
+
*
|
|
12830
14150
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
12831
14151
|
* * This is useful for interfacing with CIP30
|
|
12832
14152
|
*
|
|
@@ -12867,6 +14187,13 @@ export class VRFCert {
|
|
|
12867
14187
|
to_cbor_bytes(): Uint8Array;
|
|
12868
14188
|
/**
|
|
12869
14189
|
*
|
|
14190
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
14191
|
+
*
|
|
14192
|
+
* @returns {Uint8Array}
|
|
14193
|
+
*/
|
|
14194
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
14195
|
+
/**
|
|
14196
|
+
*
|
|
12870
14197
|
* * Create this type from CBOR bytes
|
|
12871
14198
|
*
|
|
12872
14199
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -12884,6 +14211,13 @@ export class VRFCert {
|
|
|
12884
14211
|
to_cbor_hex(): string;
|
|
12885
14212
|
/**
|
|
12886
14213
|
*
|
|
14214
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
14215
|
+
*
|
|
14216
|
+
* @returns {string}
|
|
14217
|
+
*/
|
|
14218
|
+
to_canonical_cbor_hex(): string;
|
|
14219
|
+
/**
|
|
14220
|
+
*
|
|
12887
14221
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
12888
14222
|
* * This is useful for interfacing with CIP30
|
|
12889
14223
|
*
|
|
@@ -13024,6 +14358,13 @@ export class Value {
|
|
|
13024
14358
|
to_cbor_bytes(): Uint8Array;
|
|
13025
14359
|
/**
|
|
13026
14360
|
*
|
|
14361
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
14362
|
+
*
|
|
14363
|
+
* @returns {Uint8Array}
|
|
14364
|
+
*/
|
|
14365
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
14366
|
+
/**
|
|
14367
|
+
*
|
|
13027
14368
|
* * Create this type from CBOR bytes
|
|
13028
14369
|
*
|
|
13029
14370
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -13041,6 +14382,13 @@ export class Value {
|
|
|
13041
14382
|
to_cbor_hex(): string;
|
|
13042
14383
|
/**
|
|
13043
14384
|
*
|
|
14385
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
14386
|
+
*
|
|
14387
|
+
* @returns {string}
|
|
14388
|
+
*/
|
|
14389
|
+
to_canonical_cbor_hex(): string;
|
|
14390
|
+
/**
|
|
14391
|
+
*
|
|
13044
14392
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
13045
14393
|
* * This is useful for interfacing with CIP30
|
|
13046
14394
|
*
|
|
@@ -13127,6 +14475,13 @@ export class Vkeywitness {
|
|
|
13127
14475
|
to_cbor_bytes(): Uint8Array;
|
|
13128
14476
|
/**
|
|
13129
14477
|
*
|
|
14478
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
14479
|
+
*
|
|
14480
|
+
* @returns {Uint8Array}
|
|
14481
|
+
*/
|
|
14482
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
14483
|
+
/**
|
|
14484
|
+
*
|
|
13130
14485
|
* * Create this type from CBOR bytes
|
|
13131
14486
|
*
|
|
13132
14487
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -13144,6 +14499,13 @@ export class Vkeywitness {
|
|
|
13144
14499
|
to_cbor_hex(): string;
|
|
13145
14500
|
/**
|
|
13146
14501
|
*
|
|
14502
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
14503
|
+
*
|
|
14504
|
+
* @returns {string}
|
|
14505
|
+
*/
|
|
14506
|
+
to_canonical_cbor_hex(): string;
|
|
14507
|
+
/**
|
|
14508
|
+
*
|
|
13147
14509
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
13148
14510
|
* * This is useful for interfacing with CIP30
|
|
13149
14511
|
*
|
|
@@ -13269,6 +14631,13 @@ export class VoteDelegCert {
|
|
|
13269
14631
|
to_cbor_bytes(): Uint8Array;
|
|
13270
14632
|
/**
|
|
13271
14633
|
*
|
|
14634
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
14635
|
+
*
|
|
14636
|
+
* @returns {Uint8Array}
|
|
14637
|
+
*/
|
|
14638
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
14639
|
+
/**
|
|
14640
|
+
*
|
|
13272
14641
|
* * Create this type from CBOR bytes
|
|
13273
14642
|
*
|
|
13274
14643
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -13286,6 +14655,13 @@ export class VoteDelegCert {
|
|
|
13286
14655
|
to_cbor_hex(): string;
|
|
13287
14656
|
/**
|
|
13288
14657
|
*
|
|
14658
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
14659
|
+
*
|
|
14660
|
+
* @returns {string}
|
|
14661
|
+
*/
|
|
14662
|
+
to_canonical_cbor_hex(): string;
|
|
14663
|
+
/**
|
|
14664
|
+
*
|
|
13289
14665
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
13290
14666
|
* * This is useful for interfacing with CIP30
|
|
13291
14667
|
*
|
|
@@ -13336,6 +14712,13 @@ export class VoteRegDelegCert {
|
|
|
13336
14712
|
to_cbor_bytes(): Uint8Array;
|
|
13337
14713
|
/**
|
|
13338
14714
|
*
|
|
14715
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
14716
|
+
*
|
|
14717
|
+
* @returns {Uint8Array}
|
|
14718
|
+
*/
|
|
14719
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
14720
|
+
/**
|
|
14721
|
+
*
|
|
13339
14722
|
* * Create this type from CBOR bytes
|
|
13340
14723
|
*
|
|
13341
14724
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -13353,6 +14736,13 @@ export class VoteRegDelegCert {
|
|
|
13353
14736
|
to_cbor_hex(): string;
|
|
13354
14737
|
/**
|
|
13355
14738
|
*
|
|
14739
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
14740
|
+
*
|
|
14741
|
+
* @returns {string}
|
|
14742
|
+
*/
|
|
14743
|
+
to_canonical_cbor_hex(): string;
|
|
14744
|
+
/**
|
|
14745
|
+
*
|
|
13356
14746
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
13357
14747
|
* * This is useful for interfacing with CIP30
|
|
13358
14748
|
*
|
|
@@ -13416,6 +14806,13 @@ export class Voter {
|
|
|
13416
14806
|
to_cbor_bytes(): Uint8Array;
|
|
13417
14807
|
/**
|
|
13418
14808
|
*
|
|
14809
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
14810
|
+
*
|
|
14811
|
+
* @returns {Uint8Array}
|
|
14812
|
+
*/
|
|
14813
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
14814
|
+
/**
|
|
14815
|
+
*
|
|
13419
14816
|
* * Create this type from CBOR bytes
|
|
13420
14817
|
*
|
|
13421
14818
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -13433,6 +14830,13 @@ export class Voter {
|
|
|
13433
14830
|
to_cbor_hex(): string;
|
|
13434
14831
|
/**
|
|
13435
14832
|
*
|
|
14833
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
14834
|
+
*
|
|
14835
|
+
* @returns {string}
|
|
14836
|
+
*/
|
|
14837
|
+
to_canonical_cbor_hex(): string;
|
|
14838
|
+
/**
|
|
14839
|
+
*
|
|
13436
14840
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
13437
14841
|
* * This is useful for interfacing with CIP30
|
|
13438
14842
|
*
|
|
@@ -13540,6 +14944,13 @@ export class VotingProcedure {
|
|
|
13540
14944
|
to_cbor_bytes(): Uint8Array;
|
|
13541
14945
|
/**
|
|
13542
14946
|
*
|
|
14947
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings
|
|
14948
|
+
*
|
|
14949
|
+
* @returns {Uint8Array}
|
|
14950
|
+
*/
|
|
14951
|
+
to_canonical_cbor_bytes(): Uint8Array;
|
|
14952
|
+
/**
|
|
14953
|
+
*
|
|
13543
14954
|
* * Create this type from CBOR bytes
|
|
13544
14955
|
*
|
|
13545
14956
|
* @param {Uint8Array} cbor_bytes
|
|
@@ -13557,6 +14968,13 @@ export class VotingProcedure {
|
|
|
13557
14968
|
to_cbor_hex(): string;
|
|
13558
14969
|
/**
|
|
13559
14970
|
*
|
|
14971
|
+
* * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
|
|
14972
|
+
*
|
|
14973
|
+
* @returns {string}
|
|
14974
|
+
*/
|
|
14975
|
+
to_canonical_cbor_hex(): string;
|
|
14976
|
+
/**
|
|
14977
|
+
*
|
|
13560
14978
|
* * Create this type from the CBOR bytes encoded as a hex string.
|
|
13561
14979
|
* * This is useful for interfacing with CIP30
|
|
13562
14980
|
*
|