@wgb5445/aptos-intent-npm 0.0.8 → 0.0.9

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/cjs/entry.js CHANGED
@@ -117,105 +117,6 @@ function getInt32Memory0() {
117
117
  return cachedInt32Memory0;
118
118
  }
119
119
 
120
- function debugString(val) {
121
- // primitive types
122
- const type = typeof val;
123
- if (type == 'number' || type == 'boolean' || val == null) {
124
- return `${val}`;
125
- }
126
- if (type == 'string') {
127
- return `"${val}"`;
128
- }
129
- if (type == 'symbol') {
130
- const description = val.description;
131
- if (description == null) {
132
- return 'Symbol';
133
- } else {
134
- return `Symbol(${description})`;
135
- }
136
- }
137
- if (type == 'function') {
138
- const name = val.name;
139
- if (typeof name == 'string' && name.length > 0) {
140
- return `Function(${name})`;
141
- } else {
142
- return 'Function';
143
- }
144
- }
145
- // objects
146
- if (Array.isArray(val)) {
147
- const length = val.length;
148
- let debug = '[';
149
- if (length > 0) {
150
- debug += debugString(val[0]);
151
- }
152
- for(let i = 1; i < length; i++) {
153
- debug += ', ' + debugString(val[i]);
154
- }
155
- debug += ']';
156
- return debug;
157
- }
158
- // Test for built-in
159
- const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
160
- let className;
161
- if (builtInMatches.length > 1) {
162
- className = builtInMatches[1];
163
- } else {
164
- // Failed to match the standard '[object ClassName]'
165
- return toString.call(val);
166
- }
167
- if (className == 'Object') {
168
- // we're a user defined class or Object
169
- // JSON.stringify avoids problems with cycles, and is generally much
170
- // easier than looping through ownProperties of `val`.
171
- try {
172
- return 'Object(' + JSON.stringify(val) + ')';
173
- } catch (_) {
174
- return 'Object';
175
- }
176
- }
177
- // errors
178
- if (val instanceof Error) {
179
- return `${val.name}: ${val.message}\n${val.stack}`;
180
- }
181
- // TODO we could test for more things here, like `Set`s and `Map`s.
182
- return className;
183
- }
184
-
185
- const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
186
- ? { register: () => {}, unregister: () => {} }
187
- : new FinalizationRegistry(state => {
188
- wasm.__wbindgen_export_2.get(state.dtor)(state.a, state.b);
189
- });
190
-
191
- function makeMutClosure(arg0, arg1, dtor, f) {
192
- const state = { a: arg0, b: arg1, cnt: 1, dtor };
193
- const real = (...args) => {
194
- // First up with a closure we increment the internal reference
195
- // count. This ensures that the Rust closure environment won't
196
- // be deallocated while we're invoking it.
197
- state.cnt++;
198
- const a = state.a;
199
- state.a = 0;
200
- try {
201
- return f(a, state.b, ...args);
202
- } finally {
203
- if (--state.cnt === 0) {
204
- wasm.__wbindgen_export_2.get(state.dtor)(a, state.b);
205
- CLOSURE_DTORS.unregister(state);
206
- } else {
207
- state.a = a;
208
- }
209
- }
210
- };
211
- real.original = state;
212
- CLOSURE_DTORS.register(real, state, state);
213
- return real;
214
- }
215
- function __wbg_adapter_24(arg0, arg1, arg2) {
216
- wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h09acdaa8b02601d5(arg0, arg1, addHeapObject(arg2));
217
- }
218
-
219
120
  let cachedUint32Memory0 = null;
220
121
 
221
122
  function getUint32Memory0() {
@@ -257,44 +158,54 @@ function passArray8ToWasm0(arg, malloc) {
257
158
  WASM_VECTOR_LEN = arg.length;
258
159
  return ptr;
259
160
  }
260
-
261
- function handleError(f, args) {
161
+ /**
162
+ * @param {Uint8Array} script
163
+ * @returns {(BatchedFunctionCall)[]}
164
+ */
165
+ function generate_intent_payload_wasm(script) {
262
166
  try {
263
- return f.apply(this, args);
264
- } catch (e) {
265
- wasm.__wbindgen_exn_store(addHeapObject(e));
167
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
168
+ const ptr0 = passArray8ToWasm0(script, wasm.__wbindgen_malloc);
169
+ const len0 = WASM_VECTOR_LEN;
170
+ wasm.generate_intent_payload_wasm(retptr, ptr0, len0);
171
+ var r0 = getInt32Memory0()[retptr / 4 + 0];
172
+ var r1 = getInt32Memory0()[retptr / 4 + 1];
173
+ var r2 = getInt32Memory0()[retptr / 4 + 2];
174
+ var r3 = getInt32Memory0()[retptr / 4 + 3];
175
+ if (r3) {
176
+ throw takeObject(r2);
177
+ }
178
+ var v2 = getArrayJsValueFromWasm0(r0, r1).slice();
179
+ wasm.__wbindgen_free(r0, r1 * 4, 4);
180
+ return v2;
181
+ } finally {
182
+ wasm.__wbindgen_add_to_stack_pointer(16);
266
183
  }
267
184
  }
268
- function __wbg_adapter_87(arg0, arg1, arg2, arg3) {
269
- wasm.wasm_bindgen__convert__closures__invoke2_mut__h4c0838795c3445c5(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
270
- }
271
185
 
272
- /**
273
- */
274
- const ArgumentOperation = Object.freeze({ Move:0,"0":"Move",Copy:1,"1":"Copy",Borrow:2,"2":"Borrow",BorrowMut:3,"3":"BorrowMut", });
275
186
  /**
276
187
  * Arguments for each function.
277
188
  */
278
189
  const BatchArgumentType = Object.freeze({ Raw:0,"0":"Raw",Signer:1,"1":"Signer",PreviousResult:2,"2":"PreviousResult", });
279
190
 
280
- const BatchArgumentFinalization = (typeof FinalizationRegistry === 'undefined')
191
+ const BatchArgumentWASMFinalization = (typeof FinalizationRegistry === 'undefined')
281
192
  ? { register: () => {}, unregister: () => {} }
282
- : new FinalizationRegistry(ptr => wasm.__wbg_batchargument_free(ptr >>> 0));
193
+ : new FinalizationRegistry(ptr => wasm.__wbg_batchargumentwasm_free(ptr >>> 0));
283
194
  /**
284
195
  * Arguments for each function. Wasm bindgen only support C-style enum so use option to work around.
285
196
  */
286
- class BatchArgument {
197
+ class BatchArgumentWASM {
287
198
 
288
199
  static __wrap(ptr) {
289
200
  ptr = ptr >>> 0;
290
- const obj = Object.create(BatchArgument.prototype);
201
+ const obj = Object.create(BatchArgumentWASM.prototype);
291
202
  obj.__wbg_ptr = ptr;
292
- BatchArgumentFinalization.register(obj, obj.__wbg_ptr, obj);
203
+ BatchArgumentWASMFinalization.register(obj, obj.__wbg_ptr, obj);
293
204
  return obj;
294
205
  }
295
206
 
296
207
  static __unwrap(jsValue) {
297
- if (!(jsValue instanceof BatchArgument)) {
208
+ if (!(jsValue instanceof BatchArgumentWASM)) {
298
209
  return 0;
299
210
  }
300
211
  return jsValue.__destroy_into_raw();
@@ -303,82 +214,82 @@ class BatchArgument {
303
214
  __destroy_into_raw() {
304
215
  const ptr = this.__wbg_ptr;
305
216
  this.__wbg_ptr = 0;
306
- BatchArgumentFinalization.unregister(this);
217
+ BatchArgumentWASMFinalization.unregister(this);
307
218
  return ptr;
308
219
  }
309
220
 
310
221
  free() {
311
222
  const ptr = this.__destroy_into_raw();
312
- wasm.__wbg_batchargument_free(ptr);
223
+ wasm.__wbg_batchargumentwasm_free(ptr);
313
224
  }
314
225
  /**
315
226
  * @param {Uint8Array} bytes
316
- * @returns {BatchArgument}
227
+ * @returns {BatchArgumentWASM}
317
228
  */
318
229
  static new_bytes(bytes) {
319
230
  const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
320
231
  const len0 = WASM_VECTOR_LEN;
321
- const ret = wasm.batchargument_new_bytes(ptr0, len0);
322
- return BatchArgument.__wrap(ret);
232
+ const ret = wasm.batchargumentwasm_new_bytes(ptr0, len0);
233
+ return BatchArgumentWASM.__wrap(ret);
323
234
  }
324
235
  /**
325
236
  * @param {number} signer_idx
326
- * @returns {BatchArgument}
237
+ * @returns {BatchArgumentWASM}
327
238
  */
328
239
  static new_signer(signer_idx) {
329
- const ret = wasm.batchargument_new_signer(signer_idx);
330
- return BatchArgument.__wrap(ret);
240
+ const ret = wasm.batchargumentwasm_new_signer(signer_idx);
241
+ return BatchArgumentWASM.__wrap(ret);
331
242
  }
332
243
  /**
333
- * @returns {BatchArgument}
244
+ * @returns {BatchArgumentWASM}
334
245
  */
335
246
  borrow() {
336
247
  try {
337
248
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
338
- wasm.batchargument_borrow(retptr, this.__wbg_ptr);
249
+ wasm.batchargumentwasm_borrow(retptr, this.__wbg_ptr);
339
250
  var r0 = getInt32Memory0()[retptr / 4 + 0];
340
251
  var r1 = getInt32Memory0()[retptr / 4 + 1];
341
252
  var r2 = getInt32Memory0()[retptr / 4 + 2];
342
253
  if (r2) {
343
254
  throw takeObject(r1);
344
255
  }
345
- return BatchArgument.__wrap(r0);
256
+ return BatchArgumentWASM.__wrap(r0);
346
257
  } finally {
347
258
  wasm.__wbindgen_add_to_stack_pointer(16);
348
259
  }
349
260
  }
350
261
  /**
351
- * @returns {BatchArgument}
262
+ * @returns {BatchArgumentWASM}
352
263
  */
353
264
  borrow_mut() {
354
265
  try {
355
266
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
356
- wasm.batchargument_borrow_mut(retptr, this.__wbg_ptr);
267
+ wasm.batchargumentwasm_borrow_mut(retptr, this.__wbg_ptr);
357
268
  var r0 = getInt32Memory0()[retptr / 4 + 0];
358
269
  var r1 = getInt32Memory0()[retptr / 4 + 1];
359
270
  var r2 = getInt32Memory0()[retptr / 4 + 2];
360
271
  if (r2) {
361
272
  throw takeObject(r1);
362
273
  }
363
- return BatchArgument.__wrap(r0);
274
+ return BatchArgumentWASM.__wrap(r0);
364
275
  } finally {
365
276
  wasm.__wbindgen_add_to_stack_pointer(16);
366
277
  }
367
278
  }
368
279
  /**
369
- * @returns {BatchArgument}
280
+ * @returns {BatchArgumentWASM}
370
281
  */
371
282
  copy() {
372
283
  try {
373
284
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
374
- wasm.batchargument_copy(retptr, this.__wbg_ptr);
285
+ wasm.batchargumentwasm_copy(retptr, this.__wbg_ptr);
375
286
  var r0 = getInt32Memory0()[retptr / 4 + 0];
376
287
  var r1 = getInt32Memory0()[retptr / 4 + 1];
377
288
  var r2 = getInt32Memory0()[retptr / 4 + 2];
378
289
  if (r2) {
379
290
  throw takeObject(r1);
380
291
  }
381
- return BatchArgument.__wrap(r0);
292
+ return BatchArgumentWASM.__wrap(r0);
382
293
  } finally {
383
294
  wasm.__wbindgen_add_to_stack_pointer(16);
384
295
  }
@@ -393,6 +304,14 @@ const BatchedFunctionCallFinalization = (typeof FinalizationRegistry === 'undefi
393
304
  */
394
305
  class BatchedFunctionCall {
395
306
 
307
+ static __wrap(ptr) {
308
+ ptr = ptr >>> 0;
309
+ const obj = Object.create(BatchedFunctionCall.prototype);
310
+ obj.__wbg_ptr = ptr;
311
+ BatchedFunctionCallFinalization.register(obj, obj.__wbg_ptr, obj);
312
+ return obj;
313
+ }
314
+
396
315
  __destroy_into_raw() {
397
316
  const ptr = this.__wbg_ptr;
398
317
  this.__wbg_ptr = 0;
@@ -451,8 +370,8 @@ class BatchedFunctionCallBuilder {
451
370
  * @param {string} module
452
371
  * @param {string} _function
453
372
  * @param {(string)[]} ty_args
454
- * @param {(BatchArgument)[]} args
455
- * @returns {(BatchArgument)[]}
373
+ * @param {(BatchArgumentWASM)[]} args
374
+ * @returns {(BatchArgumentWASM)[]}
456
375
  */
457
376
  add_batched_call(module, _function, ty_args, args) {
458
377
  try {
@@ -502,47 +421,26 @@ class BatchedFunctionCallBuilder {
502
421
  wasm.__wbindgen_add_to_stack_pointer(16);
503
422
  }
504
423
  }
505
- /**
506
- * @param {string} api_url
507
- * @param {string} module_name
508
- * @returns {Promise<void>}
509
- */
510
- load_module(api_url, module_name) {
511
- const ptr0 = passStringToWasm0(api_url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
512
- const len0 = WASM_VECTOR_LEN;
513
- const ptr1 = passStringToWasm0(module_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
514
- const len1 = WASM_VECTOR_LEN;
515
- const ret = wasm.batchedfunctioncallbuilder_load_module(this.__wbg_ptr, ptr0, len0, ptr1, len1);
516
- return takeObject(ret);
517
- }
518
- }
519
-
520
- const PreviousResultFinalization = (typeof FinalizationRegistry === 'undefined')
521
- ? { register: () => {}, unregister: () => {} }
522
- : new FinalizationRegistry(ptr => wasm.__wbg_previousresult_free(ptr >>> 0));
523
- /**
524
- */
525
- class PreviousResult {
526
-
527
- __destroy_into_raw() {
528
- const ptr = this.__wbg_ptr;
529
- this.__wbg_ptr = 0;
530
- PreviousResultFinalization.unregister(this);
531
- return ptr;
532
- }
533
-
534
- free() {
535
- const ptr = this.__destroy_into_raw();
536
- wasm.__wbg_previousresult_free(ptr);
537
- }
538
424
  }
539
425
 
540
426
  function __wbg_get_imports() {
541
427
  const imports = {};
542
428
  imports.wbg = {};
429
+ imports.wbg.__wbg_batchargumentwasm_new = function(arg0) {
430
+ const ret = BatchArgumentWASM.__wrap(arg0);
431
+ return addHeapObject(ret);
432
+ };
433
+ imports.wbg.__wbg_batchedfunctioncall_new = function(arg0) {
434
+ const ret = BatchedFunctionCall.__wrap(arg0);
435
+ return addHeapObject(ret);
436
+ };
543
437
  imports.wbg.__wbindgen_object_drop_ref = function(arg0) {
544
438
  takeObject(arg0);
545
439
  };
440
+ imports.wbg.__wbg_batchargumentwasm_unwrap = function(arg0) {
441
+ const ret = BatchArgumentWASM.__unwrap(takeObject(arg0));
442
+ return ret;
443
+ };
546
444
  imports.wbg.__wbindgen_string_new = function(arg0, arg1) {
547
445
  const ret = getStringFromWasm0(arg0, arg1);
548
446
  return addHeapObject(ret);
@@ -555,234 +453,9 @@ function __wbg_get_imports() {
555
453
  getInt32Memory0()[arg0 / 4 + 1] = len1;
556
454
  getInt32Memory0()[arg0 / 4 + 0] = ptr1;
557
455
  };
558
- imports.wbg.__wbg_batchargument_unwrap = function(arg0) {
559
- const ret = BatchArgument.__unwrap(takeObject(arg0));
560
- return ret;
561
- };
562
- imports.wbg.__wbg_batchargument_new = function(arg0) {
563
- const ret = BatchArgument.__wrap(arg0);
564
- return addHeapObject(ret);
565
- };
566
- imports.wbg.__wbindgen_cb_drop = function(arg0) {
567
- const obj = takeObject(arg0).original;
568
- if (obj.cnt-- == 1) {
569
- obj.a = 0;
570
- return true;
571
- }
572
- const ret = false;
573
- return ret;
574
- };
575
- imports.wbg.__wbg_fetch_1e4e8ed1f64c7e28 = function(arg0) {
576
- const ret = fetch(getObject(arg0));
577
- return addHeapObject(ret);
578
- };
579
- imports.wbg.__wbindgen_object_clone_ref = function(arg0) {
580
- const ret = getObject(arg0);
581
- return addHeapObject(ret);
582
- };
583
- imports.wbg.__wbg_queueMicrotask_481971b0d87f3dd4 = function(arg0) {
584
- queueMicrotask(getObject(arg0));
585
- };
586
- imports.wbg.__wbg_queueMicrotask_3cbae2ec6b6cd3d6 = function(arg0) {
587
- const ret = getObject(arg0).queueMicrotask;
588
- return addHeapObject(ret);
589
- };
590
- imports.wbg.__wbindgen_is_function = function(arg0) {
591
- const ret = typeof(getObject(arg0)) === 'function';
592
- return ret;
593
- };
594
- imports.wbg.__wbg_fetch_693453ca3f88c055 = function(arg0, arg1) {
595
- const ret = getObject(arg0).fetch(getObject(arg1));
596
- return addHeapObject(ret);
597
- };
598
- imports.wbg.__wbg_newwithstrandinit_f581dff0d19a8b03 = function() { return handleError(function (arg0, arg1, arg2) {
599
- const ret = new Request(getStringFromWasm0(arg0, arg1), getObject(arg2));
600
- return addHeapObject(ret);
601
- }, arguments) };
602
- imports.wbg.__wbg_signal_3c701f5f40a5f08d = function(arg0) {
603
- const ret = getObject(arg0).signal;
604
- return addHeapObject(ret);
605
- };
606
- imports.wbg.__wbg_new_0ae46f44b7485bb2 = function() { return handleError(function () {
607
- const ret = new AbortController();
608
- return addHeapObject(ret);
609
- }, arguments) };
610
- imports.wbg.__wbg_abort_2c4fb490d878d2b2 = function(arg0) {
611
- getObject(arg0).abort();
612
- };
613
- imports.wbg.__wbg_new_7a20246daa6eec7e = function() { return handleError(function () {
614
- const ret = new Headers();
615
- return addHeapObject(ret);
616
- }, arguments) };
617
- imports.wbg.__wbg_append_aa3f462f9e2b5ff2 = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
618
- getObject(arg0).append(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
619
- }, arguments) };
620
- imports.wbg.__wbg_instanceof_Response_4c3b1446206114d1 = function(arg0) {
621
- let result;
622
- try {
623
- result = getObject(arg0) instanceof Response;
624
- } catch (_) {
625
- result = false;
626
- }
627
- const ret = result;
628
- return ret;
629
- };
630
- imports.wbg.__wbg_url_83a6a4f65f7a2b38 = function(arg0, arg1) {
631
- const ret = getObject(arg1).url;
632
- const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
633
- const len1 = WASM_VECTOR_LEN;
634
- getInt32Memory0()[arg0 / 4 + 1] = len1;
635
- getInt32Memory0()[arg0 / 4 + 0] = ptr1;
636
- };
637
- imports.wbg.__wbg_status_d6d47ad2837621eb = function(arg0) {
638
- const ret = getObject(arg0).status;
639
- return ret;
640
- };
641
- imports.wbg.__wbg_headers_24def508a7518df9 = function(arg0) {
642
- const ret = getObject(arg0).headers;
643
- return addHeapObject(ret);
644
- };
645
- imports.wbg.__wbg_text_668782292b0bc561 = function() { return handleError(function (arg0) {
646
- const ret = getObject(arg0).text();
647
- return addHeapObject(ret);
648
- }, arguments) };
649
- imports.wbg.__wbindgen_is_object = function(arg0) {
650
- const val = getObject(arg0);
651
- const ret = typeof(val) === 'object' && val !== null;
652
- return ret;
653
- };
654
- imports.wbg.__wbg_newnoargs_e258087cd0daa0ea = function(arg0, arg1) {
655
- const ret = new Function(getStringFromWasm0(arg0, arg1));
656
- return addHeapObject(ret);
657
- };
658
- imports.wbg.__wbg_next_40fc327bfc8770e6 = function(arg0) {
659
- const ret = getObject(arg0).next;
660
- return addHeapObject(ret);
661
- };
662
- imports.wbg.__wbg_next_196c84450b364254 = function() { return handleError(function (arg0) {
663
- const ret = getObject(arg0).next();
664
- return addHeapObject(ret);
665
- }, arguments) };
666
- imports.wbg.__wbg_done_298b57d23c0fc80c = function(arg0) {
667
- const ret = getObject(arg0).done;
668
- return ret;
669
- };
670
- imports.wbg.__wbg_value_d93c65011f51a456 = function(arg0) {
671
- const ret = getObject(arg0).value;
672
- return addHeapObject(ret);
673
- };
674
- imports.wbg.__wbg_iterator_2cee6dadfd956dfa = function() {
675
- const ret = Symbol.iterator;
676
- return addHeapObject(ret);
677
- };
678
- imports.wbg.__wbg_get_e3c254076557e348 = function() { return handleError(function (arg0, arg1) {
679
- const ret = Reflect.get(getObject(arg0), getObject(arg1));
680
- return addHeapObject(ret);
681
- }, arguments) };
682
- imports.wbg.__wbg_call_27c0f87801dedf93 = function() { return handleError(function (arg0, arg1) {
683
- const ret = getObject(arg0).call(getObject(arg1));
684
- return addHeapObject(ret);
685
- }, arguments) };
686
- imports.wbg.__wbg_new_72fb9a18b5ae2624 = function() {
687
- const ret = new Object();
688
- return addHeapObject(ret);
689
- };
690
- imports.wbg.__wbg_self_ce0dbfc45cf2f5be = function() { return handleError(function () {
691
- const ret = self.self;
692
- return addHeapObject(ret);
693
- }, arguments) };
694
- imports.wbg.__wbg_window_c6fb939a7f436783 = function() { return handleError(function () {
695
- const ret = window.window;
696
- return addHeapObject(ret);
697
- }, arguments) };
698
- imports.wbg.__wbg_globalThis_d1e6af4856ba331b = function() { return handleError(function () {
699
- const ret = globalThis.globalThis;
700
- return addHeapObject(ret);
701
- }, arguments) };
702
- imports.wbg.__wbg_global_207b558942527489 = function() { return handleError(function () {
703
- const ret = global.global;
704
- return addHeapObject(ret);
705
- }, arguments) };
706
- imports.wbg.__wbindgen_is_undefined = function(arg0) {
707
- const ret = getObject(arg0) === undefined;
708
- return ret;
709
- };
710
- imports.wbg.__wbg_call_b3ca7c6051f9bec1 = function() { return handleError(function (arg0, arg1, arg2) {
711
- const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
712
- return addHeapObject(ret);
713
- }, arguments) };
714
- imports.wbg.__wbg_new_81740750da40724f = function(arg0, arg1) {
715
- try {
716
- var state0 = {a: arg0, b: arg1};
717
- var cb0 = (arg0, arg1) => {
718
- const a = state0.a;
719
- state0.a = 0;
720
- try {
721
- return __wbg_adapter_87(a, state0.b, arg0, arg1);
722
- } finally {
723
- state0.a = a;
724
- }
725
- };
726
- const ret = new Promise(cb0);
727
- return addHeapObject(ret);
728
- } finally {
729
- state0.a = state0.b = 0;
730
- }
731
- };
732
- imports.wbg.__wbg_resolve_b0083a7967828ec8 = function(arg0) {
733
- const ret = Promise.resolve(getObject(arg0));
734
- return addHeapObject(ret);
735
- };
736
- imports.wbg.__wbg_then_0c86a60e8fcfe9f6 = function(arg0, arg1) {
737
- const ret = getObject(arg0).then(getObject(arg1));
738
- return addHeapObject(ret);
739
- };
740
- imports.wbg.__wbg_then_a73caa9a87991566 = function(arg0, arg1, arg2) {
741
- const ret = getObject(arg0).then(getObject(arg1), getObject(arg2));
742
- return addHeapObject(ret);
743
- };
744
- imports.wbg.__wbg_buffer_12d079cc21e14bdb = function(arg0) {
745
- const ret = getObject(arg0).buffer;
746
- return addHeapObject(ret);
747
- };
748
- imports.wbg.__wbg_newwithbyteoffsetandlength_aa4a17c33a06e5cb = function(arg0, arg1, arg2) {
749
- const ret = new Uint8Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
750
- return addHeapObject(ret);
751
- };
752
- imports.wbg.__wbg_new_63b92bc8671ed464 = function(arg0) {
753
- const ret = new Uint8Array(getObject(arg0));
754
- return addHeapObject(ret);
755
- };
756
- imports.wbg.__wbg_stringify_8887fe74e1c50d81 = function() { return handleError(function (arg0) {
757
- const ret = JSON.stringify(getObject(arg0));
758
- return addHeapObject(ret);
759
- }, arguments) };
760
- imports.wbg.__wbg_has_0af94d20077affa2 = function() { return handleError(function (arg0, arg1) {
761
- const ret = Reflect.has(getObject(arg0), getObject(arg1));
762
- return ret;
763
- }, arguments) };
764
- imports.wbg.__wbg_set_1f9b04f170055d33 = function() { return handleError(function (arg0, arg1, arg2) {
765
- const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
766
- return ret;
767
- }, arguments) };
768
- imports.wbg.__wbindgen_debug_string = function(arg0, arg1) {
769
- const ret = debugString(getObject(arg1));
770
- const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
771
- const len1 = WASM_VECTOR_LEN;
772
- getInt32Memory0()[arg0 / 4 + 1] = len1;
773
- getInt32Memory0()[arg0 / 4 + 0] = ptr1;
774
- };
775
456
  imports.wbg.__wbindgen_throw = function(arg0, arg1) {
776
457
  throw new Error(getStringFromWasm0(arg0, arg1));
777
458
  };
778
- imports.wbg.__wbindgen_memory = function() {
779
- const ret = wasm.memory;
780
- return addHeapObject(ret);
781
- };
782
- imports.wbg.__wbindgen_closure_wrapper540 = function(arg0, arg1, arg2) {
783
- const ret = makeMutClosure(arg0, arg1, 264, __wbg_adapter_24);
784
- return addHeapObject(ret);
785
- };
786
459
 
787
460
  return imports;
788
461
  }
@@ -812,14 +485,13 @@ function initSync(module) {
812
485
  }
813
486
 
814
487
  async function get_wasm (){
815
- return (await Promise.resolve().then(function () { return require('./aptos_intent_bg-Cvhg0cOA.js'); })).default()
488
+ return (await Promise.resolve().then(function () { return require('./aptos_intent_bg-pteHxyaL.js'); })).default()
816
489
  }
817
490
 
818
- exports.ArgumentOperation = ArgumentOperation;
819
- exports.BatchArgument = BatchArgument;
820
491
  exports.BatchArgumentType = BatchArgumentType;
492
+ exports.BatchArgumentWASM = BatchArgumentWASM;
821
493
  exports.BatchedFunctionCall = BatchedFunctionCall;
822
494
  exports.BatchedFunctionCallBuilder = BatchedFunctionCallBuilder;
823
- exports.PreviousResult = PreviousResult;
495
+ exports.generate_intent_payload_wasm = generate_intent_payload_wasm;
824
496
  exports.get_wasm = get_wasm;
825
497
  exports.initSync = initSync;