@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.
- package/README.md +4 -4
- package/cardano_multiplatform_lib.d.ts +1737 -319
- package/cardano_multiplatform_lib.js +4534 -382
- package/cardano_multiplatform_lib_bg.wasm +0 -0
- package/package.json +1 -1
|
@@ -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
|
|
214
|
-
|
|
215
|
-
|
|
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
|
|
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
|
-
|
|
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
|
-
|
|
248
|
-
PubKey = 0,
|
|
249
|
-
Script = 1,
|
|
250
|
-
}
|
|
220
|
+
RandomImprove = 1,
|
|
251
221
|
/**
|
|
252
|
-
*
|
|
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
|
-
|
|
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
|
-
|
|
272
|
-
AlonzoFormatTxOut = 0,
|
|
273
|
-
ConwayFormatTxOut = 1,
|
|
228
|
+
RandomImproveMultiAsset = 3,
|
|
274
229
|
}
|
|
275
230
|
/**
|
|
276
231
|
*/
|
|
277
|
-
export enum
|
|
278
|
-
|
|
279
|
-
|
|
280
|
-
|
|
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
|
|
311
|
-
|
|
312
|
-
|
|
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
|
|
377
|
-
|
|
378
|
-
|
|
379
|
-
|
|
380
|
-
|
|
381
|
-
|
|
382
|
-
|
|
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
|
|
387
|
-
|
|
388
|
-
|
|
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
|
|
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
|
-
|
|
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
|
-
|
|
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
|
-
|
|
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
|
-
|
|
480
|
+
export enum Language {
|
|
481
|
+
PlutusV1 = 0,
|
|
482
|
+
PlutusV2 = 1,
|
|
483
|
+
PlutusV3 = 2,
|
|
484
484
|
}
|
|
485
485
|
/**
|
|
486
486
|
*/
|
|
487
|
-
export enum
|
|
488
|
-
|
|
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
|
|
493
|
-
|
|
494
|
-
|
|
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
|
-
|
|
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
|
*
|