@anastasia-labs/cardano-multiplatform-lib-nodejs 5.3.1-7 → 6.0.0

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.
@@ -17,6 +17,11 @@ 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
+ * @param {Redeemers} redeemers
21
+ * @returns {ExUnits}
22
+ */
23
+ export function compute_total_ex_units(redeemers: Redeemers): ExUnits;
24
+ /**
20
25
  * @param {AuxiliaryData} auxiliary_data
21
26
  * @returns {AuxiliaryDataHash}
22
27
  */
@@ -93,7 +98,7 @@ export function get_implicit_input(txbody: TransactionBody, pool_deposit: bigint
93
98
  export function get_deposit(txbody: TransactionBody, pool_deposit: bigint, key_deposit: bigint): bigint;
94
99
  /**
95
100
  *
96
- * * Min fee for JUST the script
101
+ * * Min fee for JUST the script, NOT including ref inputs
97
102
  *
98
103
  * @param {Transaction} tx
99
104
  * @param {ExUnitPrices} ex_unit_prices
@@ -107,12 +112,41 @@ export function min_script_fee(tx: Transaction, ex_unit_prices: ExUnitPrices): b
107
112
  */
108
113
  export function min_no_script_fee(tx: Transaction, linear_fee: LinearFee): bigint;
109
114
  /**
115
+ *
116
+ * * Calculates the cost of all ref scripts
117
+ * * * `total_ref_script_size` - Total size (original, not hashes) of all ref scripts. Duplicate scripts are counted as many times as they occur
118
+ *
110
119
  * @param {Transaction} tx
111
120
  * @param {LinearFee} linear_fee
112
121
  * @param {ExUnitPrices} ex_unit_prices
122
+ * @param {bigint} total_ref_script_size
113
123
  * @returns {bigint}
114
124
  */
115
- export function min_fee(tx: Transaction, linear_fee: LinearFee, ex_unit_prices: ExUnitPrices): bigint;
125
+ export function min_fee(tx: Transaction, linear_fee: LinearFee, ex_unit_prices: ExUnitPrices, total_ref_script_size: bigint): bigint;
126
+ /**
127
+ * @param {TransactionOutput} output
128
+ * @param {bigint} coins_per_utxo_byte
129
+ * @returns {bigint}
130
+ */
131
+ export function min_ada_required(output: TransactionOutput, coins_per_utxo_byte: bigint): bigint;
132
+ /**
133
+ * encodes arbitrary bytes into chunks of 64 bytes (the limit for bytes) as a list to be valid Metadata
134
+ * @param {Uint8Array} bytes
135
+ * @returns {TransactionMetadatum}
136
+ */
137
+ export function encode_arbitrary_bytes_as_metadatum(bytes: Uint8Array): TransactionMetadatum;
138
+ /**
139
+ * decodes from chunks of bytes in a list to a byte vector if that is the metadata format, otherwise returns None
140
+ * @param {TransactionMetadatum} metadata
141
+ * @returns {Uint8Array | undefined}
142
+ */
143
+ export function decode_arbitrary_bytes_from_metadatum(metadata: TransactionMetadatum): Uint8Array | undefined;
144
+ /**
145
+ * @param {TransactionHash} tx_body_hash
146
+ * @param {PrivateKey} sk
147
+ * @returns {Vkeywitness}
148
+ */
149
+ export function make_vkey_witness(tx_body_hash: TransactionHash, sk: PrivateKey): Vkeywitness;
116
150
  /**
117
151
  * Converts JSON to Metadata according to MetadataJsonSchema
118
152
  * @param {string} json
@@ -128,11 +162,6 @@ export function encode_json_str_to_metadatum(json: string, schema: MetadataJsonS
128
162
  */
129
163
  export function decode_metadatum_to_json_str(metadatum: TransactionMetadatum, schema: MetadataJsonSchema): string;
130
164
  /**
131
- * @param {Redeemers} redeemers
132
- * @returns {ExUnits}
133
- */
134
- export function compute_total_ex_units(redeemers: Redeemers): ExUnits;
135
- /**
136
165
  * @param {TransactionHash} tx_body_hash
137
166
  * @param {ByronAddress} addr
138
167
  * @param {LegacyDaedalusPrivateKey} key
@@ -147,30 +176,6 @@ export function make_daedalus_bootstrap_witness(tx_body_hash: TransactionHash, a
147
176
  */
148
177
  export function make_icarus_bootstrap_witness(tx_body_hash: TransactionHash, addr: ByronAddress, key: Bip32PrivateKey): BootstrapWitness;
149
178
  /**
150
- * @param {TransactionHash} tx_body_hash
151
- * @param {PrivateKey} sk
152
- * @returns {Vkeywitness}
153
- */
154
- export function make_vkey_witness(tx_body_hash: TransactionHash, sk: PrivateKey): Vkeywitness;
155
- /**
156
- * @param {TransactionOutput} output
157
- * @param {bigint} coins_per_utxo_byte
158
- * @returns {bigint}
159
- */
160
- export function min_ada_required(output: TransactionOutput, coins_per_utxo_byte: bigint): bigint;
161
- /**
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,25 +189,6 @@ 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 MetadataJsonSchema {
188
- NoConversions = 0,
189
- BasicConversions = 1,
190
- DetailedSchema = 2,
191
- }
192
- /**
193
- */
194
- export enum StakeDistributionKind {
195
- SingleKey = 0,
196
- BootstrapEra = 1,
197
- }
198
- /**
199
- */
200
- export enum ChunkableStringKind {
201
- Single = 0,
202
- Chunked = 1,
203
- }
204
- /**
205
- */
206
192
  export enum AuxiliaryDataKind {
207
193
  Shelley = 0,
208
194
  ShelleyMA = 1,
@@ -210,10 +196,9 @@ export enum AuxiliaryDataKind {
210
196
  }
211
197
  /**
212
198
  */
213
- export enum RelayKind {
214
- SingleHostAddr = 0,
215
- SingleHostName = 1,
216
- MultiHostName = 2,
199
+ export enum RedeemersKind {
200
+ ArrLegacyRedeemer = 0,
201
+ MapRedeemerKeyToRedeemerVal = 1,
217
202
  }
218
203
  /**
219
204
  */
@@ -224,60 +209,30 @@ export enum Vote {
224
209
  }
225
210
  /**
226
211
  */
227
- export enum DatumOptionKind {
228
- Hash = 0,
229
- Datum = 1,
230
- }
231
- /**
232
- */
233
- export enum NonceKind {
234
- Identity = 0,
235
- Hash = 1,
236
- }
212
+ export enum CoinSelectionStrategyCIP2 {
237
213
  /**
214
+ * Performs CIP2's Largest First ada-only selection. Will error if outputs contain non-ADA assets.
238
215
  */
239
- export enum ScriptKind {
240
- Native = 0,
241
- PlutusV1 = 1,
242
- PlutusV2 = 2,
243
- PlutusV3 = 3,
244
- }
216
+ LargestFirst = 0,
245
217
  /**
218
+ * Performs CIP2's Random Improve ada-only selection. Will error if outputs contain non-ADA assets.
246
219
  */
247
- export enum CredentialKind {
248
- PubKey = 0,
249
- Script = 1,
250
- }
220
+ RandomImprove = 1,
251
221
  /**
252
- * Careful: this enum doesn't include the network ID part of the header
253
- * ex: base address isn't 0b0000_0000 but instead 0b0000
254
- * Use `header_matches_kind` if you don't want to implement the bitwise operators yourself
222
+ * Same as LargestFirst, but before adding ADA, will insert by largest-first for each asset type.
255
223
  */
256
- export enum AddressHeaderKind {
257
- BasePaymentKeyStakeKey = 0,
258
- BasePaymentScriptStakeKey = 1,
259
- BasePaymentKeyStakeScript = 2,
260
- BasePaymentScriptStakeScript = 3,
261
- PointerKey = 4,
262
- PointerScript = 5,
263
- EnterpriseKey = 6,
264
- EnterpriseScript = 7,
265
- Byron = 8,
266
- RewardKey = 14,
267
- RewardScript = 15,
268
- }
224
+ LargestFirstMultiAsset = 2,
269
225
  /**
226
+ * Same as RandomImprove, but before adding ADA, will insert by random-improve for each asset type.
270
227
  */
271
- export enum TransactionOutputKind {
272
- AlonzoFormatTxOut = 0,
273
- ConwayFormatTxOut = 1,
228
+ RandomImproveMultiAsset = 3,
274
229
  }
275
230
  /**
276
231
  */
277
- export enum Language {
278
- PlutusV1 = 0,
279
- PlutusV2 = 1,
280
- PlutusV3 = 2,
232
+ export enum MetadataJsonSchema {
233
+ NoConversions = 0,
234
+ BasicConversions = 1,
235
+ DetailedSchema = 2,
281
236
  }
282
237
  /**
283
238
  */
@@ -290,13 +245,6 @@ export enum PlutusDataKind {
290
245
  }
291
246
  /**
292
247
  */
293
- export enum SpendingDataKind {
294
- SpendingDataPubKey = 0,
295
- SpendingDataScript = 1,
296
- SpendingDataRedeem = 2,
297
- }
298
- /**
299
- */
300
248
  export enum NativeScriptKind {
301
249
  ScriptPubkey = 0,
302
250
  ScriptAll = 1,
@@ -307,85 +255,35 @@ export enum NativeScriptKind {
307
255
  }
308
256
  /**
309
257
  */
310
- export enum AddressKind {
311
- Base = 0,
312
- Ptr = 1,
313
- Enterprise = 2,
314
- Reward = 3,
315
- Byron = 4,
316
- }
317
- /**
318
- */
319
- export enum CertificateKind {
320
- StakeRegistration = 0,
321
- StakeDeregistration = 1,
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,
258
+ export enum DelegationDistributionKind {
259
+ Weighted = 0,
260
+ Legacy = 1,
373
261
  }
374
262
  /**
263
+ * Careful: this enum doesn't include the network ID part of the header
264
+ * ex: base address isn't 0b0000_0000 but instead 0b0000
265
+ * Use `header_matches_kind` if you don't want to implement the bitwise operators yourself
375
266
  */
376
- export enum RedeemerTag {
377
- Spend = 0,
378
- Mint = 1,
379
- Cert = 2,
380
- Reward = 3,
381
- Voting = 4,
382
- Proposing = 5,
267
+ export enum AddressHeaderKind {
268
+ BasePaymentKeyStakeKey = 0,
269
+ BasePaymentScriptStakeKey = 1,
270
+ BasePaymentKeyStakeScript = 2,
271
+ BasePaymentScriptStakeScript = 3,
272
+ PointerKey = 4,
273
+ PointerScript = 5,
274
+ EnterpriseKey = 6,
275
+ EnterpriseScript = 7,
276
+ Byron = 8,
277
+ RewardKey = 14,
278
+ RewardScript = 15,
383
279
  }
384
280
  /**
385
281
  */
386
- export enum RedeemersKind {
387
- ArrLegacyRedeemer = 0,
388
- MapRedeemerKeyToRedeemerVal = 1,
282
+ export enum ScriptKind {
283
+ Native = 0,
284
+ PlutusV1 = 1,
285
+ PlutusV2 = 2,
286
+ PlutusV3 = 3,
389
287
  }
390
288
  /**
391
289
  */
@@ -396,21 +294,6 @@ export enum DRepKind {
396
294
  AlwaysNoConfidence = 3,
397
295
  }
398
296
  /**
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,
412
- }
413
- /**
414
297
  * JSON <-> PlutusData conversion schemas.
415
298
  * Follows ScriptDataJsonSchema in cardano-cli defined at:
416
299
  * https://github.com/input-output-hk/cardano-node/blob/master/cardano-api/src/Cardano/Api/ScriptData.hs#L254
@@ -464,34 +347,156 @@ export enum CardanoNodePlutusDatumSchema {
464
347
  }
465
348
  /**
466
349
  */
467
- export enum CoinSelectionStrategyCIP2 {
350
+ export enum RedeemerTag {
351
+ Spend = 0,
352
+ Mint = 1,
353
+ Cert = 2,
354
+ Reward = 3,
355
+ Voting = 4,
356
+ Proposing = 5,
357
+ }
358
+ /**
359
+ */
360
+ export enum TransactionOutputKind {
361
+ AlonzoFormatTxOut = 0,
362
+ ConwayFormatTxOut = 1,
363
+ }
364
+ /**
365
+ */
366
+ export enum TransactionMetadatumKind {
367
+ Map = 0,
368
+ List = 1,
369
+ Int = 2,
370
+ Bytes = 3,
371
+ Text = 4,
372
+ }
373
+ /**
374
+ */
375
+ export enum ChunkableStringKind {
376
+ Single = 0,
377
+ Chunked = 1,
378
+ }
379
+ /**
380
+ */
381
+ export enum AddressKind {
382
+ Base = 0,
383
+ Ptr = 1,
384
+ Enterprise = 2,
385
+ Reward = 3,
386
+ Byron = 4,
387
+ }
388
+ /**
389
+ */
390
+ export enum ByronAddrType {
391
+ PublicKey = 0,
392
+ Script = 1,
393
+ Redeem = 2,
394
+ }
395
+ /**
396
+ */
397
+ export enum CertificateKind {
398
+ StakeRegistration = 0,
399
+ StakeDeregistration = 1,
400
+ StakeDelegation = 2,
401
+ PoolRegistration = 3,
402
+ PoolRetirement = 4,
403
+ RegCert = 5,
404
+ UnregCert = 6,
405
+ VoteDelegCert = 7,
406
+ StakeVoteDelegCert = 8,
407
+ StakeRegDelegCert = 9,
408
+ VoteRegDelegCert = 10,
409
+ StakeVoteRegDelegCert = 11,
410
+ AuthCommitteeHotCert = 12,
411
+ ResignCommitteeColdCert = 13,
412
+ RegDrepCert = 14,
413
+ UnregDrepCert = 15,
414
+ UpdateDrepCert = 16,
415
+ }
416
+ /**
417
+ */
418
+ export enum CredentialKind {
419
+ PubKey = 0,
420
+ Script = 1,
421
+ }
422
+ /**
423
+ */
424
+ export enum StakeDistributionKind {
425
+ SingleKey = 0,
426
+ BootstrapEra = 1,
427
+ }
428
+ /**
429
+ */
430
+ export enum ChangeSelectionAlgo {
431
+ Default = 0,
432
+ }
433
+ /**
434
+ * Which version of the CIP25 spec to use. See CIP25 for details.
435
+ * This will change how things are encoded but for the most part contains
436
+ * the same information.
437
+ */
438
+ export enum CIP25Version {
439
+ /**
440
+ * Initial version of CIP25 with only string (utf8) asset names allowed.
441
+ */
442
+ V1 = 0,
443
+ /**
444
+ * Second version of CIP25. Supports any type of asset names.
445
+ */
446
+ V2 = 1,
447
+ }
448
+ /**
449
+ */
450
+ export enum RelayKind {
451
+ SingleHostAddr = 0,
452
+ SingleHostName = 1,
453
+ MultiHostName = 2,
454
+ }
468
455
  /**
469
- * Performs CIP2's Largest First ada-only selection. Will error if outputs contain non-ADA assets.
470
456
  */
471
- LargestFirst = 0,
457
+ export enum NonceKind {
458
+ Identity = 0,
459
+ Hash = 1,
460
+ }
472
461
  /**
473
- * Performs CIP2's Random Improve ada-only selection. Will error if outputs contain non-ADA assets.
474
462
  */
475
- RandomImprove = 1,
463
+ export enum GovActionKind {
464
+ ParameterChangeAction = 0,
465
+ HardForkInitiationAction = 1,
466
+ TreasuryWithdrawalsAction = 2,
467
+ NoConfidence = 3,
468
+ UpdateCommittee = 4,
469
+ NewConstitution = 5,
470
+ InfoAction = 6,
471
+ }
476
472
  /**
477
- * Same as LargestFirst, but before adding ADA, will insert by largest-first for each asset type.
478
473
  */
479
- LargestFirstMultiAsset = 2,
474
+ export enum DatumOptionKind {
475
+ Hash = 0,
476
+ Datum = 1,
477
+ }
480
478
  /**
481
- * Same as RandomImprove, but before adding ADA, will insert by random-improve for each asset type.
482
479
  */
483
- RandomImproveMultiAsset = 3,
480
+ export enum Language {
481
+ PlutusV1 = 0,
482
+ PlutusV2 = 1,
483
+ PlutusV3 = 2,
484
484
  }
485
485
  /**
486
486
  */
487
- export enum ChangeSelectionAlgo {
488
- Default = 0,
487
+ export enum VoterKind {
488
+ ConstitutionalCommitteeHotKeyHash = 0,
489
+ ConstitutionalCommitteeHotScriptHash = 1,
490
+ DRepKeyHash = 2,
491
+ DRepScriptHash = 3,
492
+ StakingPoolKeyHash = 4,
489
493
  }
490
494
  /**
491
495
  */
492
- export enum DelegationDistributionKind {
493
- Weighted = 0,
494
- Legacy = 1,
496
+ export enum SpendingDataKind {
497
+ SpendingDataPubKey = 0,
498
+ SpendingDataScript = 1,
499
+ SpendingDataRedeem = 2,
495
500
  }
496
501
  /**
497
502
  */
@@ -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
  *
@@ -1093,6 +1126,13 @@ export class AssetName {
1093
1126
  to_cbor_bytes(): Uint8Array;
1094
1127
  /**
1095
1128
  *
1129
+ * * Serialize this type to CBOR bytes using canonical CBOR encodings
1130
+ *
1131
+ * @returns {Uint8Array}
1132
+ */
1133
+ to_canonical_cbor_bytes(): Uint8Array;
1134
+ /**
1135
+ *
1096
1136
  * * Create this type from CBOR bytes
1097
1137
  *
1098
1138
  * @param {Uint8Array} cbor_bytes
@@ -1110,6 +1150,13 @@ export class AssetName {
1110
1150
  to_cbor_hex(): string;
1111
1151
  /**
1112
1152
  *
1153
+ * * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
1154
+ *
1155
+ * @returns {string}
1156
+ */
1157
+ to_canonical_cbor_hex(): string;
1158
+ /**
1159
+ *
1113
1160
  * * Create this type from the CBOR bytes encoded as a hex string.
1114
1161
  * * This is useful for interfacing with CIP30
1115
1162
  *
@@ -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
  *
@@ -1225,54 +1286,6 @@ export class AuthCommitteeHotCert {
1225
1286
  export class AuxiliaryData {
1226
1287
  free(): void;
1227
1288
  /**
1228
- * @returns {AuxiliaryData}
1229
- */
1230
- static new(): AuxiliaryData;
1231
- /**
1232
- * @returns {Metadata | undefined}
1233
- */
1234
- metadata(): Metadata | undefined;
1235
- /**
1236
- * @returns {NativeScriptList | undefined}
1237
- */
1238
- native_scripts(): NativeScriptList | undefined;
1239
- /**
1240
- * @returns {PlutusV1ScriptList | undefined}
1241
- */
1242
- plutus_v1_scripts(): PlutusV1ScriptList | undefined;
1243
- /**
1244
- * @returns {PlutusV2ScriptList | undefined}
1245
- */
1246
- plutus_v2_scripts(): PlutusV2ScriptList | undefined;
1247
- /**
1248
- * Warning: overwrites any conflicting metadatum labels present
1249
- * @param {Metadata} other
1250
- */
1251
- add_metadata(other: Metadata): void;
1252
- /**
1253
- * Warning: does not check for duplicates and may migrate eras
1254
- * @param {NativeScriptList} scripts
1255
- */
1256
- add_native_scripts(scripts: NativeScriptList): void;
1257
- /**
1258
- * Warning: does not check for duplicates and may migrate eras
1259
- * @param {PlutusV1ScriptList} scripts
1260
- */
1261
- add_plutus_v1_scripts(scripts: PlutusV1ScriptList): void;
1262
- /**
1263
- * Warning: does not check for duplicates and may migrate eras
1264
- * @param {PlutusV2ScriptList} scripts
1265
- */
1266
- add_plutus_v2_scripts(scripts: PlutusV2ScriptList): void;
1267
- /**
1268
- * Adds everything present in other to self
1269
- * May change the era the aux data is in if necessary
1270
- * Warning: overwrites any metadatum labels present
1271
- * also does not check for duplicates in scripts
1272
- * @param {AuxiliaryData} other
1273
- */
1274
- add(other: AuxiliaryData): void;
1275
- /**
1276
1289
  *
1277
1290
  * * Serialize this type to CBOR bytes
1278
1291
  * * This type type supports encoding preservation so this will preserve round-trip CBOR formats.
@@ -1283,6 +1296,13 @@ export class AuxiliaryData {
1283
1296
  to_cbor_bytes(): Uint8Array;
1284
1297
  /**
1285
1298
  *
1299
+ * * Serialize this type to CBOR bytes using canonical CBOR encodings
1300
+ *
1301
+ * @returns {Uint8Array}
1302
+ */
1303
+ to_canonical_cbor_bytes(): Uint8Array;
1304
+ /**
1305
+ *
1286
1306
  * * Create this type from CBOR bytes
1287
1307
  *
1288
1308
  * @param {Uint8Array} cbor_bytes
@@ -1300,6 +1320,13 @@ export class AuxiliaryData {
1300
1320
  to_cbor_hex(): string;
1301
1321
  /**
1302
1322
  *
1323
+ * * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
1324
+ *
1325
+ * @returns {string}
1326
+ */
1327
+ to_canonical_cbor_hex(): string;
1328
+ /**
1329
+ *
1303
1330
  * * Create this type from the CBOR bytes encoded as a hex string.
1304
1331
  * * This is useful for interfacing with CIP30
1305
1332
  *
@@ -1351,6 +1378,54 @@ export class AuxiliaryData {
1351
1378
  * @returns {ConwayFormatAuxData | undefined}
1352
1379
  */
1353
1380
  as_conway(): ConwayFormatAuxData | undefined;
1381
+ /**
1382
+ * @returns {AuxiliaryData}
1383
+ */
1384
+ static new(): AuxiliaryData;
1385
+ /**
1386
+ * @returns {Metadata | undefined}
1387
+ */
1388
+ metadata(): Metadata | undefined;
1389
+ /**
1390
+ * @returns {NativeScriptList | undefined}
1391
+ */
1392
+ native_scripts(): NativeScriptList | undefined;
1393
+ /**
1394
+ * @returns {PlutusV1ScriptList | undefined}
1395
+ */
1396
+ plutus_v1_scripts(): PlutusV1ScriptList | undefined;
1397
+ /**
1398
+ * @returns {PlutusV2ScriptList | undefined}
1399
+ */
1400
+ plutus_v2_scripts(): PlutusV2ScriptList | undefined;
1401
+ /**
1402
+ * Warning: overwrites any conflicting metadatum labels present
1403
+ * @param {Metadata} other
1404
+ */
1405
+ add_metadata(other: Metadata): void;
1406
+ /**
1407
+ * Warning: does not check for duplicates and may migrate eras
1408
+ * @param {NativeScriptList} scripts
1409
+ */
1410
+ add_native_scripts(scripts: NativeScriptList): void;
1411
+ /**
1412
+ * Warning: does not check for duplicates and may migrate eras
1413
+ * @param {PlutusV1ScriptList} scripts
1414
+ */
1415
+ add_plutus_v1_scripts(scripts: PlutusV1ScriptList): void;
1416
+ /**
1417
+ * Warning: does not check for duplicates and may migrate eras
1418
+ * @param {PlutusV2ScriptList} scripts
1419
+ */
1420
+ add_plutus_v2_scripts(scripts: PlutusV2ScriptList): void;
1421
+ /**
1422
+ * Adds everything present in other to self
1423
+ * May change the era the aux data is in if necessary
1424
+ * Warning: overwrites any metadatum labels present
1425
+ * also does not check for duplicates in scripts
1426
+ * @param {AuxiliaryData} other
1427
+ */
1428
+ add(other: AuxiliaryData): void;
1354
1429
  }
1355
1430
  /**
1356
1431
  */
@@ -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
@@ -2876,7 +3028,14 @@ export class CIP36DeregistrationWitness {
2876
3028
  *
2877
3029
  * @returns {string}
2878
3030
  */
2879
- to_cbor_hex(): string;
3031
+ to_cbor_hex(): string;
3032
+ /**
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;
2880
3039
  /**
2881
3040
  *
2882
3041
  * * Create this type from the CBOR bytes encoded as a hex string.
@@ -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
  *
@@ -4214,6 +4555,13 @@ export class DatumOption {
4214
4555
  to_cbor_bytes(): Uint8Array;
4215
4556
  /**
4216
4557
  *
4558
+ * * Serialize this type to CBOR bytes using canonical CBOR encodings
4559
+ *
4560
+ * @returns {Uint8Array}
4561
+ */
4562
+ to_canonical_cbor_bytes(): Uint8Array;
4563
+ /**
4564
+ *
4217
4565
  * * Create this type from CBOR bytes
4218
4566
  *
4219
4567
  * @param {Uint8Array} 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
- coefficient(): bigint;
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
  *
@@ -6261,24 +6796,6 @@ export class MultiHostName {
6261
6796
  export class NativeScript {
6262
6797
  free(): void;
6263
6798
  /**
6264
- * Returns an array of unique Ed25519KeyHashes
6265
- * contained within this script recursively on any depth level.
6266
- * The order of the keys in the result is not determined in any way.
6267
- * @returns {Ed25519KeyHashList}
6268
- */
6269
- get_required_signers(): Ed25519KeyHashList;
6270
- /**
6271
- * @returns {ScriptHash}
6272
- */
6273
- hash(): ScriptHash;
6274
- /**
6275
- * @param {bigint | undefined} lower_bound
6276
- * @param {bigint | undefined} upper_bound
6277
- * @param {Ed25519KeyHashList} key_hashes
6278
- * @returns {boolean}
6279
- */
6280
- verify(lower_bound: bigint | undefined, upper_bound: bigint | undefined, key_hashes: Ed25519KeyHashList): boolean;
6281
- /**
6282
6799
  *
6283
6800
  * * Serialize this type to CBOR bytes
6284
6801
  * * This type type supports encoding preservation so this will preserve round-trip CBOR formats.
@@ -6289,6 +6806,13 @@ export class NativeScript {
6289
6806
  to_cbor_bytes(): Uint8Array;
6290
6807
  /**
6291
6808
  *
6809
+ * * Serialize this type to CBOR bytes using canonical CBOR encodings
6810
+ *
6811
+ * @returns {Uint8Array}
6812
+ */
6813
+ to_canonical_cbor_bytes(): Uint8Array;
6814
+ /**
6815
+ *
6292
6816
  * * Create this type from CBOR bytes
6293
6817
  *
6294
6818
  * @param {Uint8Array} cbor_bytes
@@ -6306,6 +6830,13 @@ export class NativeScript {
6306
6830
  to_cbor_hex(): string;
6307
6831
  /**
6308
6832
  *
6833
+ * * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
6834
+ *
6835
+ * @returns {string}
6836
+ */
6837
+ to_canonical_cbor_hex(): string;
6838
+ /**
6839
+ *
6309
6840
  * * Create this type from the CBOR bytes encoded as a hex string.
6310
6841
  * * This is useful for interfacing with CIP30
6311
6842
  *
@@ -6387,6 +6918,24 @@ export class NativeScript {
6387
6918
  * @returns {ScriptInvalidHereafter | undefined}
6388
6919
  */
6389
6920
  as_script_invalid_hereafter(): ScriptInvalidHereafter | undefined;
6921
+ /**
6922
+ * Returns an array of unique Ed25519KeyHashes
6923
+ * contained within this script recursively on any depth level.
6924
+ * The order of the keys in the result is not determined in any way.
6925
+ * @returns {Ed25519KeyHashList}
6926
+ */
6927
+ get_required_signers(): Ed25519KeyHashList;
6928
+ /**
6929
+ * @returns {ScriptHash}
6930
+ */
6931
+ hash(): ScriptHash;
6932
+ /**
6933
+ * @param {bigint | undefined} lower_bound
6934
+ * @param {bigint | undefined} upper_bound
6935
+ * @param {Ed25519KeyHashList} key_hashes
6936
+ * @returns {boolean}
6937
+ */
6938
+ verify(lower_bound: bigint | undefined, upper_bound: bigint | undefined, key_hashes: Ed25519KeyHashList): boolean;
6390
6939
  }
6391
6940
  /**
6392
6941
  */
@@ -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
  *
@@ -8656,7 +9471,14 @@ export class Rational {
8656
9471
  *
8657
9472
  * @returns {Uint8Array}
8658
9473
  */
8659
- to_cbor_bytes(): Uint8Array;
9474
+ to_cbor_bytes(): Uint8Array;
9475
+ /**
9476
+ *
9477
+ * * Serialize this type to CBOR bytes using canonical CBOR encodings
9478
+ *
9479
+ * @returns {Uint8Array}
9480
+ */
9481
+ to_canonical_cbor_bytes(): Uint8Array;
8660
9482
  /**
8661
9483
  *
8662
9484
  * * Create this type from 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
  *
@@ -10247,6 +11300,13 @@ export class SingleHostName {
10247
11300
  to_cbor_bytes(): Uint8Array;
10248
11301
  /**
10249
11302
  *
11303
+ * * Serialize this type to CBOR bytes using canonical CBOR encodings
11304
+ *
11305
+ * @returns {Uint8Array}
11306
+ */
11307
+ to_canonical_cbor_bytes(): Uint8Array;
11308
+ /**
11309
+ *
10250
11310
  * * Create this type from CBOR bytes
10251
11311
  *
10252
11312
  * @param {Uint8Array} 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
  *
@@ -11868,41 +13062,6 @@ export class TransactionMetadatumList {
11868
13062
  export class TransactionOutput {
11869
13063
  free(): void;
11870
13064
  /**
11871
- * @param {Address} address
11872
- * @param {Value} amount
11873
- * @param {DatumOption | undefined} [datum_option]
11874
- * @param {Script | undefined} [script_reference]
11875
- * @returns {TransactionOutput}
11876
- */
11877
- static new(address: Address, amount: Value, datum_option?: DatumOption, script_reference?: Script): TransactionOutput;
11878
- /**
11879
- * @returns {Address}
11880
- */
11881
- address(): Address;
11882
- /**
11883
- * @returns {Value}
11884
- */
11885
- amount(): Value;
11886
- /**
11887
- * @param {Value} amount
11888
- */
11889
- set_amount(amount: Value): void;
11890
- /**
11891
- * @returns {DatumOption | undefined}
11892
- */
11893
- datum(): DatumOption | undefined;
11894
- /**
11895
- * Get the datum hash from a tx output if present as a hash.
11896
- * Returns None if there is no datum, or the datum is inlined.
11897
- * Use TransactionOutput::datum() for inlined datums.
11898
- * @returns {DatumHash | undefined}
11899
- */
11900
- datum_hash(): DatumHash | undefined;
11901
- /**
11902
- * @returns {Script | undefined}
11903
- */
11904
- script_ref(): Script | undefined;
11905
- /**
11906
13065
  *
11907
13066
  * * Serialize this type to CBOR bytes
11908
13067
  * * This type type supports encoding preservation so this will preserve round-trip CBOR formats.
@@ -11913,6 +13072,13 @@ export class TransactionOutput {
11913
13072
  to_cbor_bytes(): Uint8Array;
11914
13073
  /**
11915
13074
  *
13075
+ * * Serialize this type to CBOR bytes using canonical CBOR encodings
13076
+ *
13077
+ * @returns {Uint8Array}
13078
+ */
13079
+ to_canonical_cbor_bytes(): Uint8Array;
13080
+ /**
13081
+ *
11916
13082
  * * Create this type from CBOR bytes
11917
13083
  *
11918
13084
  * @param {Uint8Array} cbor_bytes
@@ -11930,6 +13096,13 @@ export class TransactionOutput {
11930
13096
  to_cbor_hex(): string;
11931
13097
  /**
11932
13098
  *
13099
+ * * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
13100
+ *
13101
+ * @returns {string}
13102
+ */
13103
+ to_canonical_cbor_hex(): string;
13104
+ /**
13105
+ *
11933
13106
  * * Create this type from the CBOR bytes encoded as a hex string.
11934
13107
  * * This is useful for interfacing with CIP30
11935
13108
  *
@@ -11972,6 +13145,41 @@ export class TransactionOutput {
11972
13145
  * @returns {ConwayFormatTxOut | undefined}
11973
13146
  */
11974
13147
  as_conway_format_tx_out(): ConwayFormatTxOut | undefined;
13148
+ /**
13149
+ * @param {Address} address
13150
+ * @param {Value} amount
13151
+ * @param {DatumOption | undefined} [datum_option]
13152
+ * @param {Script | undefined} [script_reference]
13153
+ * @returns {TransactionOutput}
13154
+ */
13155
+ static new(address: Address, amount: Value, datum_option?: DatumOption, script_reference?: Script): TransactionOutput;
13156
+ /**
13157
+ * @returns {Address}
13158
+ */
13159
+ address(): Address;
13160
+ /**
13161
+ * @returns {Value}
13162
+ */
13163
+ amount(): Value;
13164
+ /**
13165
+ * @param {Value} amount
13166
+ */
13167
+ set_amount(amount: Value): void;
13168
+ /**
13169
+ * @returns {DatumOption | undefined}
13170
+ */
13171
+ datum(): DatumOption | undefined;
13172
+ /**
13173
+ * Get the datum hash from a tx output if present as a hash.
13174
+ * Returns None if there is no datum, or the datum is inlined.
13175
+ * Use TransactionOutput::datum() for inlined datums.
13176
+ * @returns {DatumHash | undefined}
13177
+ */
13178
+ datum_hash(): DatumHash | undefined;
13179
+ /**
13180
+ * @returns {Script | undefined}
13181
+ */
13182
+ script_ref(): Script | undefined;
11975
13183
  }
11976
13184
  /**
11977
13185
  */
@@ -12114,14 +13322,6 @@ export class TransactionUnspentOutput {
12114
13322
  export class TransactionWitnessSet {
12115
13323
  free(): void;
12116
13324
  /**
12117
- * @param {TransactionWitnessSet} other
12118
- */
12119
- add_all_witnesses(other: TransactionWitnessSet): void;
12120
- /**
12121
- * @returns {LanguageList}
12122
- */
12123
- languages(): LanguageList;
12124
- /**
12125
13325
  *
12126
13326
  * * Serialize this type to CBOR bytes
12127
13327
  * * This type type supports encoding preservation so this will preserve round-trip CBOR formats.
@@ -12132,6 +13332,13 @@ export class TransactionWitnessSet {
12132
13332
  to_cbor_bytes(): Uint8Array;
12133
13333
  /**
12134
13334
  *
13335
+ * * Serialize this type to CBOR bytes using canonical CBOR encodings
13336
+ *
13337
+ * @returns {Uint8Array}
13338
+ */
13339
+ to_canonical_cbor_bytes(): Uint8Array;
13340
+ /**
13341
+ *
12135
13342
  * * Create this type from CBOR bytes
12136
13343
  *
12137
13344
  * @param {Uint8Array} cbor_bytes
@@ -12149,6 +13356,13 @@ export class TransactionWitnessSet {
12149
13356
  to_cbor_hex(): string;
12150
13357
  /**
12151
13358
  *
13359
+ * * Serialize this type to CBOR bytes using canonical CBOR encodings as hex bytes
13360
+ *
13361
+ * @returns {string}
13362
+ */
13363
+ to_canonical_cbor_hex(): string;
13364
+ /**
13365
+ *
12152
13366
  * * Create this type from the CBOR bytes encoded as a hex string.
12153
13367
  * * This is useful for interfacing with CIP30
12154
13368
  *
@@ -12237,6 +13451,14 @@ export class TransactionWitnessSet {
12237
13451
  * @returns {TransactionWitnessSet}
12238
13452
  */
12239
13453
  static new(): TransactionWitnessSet;
13454
+ /**
13455
+ * @param {TransactionWitnessSet} other
13456
+ */
13457
+ add_all_witnesses(other: TransactionWitnessSet): void;
13458
+ /**
13459
+ * @returns {LanguageList}
13460
+ */
13461
+ languages(): LanguageList;
12240
13462
  }
12241
13463
  /**
12242
13464
  * Builder de-duplicates witnesses as they are added
@@ -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
  *