@wgb5445/aptos-intent-npm 0.0.9 → 0.0.11

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,6 +117,112 @@ 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__h8273ed02fd8578ca(arg0, arg1, addHeapObject(arg2));
217
+ }
218
+
219
+ function passArray8ToWasm0(arg, malloc) {
220
+ const ptr = malloc(arg.length * 1, 1) >>> 0;
221
+ getUint8Memory0().set(arg, ptr / 1);
222
+ WASM_VECTOR_LEN = arg.length;
223
+ return ptr;
224
+ }
225
+
120
226
  let cachedUint32Memory0 = null;
121
227
 
122
228
  function getUint32Memory0() {
@@ -126,16 +232,6 @@ function getUint32Memory0() {
126
232
  return cachedUint32Memory0;
127
233
  }
128
234
 
129
- function passArrayJsValueToWasm0(array, malloc) {
130
- const ptr = malloc(array.length * 4, 4) >>> 0;
131
- const mem = getUint32Memory0();
132
- for (let i = 0; i < array.length; i++) {
133
- mem[ptr / 4 + i] = addHeapObject(array[i]);
134
- }
135
- WASM_VECTOR_LEN = array.length;
136
- return ptr;
137
- }
138
-
139
235
  function getArrayJsValueFromWasm0(ptr, len) {
140
236
  ptr = ptr >>> 0;
141
237
  const mem = getUint32Memory0();
@@ -146,18 +242,6 @@ function getArrayJsValueFromWasm0(ptr, len) {
146
242
  }
147
243
  return result;
148
244
  }
149
-
150
- function getArrayU8FromWasm0(ptr, len) {
151
- ptr = ptr >>> 0;
152
- return getUint8Memory0().subarray(ptr / 1, ptr / 1 + len);
153
- }
154
-
155
- function passArray8ToWasm0(arg, malloc) {
156
- const ptr = malloc(arg.length * 1, 1) >>> 0;
157
- getUint8Memory0().set(arg, ptr / 1);
158
- WASM_VECTOR_LEN = arg.length;
159
- return ptr;
160
- }
161
245
  /**
162
246
  * @param {Uint8Array} script
163
247
  * @returns {(BatchedFunctionCall)[]}
@@ -183,34 +267,79 @@ function generate_intent_payload_wasm(script) {
183
267
  }
184
268
  }
185
269
 
270
+ function passArrayJsValueToWasm0(array, malloc) {
271
+ const ptr = malloc(array.length * 4, 4) >>> 0;
272
+ const mem = getUint32Memory0();
273
+ for (let i = 0; i < array.length; i++) {
274
+ mem[ptr / 4 + i] = addHeapObject(array[i]);
275
+ }
276
+ WASM_VECTOR_LEN = array.length;
277
+ return ptr;
278
+ }
279
+
280
+ function getArrayU8FromWasm0(ptr, len) {
281
+ ptr = ptr >>> 0;
282
+ return getUint8Memory0().subarray(ptr / 1, ptr / 1 + len);
283
+ }
284
+
285
+ function handleError(f, args) {
286
+ try {
287
+ return f.apply(this, args);
288
+ } catch (e) {
289
+ wasm.__wbindgen_exn_store(addHeapObject(e));
290
+ }
291
+ }
292
+ function __wbg_adapter_90(arg0, arg1, arg2, arg3) {
293
+ wasm.wasm_bindgen__convert__closures__invoke2_mut__h7a552e5a28352106(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
294
+ }
295
+
186
296
  /**
187
297
  * Arguments for each function.
188
298
  */
189
299
  const BatchArgumentType = Object.freeze({ Raw:0,"0":"Raw",Signer:1,"1":"Signer",PreviousResult:2,"2":"PreviousResult", });
190
300
 
191
- const BatchArgumentWASMFinalization = (typeof FinalizationRegistry === 'undefined')
301
+ const BatchArgumentFinalization = (typeof FinalizationRegistry === 'undefined')
192
302
  ? { register: () => {}, unregister: () => {} }
193
- : new FinalizationRegistry(ptr => wasm.__wbg_batchargumentwasm_free(ptr >>> 0));
303
+ : new FinalizationRegistry(ptr => wasm.__wbg_batchargument_free(ptr >>> 0));
194
304
  /**
195
305
  * Arguments for each function. Wasm bindgen only support C-style enum so use option to work around.
196
306
  */
197
- class BatchArgumentWASM {
307
+ class BatchArgument {
198
308
 
199
309
  static __wrap(ptr) {
200
310
  ptr = ptr >>> 0;
201
- const obj = Object.create(BatchArgumentWASM.prototype);
311
+ const obj = Object.create(BatchArgument.prototype);
202
312
  obj.__wbg_ptr = ptr;
203
- BatchArgumentWASMFinalization.register(obj, obj.__wbg_ptr, obj);
313
+ BatchArgumentFinalization.register(obj, obj.__wbg_ptr, obj);
204
314
  return obj;
205
315
  }
206
316
 
207
317
  static __unwrap(jsValue) {
208
- if (!(jsValue instanceof BatchArgumentWASM)) {
318
+ if (!(jsValue instanceof BatchArgument)) {
209
319
  return 0;
210
320
  }
211
321
  return jsValue.__destroy_into_raw();
212
322
  }
213
323
 
324
+ __destroy_into_raw() {
325
+ const ptr = this.__wbg_ptr;
326
+ this.__wbg_ptr = 0;
327
+ BatchArgumentFinalization.unregister(this);
328
+ return ptr;
329
+ }
330
+
331
+ free() {
332
+ const ptr = this.__destroy_into_raw();
333
+ wasm.__wbg_batchargument_free(ptr);
334
+ }
335
+ }
336
+
337
+ const BatchArgumentWASMFinalization = (typeof FinalizationRegistry === 'undefined')
338
+ ? { register: () => {}, unregister: () => {} }
339
+ : new FinalizationRegistry(ptr => wasm.__wbg_batchargumentwasm_free(ptr >>> 0));
340
+
341
+ class BatchArgumentWASM {
342
+
214
343
  __destroy_into_raw() {
215
344
  const ptr = this.__wbg_ptr;
216
345
  this.__wbg_ptr = 0;
@@ -224,24 +353,24 @@ class BatchArgumentWASM {
224
353
  }
225
354
  /**
226
355
  * @param {Uint8Array} bytes
227
- * @returns {BatchArgumentWASM}
356
+ * @returns {BatchArgument}
228
357
  */
229
358
  static new_bytes(bytes) {
230
359
  const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
231
360
  const len0 = WASM_VECTOR_LEN;
232
361
  const ret = wasm.batchargumentwasm_new_bytes(ptr0, len0);
233
- return BatchArgumentWASM.__wrap(ret);
362
+ return BatchArgument.__wrap(ret);
234
363
  }
235
364
  /**
236
365
  * @param {number} signer_idx
237
- * @returns {BatchArgumentWASM}
366
+ * @returns {BatchArgument}
238
367
  */
239
368
  static new_signer(signer_idx) {
240
369
  const ret = wasm.batchargumentwasm_new_signer(signer_idx);
241
- return BatchArgumentWASM.__wrap(ret);
370
+ return BatchArgument.__wrap(ret);
242
371
  }
243
372
  /**
244
- * @returns {BatchArgumentWASM}
373
+ * @returns {BatchArgument}
245
374
  */
246
375
  borrow() {
247
376
  try {
@@ -253,13 +382,13 @@ class BatchArgumentWASM {
253
382
  if (r2) {
254
383
  throw takeObject(r1);
255
384
  }
256
- return BatchArgumentWASM.__wrap(r0);
385
+ return BatchArgument.__wrap(r0);
257
386
  } finally {
258
387
  wasm.__wbindgen_add_to_stack_pointer(16);
259
388
  }
260
389
  }
261
390
  /**
262
- * @returns {BatchArgumentWASM}
391
+ * @returns {BatchArgument}
263
392
  */
264
393
  borrow_mut() {
265
394
  try {
@@ -271,13 +400,13 @@ class BatchArgumentWASM {
271
400
  if (r2) {
272
401
  throw takeObject(r1);
273
402
  }
274
- return BatchArgumentWASM.__wrap(r0);
403
+ return BatchArgument.__wrap(r0);
275
404
  } finally {
276
405
  wasm.__wbindgen_add_to_stack_pointer(16);
277
406
  }
278
407
  }
279
408
  /**
280
- * @returns {BatchArgumentWASM}
409
+ * @returns {BatchArgument}
281
410
  */
282
411
  copy() {
283
412
  try {
@@ -289,7 +418,7 @@ class BatchArgumentWASM {
289
418
  if (r2) {
290
419
  throw takeObject(r1);
291
420
  }
292
- return BatchArgumentWASM.__wrap(r0);
421
+ return BatchArgument.__wrap(r0);
293
422
  } finally {
294
423
  wasm.__wbindgen_add_to_stack_pointer(16);
295
424
  }
@@ -370,8 +499,8 @@ class BatchedFunctionCallBuilder {
370
499
  * @param {string} module
371
500
  * @param {string} _function
372
501
  * @param {(string)[]} ty_args
373
- * @param {(BatchArgumentWASM)[]} args
374
- * @returns {(BatchArgumentWASM)[]}
502
+ * @param {(BatchArgument)[]} args
503
+ * @returns {(BatchArgument)[]}
375
504
  */
376
505
  add_batched_call(module, _function, ty_args, args) {
377
506
  try {
@@ -421,13 +550,26 @@ class BatchedFunctionCallBuilder {
421
550
  wasm.__wbindgen_add_to_stack_pointer(16);
422
551
  }
423
552
  }
553
+ /**
554
+ * @param {string} api_url
555
+ * @param {string} module_name
556
+ * @returns {Promise<void>}
557
+ */
558
+ load_module(api_url, module_name) {
559
+ const ptr0 = passStringToWasm0(api_url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
560
+ const len0 = WASM_VECTOR_LEN;
561
+ const ptr1 = passStringToWasm0(module_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
562
+ const len1 = WASM_VECTOR_LEN;
563
+ const ret = wasm.batchedfunctioncallbuilder_load_module(this.__wbg_ptr, ptr0, len0, ptr1, len1);
564
+ return takeObject(ret);
565
+ }
424
566
  }
425
567
 
426
568
  function __wbg_get_imports() {
427
569
  const imports = {};
428
570
  imports.wbg = {};
429
- imports.wbg.__wbg_batchargumentwasm_new = function(arg0) {
430
- const ret = BatchArgumentWASM.__wrap(arg0);
571
+ imports.wbg.__wbg_batchargument_new = function(arg0) {
572
+ const ret = BatchArgument.__wrap(arg0);
431
573
  return addHeapObject(ret);
432
574
  };
433
575
  imports.wbg.__wbg_batchedfunctioncall_new = function(arg0) {
@@ -437,8 +579,17 @@ function __wbg_get_imports() {
437
579
  imports.wbg.__wbindgen_object_drop_ref = function(arg0) {
438
580
  takeObject(arg0);
439
581
  };
440
- imports.wbg.__wbg_batchargumentwasm_unwrap = function(arg0) {
441
- const ret = BatchArgumentWASM.__unwrap(takeObject(arg0));
582
+ imports.wbg.__wbindgen_cb_drop = function(arg0) {
583
+ const obj = takeObject(arg0).original;
584
+ if (obj.cnt-- == 1) {
585
+ obj.a = 0;
586
+ return true;
587
+ }
588
+ const ret = false;
589
+ return ret;
590
+ };
591
+ imports.wbg.__wbg_batchargument_unwrap = function(arg0) {
592
+ const ret = BatchArgument.__unwrap(takeObject(arg0));
442
593
  return ret;
443
594
  };
444
595
  imports.wbg.__wbindgen_string_new = function(arg0, arg1) {
@@ -453,9 +604,217 @@ function __wbg_get_imports() {
453
604
  getInt32Memory0()[arg0 / 4 + 1] = len1;
454
605
  getInt32Memory0()[arg0 / 4 + 0] = ptr1;
455
606
  };
607
+ imports.wbg.__wbg_fetch_1e4e8ed1f64c7e28 = function(arg0) {
608
+ const ret = fetch(getObject(arg0));
609
+ return addHeapObject(ret);
610
+ };
611
+ imports.wbg.__wbindgen_object_clone_ref = function(arg0) {
612
+ const ret = getObject(arg0);
613
+ return addHeapObject(ret);
614
+ };
615
+ imports.wbg.__wbg_queueMicrotask_3cbae2ec6b6cd3d6 = function(arg0) {
616
+ const ret = getObject(arg0).queueMicrotask;
617
+ return addHeapObject(ret);
618
+ };
619
+ imports.wbg.__wbindgen_is_function = function(arg0) {
620
+ const ret = typeof(getObject(arg0)) === 'function';
621
+ return ret;
622
+ };
623
+ imports.wbg.__wbg_queueMicrotask_481971b0d87f3dd4 = function(arg0) {
624
+ queueMicrotask(getObject(arg0));
625
+ };
626
+ imports.wbg.__wbg_fetch_693453ca3f88c055 = function(arg0, arg1) {
627
+ const ret = getObject(arg0).fetch(getObject(arg1));
628
+ return addHeapObject(ret);
629
+ };
630
+ imports.wbg.__wbg_new_7a20246daa6eec7e = function() { return handleError(function () {
631
+ const ret = new Headers();
632
+ return addHeapObject(ret);
633
+ }, arguments) };
634
+ imports.wbg.__wbg_append_aa3f462f9e2b5ff2 = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
635
+ getObject(arg0).append(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
636
+ }, arguments) };
637
+ imports.wbg.__wbg_newwithstrandinit_f581dff0d19a8b03 = function() { return handleError(function (arg0, arg1, arg2) {
638
+ const ret = new Request(getStringFromWasm0(arg0, arg1), getObject(arg2));
639
+ return addHeapObject(ret);
640
+ }, arguments) };
641
+ imports.wbg.__wbg_signal_3c701f5f40a5f08d = function(arg0) {
642
+ const ret = getObject(arg0).signal;
643
+ return addHeapObject(ret);
644
+ };
645
+ imports.wbg.__wbg_new_0ae46f44b7485bb2 = function() { return handleError(function () {
646
+ const ret = new AbortController();
647
+ return addHeapObject(ret);
648
+ }, arguments) };
649
+ imports.wbg.__wbg_abort_2c4fb490d878d2b2 = function(arg0) {
650
+ getObject(arg0).abort();
651
+ };
652
+ imports.wbg.__wbg_instanceof_Response_4c3b1446206114d1 = function(arg0) {
653
+ let result;
654
+ try {
655
+ result = getObject(arg0) instanceof Response;
656
+ } catch (_) {
657
+ result = false;
658
+ }
659
+ const ret = result;
660
+ return ret;
661
+ };
662
+ imports.wbg.__wbg_url_83a6a4f65f7a2b38 = function(arg0, arg1) {
663
+ const ret = getObject(arg1).url;
664
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
665
+ const len1 = WASM_VECTOR_LEN;
666
+ getInt32Memory0()[arg0 / 4 + 1] = len1;
667
+ getInt32Memory0()[arg0 / 4 + 0] = ptr1;
668
+ };
669
+ imports.wbg.__wbg_status_d6d47ad2837621eb = function(arg0) {
670
+ const ret = getObject(arg0).status;
671
+ return ret;
672
+ };
673
+ imports.wbg.__wbg_headers_24def508a7518df9 = function(arg0) {
674
+ const ret = getObject(arg0).headers;
675
+ return addHeapObject(ret);
676
+ };
677
+ imports.wbg.__wbg_text_668782292b0bc561 = function() { return handleError(function (arg0) {
678
+ const ret = getObject(arg0).text();
679
+ return addHeapObject(ret);
680
+ }, arguments) };
681
+ imports.wbg.__wbindgen_is_object = function(arg0) {
682
+ const val = getObject(arg0);
683
+ const ret = typeof(val) === 'object' && val !== null;
684
+ return ret;
685
+ };
686
+ imports.wbg.__wbg_newnoargs_e258087cd0daa0ea = function(arg0, arg1) {
687
+ const ret = new Function(getStringFromWasm0(arg0, arg1));
688
+ return addHeapObject(ret);
689
+ };
690
+ imports.wbg.__wbg_next_40fc327bfc8770e6 = function(arg0) {
691
+ const ret = getObject(arg0).next;
692
+ return addHeapObject(ret);
693
+ };
694
+ imports.wbg.__wbg_next_196c84450b364254 = function() { return handleError(function (arg0) {
695
+ const ret = getObject(arg0).next();
696
+ return addHeapObject(ret);
697
+ }, arguments) };
698
+ imports.wbg.__wbg_done_298b57d23c0fc80c = function(arg0) {
699
+ const ret = getObject(arg0).done;
700
+ return ret;
701
+ };
702
+ imports.wbg.__wbg_value_d93c65011f51a456 = function(arg0) {
703
+ const ret = getObject(arg0).value;
704
+ return addHeapObject(ret);
705
+ };
706
+ imports.wbg.__wbg_iterator_2cee6dadfd956dfa = function() {
707
+ const ret = Symbol.iterator;
708
+ return addHeapObject(ret);
709
+ };
710
+ imports.wbg.__wbg_get_e3c254076557e348 = function() { return handleError(function (arg0, arg1) {
711
+ const ret = Reflect.get(getObject(arg0), getObject(arg1));
712
+ return addHeapObject(ret);
713
+ }, arguments) };
714
+ imports.wbg.__wbg_call_27c0f87801dedf93 = function() { return handleError(function (arg0, arg1) {
715
+ const ret = getObject(arg0).call(getObject(arg1));
716
+ return addHeapObject(ret);
717
+ }, arguments) };
718
+ imports.wbg.__wbg_new_72fb9a18b5ae2624 = function() {
719
+ const ret = new Object();
720
+ return addHeapObject(ret);
721
+ };
722
+ imports.wbg.__wbg_self_ce0dbfc45cf2f5be = function() { return handleError(function () {
723
+ const ret = self.self;
724
+ return addHeapObject(ret);
725
+ }, arguments) };
726
+ imports.wbg.__wbg_window_c6fb939a7f436783 = function() { return handleError(function () {
727
+ const ret = window.window;
728
+ return addHeapObject(ret);
729
+ }, arguments) };
730
+ imports.wbg.__wbg_globalThis_d1e6af4856ba331b = function() { return handleError(function () {
731
+ const ret = globalThis.globalThis;
732
+ return addHeapObject(ret);
733
+ }, arguments) };
734
+ imports.wbg.__wbg_global_207b558942527489 = function() { return handleError(function () {
735
+ const ret = global.global;
736
+ return addHeapObject(ret);
737
+ }, arguments) };
738
+ imports.wbg.__wbindgen_is_undefined = function(arg0) {
739
+ const ret = getObject(arg0) === undefined;
740
+ return ret;
741
+ };
742
+ imports.wbg.__wbg_call_b3ca7c6051f9bec1 = function() { return handleError(function (arg0, arg1, arg2) {
743
+ const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
744
+ return addHeapObject(ret);
745
+ }, arguments) };
746
+ imports.wbg.__wbg_new_81740750da40724f = function(arg0, arg1) {
747
+ try {
748
+ var state0 = {a: arg0, b: arg1};
749
+ var cb0 = (arg0, arg1) => {
750
+ const a = state0.a;
751
+ state0.a = 0;
752
+ try {
753
+ return __wbg_adapter_90(a, state0.b, arg0, arg1);
754
+ } finally {
755
+ state0.a = a;
756
+ }
757
+ };
758
+ const ret = new Promise(cb0);
759
+ return addHeapObject(ret);
760
+ } finally {
761
+ state0.a = state0.b = 0;
762
+ }
763
+ };
764
+ imports.wbg.__wbg_resolve_b0083a7967828ec8 = function(arg0) {
765
+ const ret = Promise.resolve(getObject(arg0));
766
+ return addHeapObject(ret);
767
+ };
768
+ imports.wbg.__wbg_then_0c86a60e8fcfe9f6 = function(arg0, arg1) {
769
+ const ret = getObject(arg0).then(getObject(arg1));
770
+ return addHeapObject(ret);
771
+ };
772
+ imports.wbg.__wbg_then_a73caa9a87991566 = function(arg0, arg1, arg2) {
773
+ const ret = getObject(arg0).then(getObject(arg1), getObject(arg2));
774
+ return addHeapObject(ret);
775
+ };
776
+ imports.wbg.__wbg_buffer_12d079cc21e14bdb = function(arg0) {
777
+ const ret = getObject(arg0).buffer;
778
+ return addHeapObject(ret);
779
+ };
780
+ imports.wbg.__wbg_newwithbyteoffsetandlength_aa4a17c33a06e5cb = function(arg0, arg1, arg2) {
781
+ const ret = new Uint8Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
782
+ return addHeapObject(ret);
783
+ };
784
+ imports.wbg.__wbg_new_63b92bc8671ed464 = function(arg0) {
785
+ const ret = new Uint8Array(getObject(arg0));
786
+ return addHeapObject(ret);
787
+ };
788
+ imports.wbg.__wbg_has_0af94d20077affa2 = function() { return handleError(function (arg0, arg1) {
789
+ const ret = Reflect.has(getObject(arg0), getObject(arg1));
790
+ return ret;
791
+ }, arguments) };
792
+ imports.wbg.__wbg_set_1f9b04f170055d33 = function() { return handleError(function (arg0, arg1, arg2) {
793
+ const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
794
+ return ret;
795
+ }, arguments) };
796
+ imports.wbg.__wbg_stringify_8887fe74e1c50d81 = function() { return handleError(function (arg0) {
797
+ const ret = JSON.stringify(getObject(arg0));
798
+ return addHeapObject(ret);
799
+ }, arguments) };
800
+ imports.wbg.__wbindgen_debug_string = function(arg0, arg1) {
801
+ const ret = debugString(getObject(arg1));
802
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
803
+ const len1 = WASM_VECTOR_LEN;
804
+ getInt32Memory0()[arg0 / 4 + 1] = len1;
805
+ getInt32Memory0()[arg0 / 4 + 0] = ptr1;
806
+ };
456
807
  imports.wbg.__wbindgen_throw = function(arg0, arg1) {
457
808
  throw new Error(getStringFromWasm0(arg0, arg1));
458
809
  };
810
+ imports.wbg.__wbindgen_memory = function() {
811
+ const ret = wasm.memory;
812
+ return addHeapObject(ret);
813
+ };
814
+ imports.wbg.__wbindgen_closure_wrapper1042 = function(arg0, arg1, arg2) {
815
+ const ret = makeMutClosure(arg0, arg1, 297, __wbg_adapter_24);
816
+ return addHeapObject(ret);
817
+ };
459
818
 
460
819
  return imports;
461
820
  }
@@ -485,9 +844,10 @@ function initSync(module) {
485
844
  }
486
845
 
487
846
  async function get_wasm (){
488
- return (await Promise.resolve().then(function () { return require('./aptos_intent_bg-pteHxyaL.js'); })).default()
847
+ return (await Promise.resolve().then(function () { return require('./aptos_intent_bg-2V_b8N0G.js'); })).default()
489
848
  }
490
849
 
850
+ exports.BatchArgument = BatchArgument;
491
851
  exports.BatchArgumentType = BatchArgumentType;
492
852
  exports.BatchArgumentWASM = BatchArgumentWASM;
493
853
  exports.BatchedFunctionCall = BatchedFunctionCall;