@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/aptos_intent.d.ts +17 -28
- package/dist/cjs/aptos_intent_bg-2V_b8N0G.js +42 -0
- package/dist/cjs/aptos_intent_bg-Dke4lYNx.js +42 -0
- package/dist/cjs/entry.js +405 -45
- package/dist/esm/aptos_intent_bg-B4vpJSlo.js +40 -0
- package/dist/esm/aptos_intent_bg-vY0jOTb5.js +40 -0
- package/dist/esm/entry.js +405 -46
- package/package.json +1 -1
- package/dist/cjs/aptos_intent_bg-Cvhg0cOA.js +0 -42
- package/dist/cjs/aptos_intent_bg-pteHxyaL.js +0 -42
- package/dist/esm/aptos_intent_bg-DEdT9YzH.js +0 -40
- package/dist/esm/aptos_intent_bg-Dr5TXbTf.js +0 -40
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
|
301
|
+
const BatchArgumentFinalization = (typeof FinalizationRegistry === 'undefined')
|
192
302
|
? { register: () => {}, unregister: () => {} }
|
193
|
-
: new FinalizationRegistry(ptr => wasm.
|
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
|
307
|
+
class BatchArgument {
|
198
308
|
|
199
309
|
static __wrap(ptr) {
|
200
310
|
ptr = ptr >>> 0;
|
201
|
-
const obj = Object.create(
|
311
|
+
const obj = Object.create(BatchArgument.prototype);
|
202
312
|
obj.__wbg_ptr = ptr;
|
203
|
-
|
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
|
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 {
|
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
|
362
|
+
return BatchArgument.__wrap(ret);
|
234
363
|
}
|
235
364
|
/**
|
236
365
|
* @param {number} signer_idx
|
237
|
-
* @returns {
|
366
|
+
* @returns {BatchArgument}
|
238
367
|
*/
|
239
368
|
static new_signer(signer_idx) {
|
240
369
|
const ret = wasm.batchargumentwasm_new_signer(signer_idx);
|
241
|
-
return
|
370
|
+
return BatchArgument.__wrap(ret);
|
242
371
|
}
|
243
372
|
/**
|
244
|
-
* @returns {
|
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
|
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 {
|
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
|
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 {
|
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
|
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 {(
|
374
|
-
* @returns {(
|
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.
|
430
|
-
const ret =
|
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.
|
441
|
-
const
|
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-
|
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;
|