@dashevo/wasm-dpp 0.25.0-dev.17 → 0.25.0-dev.19

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.
@@ -282,19 +282,53 @@ function __wbg_adapter_56(arg0, arg1, arg2) {
282
282
  wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h88b94080a33d3469(arg0, arg1, addHeapObject(arg2));
283
283
  }
284
284
 
285
+ function _assertClass(instance, klass) {
286
+ if (!(instance instanceof klass)) {
287
+ throw new Error("expected instance of ".concat(klass.name));
288
+ }
289
+
290
+ return instance.ptr;
291
+ }
292
+
293
+ let stack_pointer = 128;
294
+
295
+ function addBorrowedObject(obj) {
296
+ if (stack_pointer == 1) throw new Error('out of js stack');
297
+ heap[--stack_pointer] = obj;
298
+ return stack_pointer;
299
+ }
300
+
285
301
  function passArray8ToWasm0(arg, malloc) {
286
302
  const ptr = malloc(arg.length * 1) >>> 0;
287
303
  getUint8Memory0().set(arg, ptr / 1);
288
304
  WASM_VECTOR_LEN = arg.length;
289
305
  return ptr;
290
306
  }
307
+ /**
308
+ * @param {Uint8Array} bytes
309
+ * @returns {any}
310
+ */
291
311
 
292
- function _assertClass(instance, klass) {
293
- if (!(instance instanceof klass)) {
294
- throw new Error("expected instance of ".concat(klass.name));
295
- }
296
312
 
297
- return instance.ptr;
313
+ function deserializeConsensusError(bytes) {
314
+ try {
315
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
316
+
317
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
318
+ const len0 = WASM_VECTOR_LEN;
319
+ wasm.deserializeConsensusError(retptr, ptr0, len0);
320
+ var r0 = getInt32Memory0()[retptr / 4 + 0];
321
+ var r1 = getInt32Memory0()[retptr / 4 + 1];
322
+ var r2 = getInt32Memory0()[retptr / 4 + 2];
323
+
324
+ if (r2) {
325
+ throw takeObject(r1);
326
+ }
327
+
328
+ return takeObject(r0);
329
+ } finally {
330
+ wasm.__wbindgen_add_to_stack_pointer(16);
331
+ }
298
332
  }
299
333
 
300
334
  let cachedUint32Memory0 = null;
@@ -307,18 +341,6 @@ function getUint32Memory0() {
307
341
  return cachedUint32Memory0;
308
342
  }
309
343
 
310
- function passArrayJsValueToWasm0(array, malloc) {
311
- const ptr = malloc(array.length * 4) >>> 0;
312
- const mem = getUint32Memory0();
313
-
314
- for (let i = 0; i < array.length; i++) {
315
- mem[ptr / 4 + i] = addHeapObject(array[i]);
316
- }
317
-
318
- WASM_VECTOR_LEN = array.length;
319
- return ptr;
320
- }
321
-
322
344
  function getArrayJsValueFromWasm0(ptr, len) {
323
345
  ptr = ptr >>> 0;
324
346
  const mem = getUint32Memory0();
@@ -332,51 +354,30 @@ function getArrayJsValueFromWasm0(ptr, len) {
332
354
  return result;
333
355
  }
334
356
 
335
- let stack_pointer = 128;
336
-
337
- function addBorrowedObject(obj) {
338
- if (stack_pointer == 1) throw new Error('out of js stack');
339
- heap[--stack_pointer] = obj;
340
- return stack_pointer;
341
- }
342
-
343
357
  function getArrayU8FromWasm0(ptr, len) {
344
358
  ptr = ptr >>> 0;
345
359
  return getUint8Memory0().subarray(ptr / 1, ptr / 1 + len);
346
360
  }
347
-
348
- function handleError(f, args) {
349
- try {
350
- return f.apply(this, args);
351
- } catch (e) {
352
- wasm.__wbindgen_exn_store(addHeapObject(e));
353
- }
354
- }
355
361
  /**
356
- * @param {Uint8Array} bytes
357
- * @returns {any}
362
+ * @returns {number}
358
363
  */
359
364
 
360
365
 
361
- function deserializeConsensusError(bytes) {
362
- try {
363
- const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
364
-
365
- const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
366
- const len0 = WASM_VECTOR_LEN;
367
- wasm.deserializeConsensusError(retptr, ptr0, len0);
368
- var r0 = getInt32Memory0()[retptr / 4 + 0];
369
- var r1 = getInt32Memory0()[retptr / 4 + 1];
370
- var r2 = getInt32Memory0()[retptr / 4 + 2];
366
+ function getLatestProtocolVersion() {
367
+ const ret = wasm.getLatestProtocolVersion();
368
+ return ret >>> 0;
369
+ }
371
370
 
372
- if (r2) {
373
- throw takeObject(r1);
374
- }
371
+ function passArrayJsValueToWasm0(array, malloc) {
372
+ const ptr = malloc(array.length * 4) >>> 0;
373
+ const mem = getUint32Memory0();
375
374
 
376
- return takeObject(r0);
377
- } finally {
378
- wasm.__wbindgen_add_to_stack_pointer(16);
375
+ for (let i = 0; i < array.length; i++) {
376
+ mem[ptr / 4 + i] = addHeapObject(array[i]);
379
377
  }
378
+
379
+ WASM_VECTOR_LEN = array.length;
380
+ return ptr;
380
381
  }
381
382
  /**
382
383
  * @param {any} raw_parameters
@@ -409,6 +410,14 @@ function passArray32ToWasm0(arg, malloc) {
409
410
  WASM_VECTOR_LEN = arg.length;
410
411
  return ptr;
411
412
  }
413
+
414
+ function handleError(f, args) {
415
+ try {
416
+ return f.apply(this, args);
417
+ } catch (e) {
418
+ wasm.__wbindgen_exn_store(addHeapObject(e));
419
+ }
420
+ }
412
421
  /**
413
422
  * @param {any} contract_id
414
423
  * @param {any} owner_id
@@ -443,15 +452,6 @@ function generateDocumentId(contract_id, owner_id, document_type, entropy) {
443
452
  heap[stack_pointer++] = undefined;
444
453
  }
445
454
  }
446
- /**
447
- * @returns {number}
448
- */
449
-
450
-
451
- function getLatestProtocolVersion() {
452
- const ret = wasm.getLatestProtocolVersion();
453
- return ret >>> 0;
454
- }
455
455
 
456
456
  function __wbg_adapter_1188(arg0, arg1, arg2, arg3) {
457
457
  wasm.wasm_bindgen__convert__closures__invoke2_mut__h49226b0a1f1efbff(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
@@ -13059,7 +13059,7 @@ class InvalidInitialRevisionError {
13059
13059
 
13060
13060
  var ptr0 = document.__destroy_into_raw();
13061
13061
 
13062
- const ret = wasm.invalidinitialrevisionerror_new(ptr0);
13062
+ const ret = wasm.documentnorevisionerror_new(ptr0);
13063
13063
  return InvalidInitialRevisionError.__wrap(ret);
13064
13064
  }
13065
13065
  /**
@@ -13068,7 +13068,7 @@ class InvalidInitialRevisionError {
13068
13068
 
13069
13069
 
13070
13070
  getDocument() {
13071
- const ret = wasm.invalidinitialrevisionerror_getDocument(this.__wbg_ptr);
13071
+ const ret = wasm.documentnorevisionerror_getDocument(this.__wbg_ptr);
13072
13072
  return Document.__wrap(ret);
13073
13073
  }
13074
13074
 
@@ -13415,7 +13415,7 @@ class InvalidStateTransitionError {
13415
13415
  try {
13416
13416
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
13417
13417
 
13418
- wasm.invalidstatetransitionerror_getErrors(retptr, this.__wbg_ptr);
13418
+ wasm.invalididentityerror_getErrors(retptr, this.__wbg_ptr);
13419
13419
  var r0 = getInt32Memory0()[retptr / 4 + 0];
13420
13420
  var r1 = getInt32Memory0()[retptr / 4 + 1];
13421
13421
  var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
@@ -13433,7 +13433,7 @@ class InvalidStateTransitionError {
13433
13433
 
13434
13434
 
13435
13435
  getRawStateTransition() {
13436
- const ret = wasm.invalidstatetransitionerror_getRawStateTransition(this.__wbg_ptr);
13436
+ const ret = wasm.invalididentityerror_getRawIdentity(this.__wbg_ptr);
13437
13437
  return takeObject(ret);
13438
13438
  }
13439
13439
 
@@ -14771,7 +14771,7 @@ class PlatformValueError {
14771
14771
  try {
14772
14772
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
14773
14773
 
14774
- wasm.datacontractgenericerror_getMessage(retptr, this.__wbg_ptr);
14774
+ wasm.platformvalueerror_getMessage(retptr, this.__wbg_ptr);
14775
14775
  var r0 = getInt32Memory0()[retptr / 4 + 0];
14776
14776
  var r1 = getInt32Memory0()[retptr / 4 + 1];
14777
14777
  deferred1_0 = r0;
@@ -15133,7 +15133,7 @@ class RevisionAbsentError {
15133
15133
 
15134
15134
  var ptr0 = document.__destroy_into_raw();
15135
15135
 
15136
- const ret = wasm.revisionabsenterror_new(ptr0);
15136
+ const ret = wasm.documentnorevisionerror_new(ptr0);
15137
15137
  return RevisionAbsentError.__wrap(ret);
15138
15138
  }
15139
15139
  /**
@@ -15142,7 +15142,7 @@ class RevisionAbsentError {
15142
15142
 
15143
15143
 
15144
15144
  getDocument() {
15145
- const ret = wasm.revisionabsenterror_getDocument(this.__wbg_ptr);
15145
+ const ret = wasm.documentnorevisionerror_getDocument(this.__wbg_ptr);
15146
15146
  return Document.__wrap(ret);
15147
15147
  }
15148
15148
 
@@ -15616,7 +15616,7 @@ class TryingToReplaceImmutableDocumentError {
15616
15616
 
15617
15617
  var ptr0 = document.__destroy_into_raw();
15618
15618
 
15619
- const ret = wasm.tryingtoreplaceimmutabledocumenterror_new(ptr0);
15619
+ const ret = wasm.tryingtodeleteimmutabledocumenterror_new(ptr0);
15620
15620
  return TryingToReplaceImmutableDocumentError.__wrap(ret);
15621
15621
  }
15622
15622
 
@@ -16260,72 +16260,62 @@ function __wbg_get_imports() {
16260
16260
  takeObject(arg0);
16261
16261
  };
16262
16262
 
16263
+ imports.wbg.__wbindgen_is_string = function (arg0) {
16264
+ const ret = typeof getObject(arg0) === 'string';
16265
+ return ret;
16266
+ };
16267
+
16263
16268
  imports.wbg.__wbindgen_string_new = function (arg0, arg1) {
16264
16269
  const ret = getStringFromWasm0(arg0, arg1);
16265
16270
  return addHeapObject(ret);
16266
16271
  };
16267
16272
 
16268
- imports.wbg.__wbindgen_string_get = function (arg0, arg1) {
16269
- const obj = getObject(arg1);
16270
- const ret = typeof obj === 'string' ? obj : undefined;
16271
- var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
16272
- var len1 = WASM_VECTOR_LEN;
16273
- getInt32Memory0()[arg0 / 4 + 1] = len1;
16274
- getInt32Memory0()[arg0 / 4 + 0] = ptr1;
16275
- };
16273
+ imports.wbg.__wbg_datacontractcreatetransition_new = function (arg0) {
16274
+ const ret = DataContractCreateTransition.__wrap(arg0);
16276
16275
 
16277
- imports.wbg.__wbindgen_is_function = function (arg0) {
16278
- const ret = typeof getObject(arg0) === 'function';
16279
- return ret;
16276
+ return addHeapObject(ret);
16280
16277
  };
16281
16278
 
16282
- imports.wbg.__wbindgen_is_null = function (arg0) {
16283
- const ret = getObject(arg0) === null;
16284
- return ret;
16285
- };
16279
+ imports.wbg.__wbg_datacontractupdatetransition_new = function (arg0) {
16280
+ const ret = DataContractUpdateTransition.__wrap(arg0);
16286
16281
 
16287
- imports.wbg.__wbindgen_is_undefined = function (arg0) {
16288
- const ret = getObject(arg0) === undefined;
16289
- return ret;
16282
+ return addHeapObject(ret);
16290
16283
  };
16291
16284
 
16292
- imports.wbg.__wbindgen_error_new = function (arg0, arg1) {
16293
- const ret = new Error(getStringFromWasm0(arg0, arg1));
16285
+ imports.wbg.__wbg_documentsbatchtransition_new = function (arg0) {
16286
+ const ret = DocumentsBatchTransition.__wrap(arg0);
16287
+
16294
16288
  return addHeapObject(ret);
16295
16289
  };
16296
16290
 
16297
- imports.wbg.__wbg_balanceisnotenougherror_new = function (arg0) {
16298
- const ret = BalanceIsNotEnoughError.__wrap(arg0);
16291
+ imports.wbg.__wbg_identitycreatetransition_new = function (arg0) {
16292
+ const ret = IdentityCreateTransition.__wrap(arg0);
16299
16293
 
16300
16294
  return addHeapObject(ret);
16301
16295
  };
16302
16296
 
16303
- imports.wbg.__wbg_verifySignature_d834cbf4122363e7 = function () {
16304
- return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
16305
- const ret = getObject(arg0).verifySignature(getArrayU8FromWasm0(arg1, arg2), getArrayU8FromWasm0(arg3, arg4), getArrayU8FromWasm0(arg5, arg6));
16306
- return ret;
16307
- }, arguments);
16297
+ imports.wbg.__wbg_identitytopuptransition_new = function (arg0) {
16298
+ const ret = IdentityTopUpTransition.__wrap(arg0);
16299
+
16300
+ return addHeapObject(ret);
16308
16301
  };
16309
16302
 
16310
- imports.wbg.__wbg_privateKeyToPublicKey_a8c7c0801893c959 = function () {
16311
- return handleError(function (arg0, arg1, arg2) {
16312
- const ret = getObject(arg0).privateKeyToPublicKey(getArrayU8FromWasm0(arg1, arg2));
16313
- return addHeapObject(ret);
16314
- }, arguments);
16303
+ imports.wbg.__wbg_identityupdatetransition_new = function (arg0) {
16304
+ const ret = IdentityUpdateTransition.__wrap(arg0);
16305
+
16306
+ return addHeapObject(ret);
16315
16307
  };
16316
16308
 
16317
- imports.wbg.__wbg_sign_2e214e5975b9bc30 = function () {
16318
- return handleError(function (arg0, arg1, arg2, arg3, arg4) {
16319
- const ret = getObject(arg0).sign(getArrayU8FromWasm0(arg1, arg2), getArrayU8FromWasm0(arg3, arg4));
16320
- return addHeapObject(ret);
16321
- }, arguments);
16309
+ imports.wbg.__wbg_identitycredittransfertransition_new = function (arg0) {
16310
+ const ret = IdentityCreditTransferTransition.__wrap(arg0);
16311
+
16312
+ return addHeapObject(ret);
16322
16313
  };
16323
16314
 
16324
- imports.wbg.__wbg_generate_1f42caa3e9e2b460 = function () {
16325
- return handleError(function (arg0) {
16326
- const ret = getObject(arg0).generate();
16327
- return addHeapObject(ret);
16328
- }, arguments);
16315
+ imports.wbg.__wbg_invalidstatetransitionerror_new = function (arg0) {
16316
+ const ret = InvalidStateTransitionError.__wrap(arg0);
16317
+
16318
+ return addHeapObject(ret);
16329
16319
  };
16330
16320
 
16331
16321
  imports.wbg.__wbg_from_1240938ee473cab4 = function (arg0, arg1) {
@@ -16365,6 +16355,11 @@ function __wbg_get_imports() {
16365
16355
  return ret;
16366
16356
  };
16367
16357
 
16358
+ imports.wbg.__wbindgen_is_undefined = function (arg0) {
16359
+ const ret = getObject(arg0) === undefined;
16360
+ return ret;
16361
+ };
16362
+
16368
16363
  imports.wbg.__wbindgen_is_object = function (arg0) {
16369
16364
  const val = getObject(arg0);
16370
16365
  const ret = typeof val === 'object' && val !== null;
@@ -16375,68 +16370,87 @@ function __wbg_get_imports() {
16375
16370
  (0, _lodash.set)(getObject(arg0), getStringFromWasm0(arg1, arg2), takeObject(arg3));
16376
16371
  };
16377
16372
 
16373
+ imports.wbg.__wbindgen_is_null = function (arg0) {
16374
+ const ret = getObject(arg0) === null;
16375
+ return ret;
16376
+ };
16377
+
16378
16378
  imports.wbg.__wbindgen_object_clone_ref = function (arg0) {
16379
16379
  const ret = getObject(arg0);
16380
16380
  return addHeapObject(ret);
16381
16381
  };
16382
16382
 
16383
+ imports.wbg.__wbindgen_string_get = function (arg0, arg1) {
16384
+ const obj = getObject(arg1);
16385
+ const ret = typeof obj === 'string' ? obj : undefined;
16386
+ var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
16387
+ var len1 = WASM_VECTOR_LEN;
16388
+ getInt32Memory0()[arg0 / 4 + 1] = len1;
16389
+ getInt32Memory0()[arg0 / 4 + 0] = ptr1;
16390
+ };
16391
+
16383
16392
  imports.wbg.__wbg_invalidactionnameerror_new = function (arg0) {
16384
16393
  const ret = InvalidActionNameError.__wrap(arg0);
16385
16394
 
16386
16395
  return addHeapObject(ret);
16387
16396
  };
16388
16397
 
16389
- imports.wbg.__wbg_datacontract_new = function (arg0) {
16390
- const ret = DataContract.__wrap(arg0);
16398
+ imports.wbg.__wbg_documenttransition_new = function (arg0) {
16399
+ const ret = DocumentTransition.__wrap(arg0);
16391
16400
 
16392
16401
  return addHeapObject(ret);
16393
16402
  };
16394
16403
 
16395
- imports.wbg.__wbg_datacontractcreatetransition_new = function (arg0) {
16396
- const ret = DataContractCreateTransition.__wrap(arg0);
16404
+ imports.wbg.__wbg_datacontract_new = function (arg0) {
16405
+ const ret = DataContract.__wrap(arg0);
16397
16406
 
16398
16407
  return addHeapObject(ret);
16399
16408
  };
16400
16409
 
16401
- imports.wbg.__wbg_datacontractupdatetransition_new = function (arg0) {
16402
- const ret = DataContractUpdateTransition.__wrap(arg0);
16410
+ imports.wbg.__wbg_datacontractnotpresentnotconsensuserror_new = function (arg0) {
16411
+ const ret = DataContractNotPresentNotConsensusError.__wrap(arg0);
16403
16412
 
16404
16413
  return addHeapObject(ret);
16405
16414
  };
16406
16415
 
16407
- imports.wbg.__wbg_documentsbatchtransition_new = function (arg0) {
16408
- const ret = DocumentsBatchTransition.__wrap(arg0);
16416
+ imports.wbg.__wbg_platformvalueerror_new = function (arg0) {
16417
+ const ret = PlatformValueError.__wrap(arg0);
16409
16418
 
16410
16419
  return addHeapObject(ret);
16411
16420
  };
16412
16421
 
16413
- imports.wbg.__wbg_identitycreatetransition_new = function (arg0) {
16414
- const ret = IdentityCreateTransition.__wrap(arg0);
16415
-
16416
- return addHeapObject(ret);
16422
+ imports.wbg.__wbindgen_number_get = function (arg0, arg1) {
16423
+ const obj = getObject(arg1);
16424
+ const ret = typeof obj === 'number' ? obj : undefined;
16425
+ getFloat64Memory0()[arg0 / 8 + 1] = isLikeNone(ret) ? 0 : ret;
16426
+ getInt32Memory0()[arg0 / 4 + 0] = !isLikeNone(ret);
16417
16427
  };
16418
16428
 
16419
- imports.wbg.__wbg_identitytopuptransition_new = function (arg0) {
16420
- const ret = IdentityTopUpTransition.__wrap(arg0);
16429
+ imports.wbg.__wbg_unknownassetlockprooftypeerror_new = function (arg0) {
16430
+ const ret = UnknownAssetLockProofTypeError.__wrap(arg0);
16421
16431
 
16422
16432
  return addHeapObject(ret);
16423
16433
  };
16424
16434
 
16425
- imports.wbg.__wbg_identityupdatetransition_new = function (arg0) {
16426
- const ret = IdentityUpdateTransition.__wrap(arg0);
16435
+ imports.wbg.__wbindgen_is_function = function (arg0) {
16436
+ const ret = typeof getObject(arg0) === 'function';
16437
+ return ret;
16438
+ };
16439
+
16440
+ imports.wbg.__wbg_instantassetlockproof_new = function (arg0) {
16441
+ const ret = InstantAssetLockProof.__wrap(arg0);
16427
16442
 
16428
16443
  return addHeapObject(ret);
16429
16444
  };
16430
16445
 
16431
- imports.wbg.__wbg_identitycredittransfertransition_new = function (arg0) {
16432
- const ret = IdentityCreditTransferTransition.__wrap(arg0);
16446
+ imports.wbg.__wbg_chainassetlockproof_new = function (arg0) {
16447
+ const ret = ChainAssetLockProof.__wrap(arg0);
16433
16448
 
16434
16449
  return addHeapObject(ret);
16435
16450
  };
16436
16451
 
16437
- imports.wbg.__wbg_invalidstatetransitionerror_new = function (arg0) {
16438
- const ret = InvalidStateTransitionError.__wrap(arg0);
16439
-
16452
+ imports.wbg.__wbindgen_error_new = function (arg0, arg1) {
16453
+ const ret = new Error(getStringFromWasm0(arg0, arg1));
16440
16454
  return addHeapObject(ret);
16441
16455
  };
16442
16456
 
@@ -16446,29 +16460,29 @@ function __wbg_get_imports() {
16446
16460
  return ret;
16447
16461
  };
16448
16462
 
16449
- imports.wbg.__wbindgen_number_get = function (arg0, arg1) {
16450
- const obj = getObject(arg1);
16451
- const ret = typeof obj === 'number' ? obj : undefined;
16452
- getFloat64Memory0()[arg0 / 8 + 1] = isLikeNone(ret) ? 0 : ret;
16453
- getInt32Memory0()[arg0 / 4 + 0] = !isLikeNone(ret);
16463
+ imports.wbg.__wbindgen_is_bigint = function (arg0) {
16464
+ const ret = typeof getObject(arg0) === 'bigint';
16465
+ return ret;
16454
16466
  };
16455
16467
 
16456
- imports.wbg.__wbg_unknownassetlockprooftypeerror_new = function (arg0) {
16457
- const ret = UnknownAssetLockProofTypeError.__wrap(arg0);
16458
-
16468
+ imports.wbg.__wbindgen_bigint_from_i64 = function (arg0) {
16469
+ const ret = arg0;
16459
16470
  return addHeapObject(ret);
16460
16471
  };
16461
16472
 
16462
- imports.wbg.__wbg_instantassetlockproof_new = function (arg0) {
16463
- const ret = InstantAssetLockProof.__wrap(arg0);
16473
+ imports.wbg.__wbindgen_jsval_eq = function (arg0, arg1) {
16474
+ const ret = getObject(arg0) === getObject(arg1);
16475
+ return ret;
16476
+ };
16464
16477
 
16478
+ imports.wbg.__wbindgen_bigint_from_u64 = function (arg0) {
16479
+ const ret = BigInt.asUintN(64, arg0);
16465
16480
  return addHeapObject(ret);
16466
16481
  };
16467
16482
 
16468
- imports.wbg.__wbg_chainassetlockproof_new = function (arg0) {
16469
- const ret = ChainAssetLockProof.__wrap(arg0);
16470
-
16471
- return addHeapObject(ret);
16483
+ imports.wbg.__wbindgen_in = function (arg0, arg1) {
16484
+ const ret = (getObject(arg0) in getObject(arg1));
16485
+ return ret;
16472
16486
  };
16473
16487
 
16474
16488
  imports.wbg.__wbg_documentalreadyexistserror_new = function (arg0) {
@@ -16549,29 +16563,17 @@ function __wbg_get_imports() {
16549
16563
  return addHeapObject(ret);
16550
16564
  };
16551
16565
 
16552
- imports.wbg.__wbindgen_is_bigint = function (arg0) {
16553
- const ret = typeof getObject(arg0) === 'bigint';
16554
- return ret;
16555
- };
16556
-
16557
- imports.wbg.__wbindgen_bigint_from_i64 = function (arg0) {
16558
- const ret = arg0;
16559
- return addHeapObject(ret);
16560
- };
16561
-
16562
- imports.wbg.__wbindgen_jsval_eq = function (arg0, arg1) {
16563
- const ret = getObject(arg0) === getObject(arg1);
16564
- return ret;
16565
- };
16566
+ imports.wbg.__wbg_balanceisnotenougherror_new = function (arg0) {
16567
+ const ret = BalanceIsNotEnoughError.__wrap(arg0);
16566
16568
 
16567
- imports.wbg.__wbindgen_bigint_from_u64 = function (arg0) {
16568
- const ret = BigInt.asUintN(64, arg0);
16569
16569
  return addHeapObject(ret);
16570
16570
  };
16571
16571
 
16572
- imports.wbg.__wbindgen_in = function (arg0, arg1) {
16573
- const ret = (getObject(arg0) in getObject(arg1));
16574
- return ret;
16572
+ imports.wbg.__wbg_generate_1f42caa3e9e2b460 = function () {
16573
+ return handleError(function (arg0) {
16574
+ const ret = getObject(arg0).generate();
16575
+ return addHeapObject(ret);
16576
+ }, arguments);
16575
16577
  };
16576
16578
 
16577
16579
  imports.wbg.__wbg_invaliddocumenttypeindatacontracterror_new = function (arg0) {
@@ -16586,20 +16588,36 @@ function __wbg_get_imports() {
16586
16588
  return addHeapObject(ret);
16587
16589
  };
16588
16590
 
16589
- imports.wbg.__wbg_documenttransition_new = function (arg0) {
16590
- const ret = DocumentTransition.__wrap(arg0);
16591
+ imports.wbg.__wbg_invalididentityerror_new = function (arg0) {
16592
+ const ret = InvalidIdentityError.__wrap(arg0);
16591
16593
 
16592
16594
  return addHeapObject(ret);
16593
16595
  };
16594
16596
 
16595
- imports.wbg.__wbg_invalididentityerror_new = function (arg0) {
16596
- const ret = InvalidIdentityError.__wrap(arg0);
16597
+ imports.wbg.__wbg_document_new = function (arg0) {
16598
+ const ret = Document.__wrap(arg0);
16597
16599
 
16598
16600
  return addHeapObject(ret);
16599
16601
  };
16600
16602
 
16601
- imports.wbg.__wbindgen_is_string = function (arg0) {
16602
- const ret = typeof getObject(arg0) === 'string';
16603
+ imports.wbg.__wbg_identitypublickeywithwitness_new = function (arg0) {
16604
+ const ret = IdentityPublicKeyWithWitness.__wrap(arg0);
16605
+
16606
+ return addHeapObject(ret);
16607
+ };
16608
+
16609
+ imports.wbg.__wbg_buffer_a2f9733fd9333302 = function (arg0) {
16610
+ const ret = getObject(arg0).buffer;
16611
+ return addHeapObject(ret);
16612
+ };
16613
+
16614
+ imports.wbg.__wbg_byteOffset_82ed8366a41aeb88 = function (arg0) {
16615
+ const ret = getObject(arg0).byteOffset;
16616
+ return ret;
16617
+ };
16618
+
16619
+ imports.wbg.__wbg_length_ef51e3e9b7ed1303 = function (arg0) {
16620
+ const ret = getObject(arg0).length;
16603
16621
  return ret;
16604
16622
  };
16605
16623
 
@@ -16609,10 +16627,25 @@ function __wbg_get_imports() {
16609
16627
  return addHeapObject(ret);
16610
16628
  };
16611
16629
 
16612
- imports.wbg.__wbg_document_new = function (arg0) {
16613
- const ret = Document.__wrap(arg0);
16630
+ imports.wbg.__wbg_verifySignature_d834cbf4122363e7 = function () {
16631
+ return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
16632
+ const ret = getObject(arg0).verifySignature(getArrayU8FromWasm0(arg1, arg2), getArrayU8FromWasm0(arg3, arg4), getArrayU8FromWasm0(arg5, arg6));
16633
+ return ret;
16634
+ }, arguments);
16635
+ };
16614
16636
 
16615
- return addHeapObject(ret);
16637
+ imports.wbg.__wbg_privateKeyToPublicKey_a8c7c0801893c959 = function () {
16638
+ return handleError(function (arg0, arg1, arg2) {
16639
+ const ret = getObject(arg0).privateKeyToPublicKey(getArrayU8FromWasm0(arg1, arg2));
16640
+ return addHeapObject(ret);
16641
+ }, arguments);
16642
+ };
16643
+
16644
+ imports.wbg.__wbg_sign_2e214e5975b9bc30 = function () {
16645
+ return handleError(function (arg0, arg1, arg2, arg3, arg4) {
16646
+ const ret = getObject(arg0).sign(getArrayU8FromWasm0(arg1, arg2), getArrayU8FromWasm0(arg3, arg4));
16647
+ return addHeapObject(ret);
16648
+ }, arguments);
16616
16649
  };
16617
16650
 
16618
16651
  imports.wbg.__wbg_datacontracthavenewuniqueindexerror_new = function (arg0) {
@@ -17185,39 +17218,6 @@ function __wbg_get_imports() {
17185
17218
  return addHeapObject(ret);
17186
17219
  };
17187
17220
 
17188
- imports.wbg.__wbg_datacontractnotpresentnotconsensuserror_new = function (arg0) {
17189
- const ret = DataContractNotPresentNotConsensusError.__wrap(arg0);
17190
-
17191
- return addHeapObject(ret);
17192
- };
17193
-
17194
- imports.wbg.__wbg_platformvalueerror_new = function (arg0) {
17195
- const ret = PlatformValueError.__wrap(arg0);
17196
-
17197
- return addHeapObject(ret);
17198
- };
17199
-
17200
- imports.wbg.__wbg_identitypublickeywithwitness_new = function (arg0) {
17201
- const ret = IdentityPublicKeyWithWitness.__wrap(arg0);
17202
-
17203
- return addHeapObject(ret);
17204
- };
17205
-
17206
- imports.wbg.__wbg_buffer_a2f9733fd9333302 = function (arg0) {
17207
- const ret = getObject(arg0).buffer;
17208
- return addHeapObject(ret);
17209
- };
17210
-
17211
- imports.wbg.__wbg_byteOffset_82ed8366a41aeb88 = function (arg0) {
17212
- const ret = getObject(arg0).byteOffset;
17213
- return ret;
17214
- };
17215
-
17216
- imports.wbg.__wbg_length_ef51e3e9b7ed1303 = function (arg0) {
17217
- const ret = getObject(arg0).length;
17218
- return ret;
17219
- };
17220
-
17221
17221
  imports.wbg.__wbindgen_cb_drop = function (arg0) {
17222
17222
  const obj = takeObject(arg0).original;
17223
17223
 
@@ -17697,8 +17697,8 @@ function __wbg_get_imports() {
17697
17697
  return addHeapObject(ret);
17698
17698
  };
17699
17699
 
17700
- imports.wbg.__wbindgen_closure_wrapper2427 = function (arg0, arg1, arg2) {
17701
- const ret = makeMutClosure(arg0, arg1, 247, __wbg_adapter_56);
17700
+ imports.wbg.__wbindgen_closure_wrapper2484 = function (arg0, arg1, arg2) {
17701
+ const ret = makeMutClosure(arg0, arg1, 257, __wbg_adapter_56);
17702
17702
  return addHeapObject(ret);
17703
17703
  };
17704
17704