@useragent-kit/wasm 0.0.1

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.
Files changed (5) hide show
  1. package/package.json +22 -0
  2. package/useragent_wasm.d.ts +838 -0
  3. package/useragent_wasm.js +9 -0
  4. package/useragent_wasm_bg.js +4464 -0
  5. package/useragent_wasm_bg.wasm +0 -0
package/useragent_wasm_bg.js ADDED
@@ -0,0 +1,4464 @@
1
+ /**
2
+ * JS-facing chain state machine.
3
+ *
4
+ * Does NOT manage the smoldot client itself — that lives in TypeScript via
5
+ * the `smoldot` NPM package. This handle provides:
6
+ * - Chain status tracking (processes JSON-RPC responses from smoldot-js)
7
+ * - Request generation (subscriptions, health checks, DB saves)
8
+ * - Chain database persistence (localStorage by default, or a custom JS store)
9
+ * - Chain spec access (for TypeScript to pass to smoldot's `addChain`)
10
+ *
11
+ * Only Substrate/Polkadot chains (smoldot backend) are supported on WASM.
12
+ */
13
+ export class ChainClientHandle {
14
+ static __wrap(ptr) {
15
+ const obj = Object.create(ChainClientHandle.prototype);
16
+ obj.__wbg_ptr = ptr;
17
+ ChainClientHandleFinalization.register(obj, obj.__wbg_ptr, obj);
18
+ return obj;
19
+ }
20
+ __destroy_into_raw() {
21
+ const ptr = this.__wbg_ptr;
22
+ this.__wbg_ptr = 0;
23
+ ChainClientHandleFinalization.unregister(this);
24
+ return ptr;
25
+ }
26
+ free() {
27
+ const ptr = this.__destroy_into_raw();
28
+ wasm.__wbg_chainclienthandle_free(ptr, 0);
29
+ }
30
+ /**
31
+ * Get all chain statuses.
32
+ * @returns {any}
33
+ */
34
+ allStatuses() {
35
+ try {
36
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
37
+ wasm.chainclienthandle_allStatuses(retptr, this.__wbg_ptr);
38
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
39
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
40
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
41
+ if (r2) {
42
+ throw takeObject(r1);
43
+ }
44
+ return takeObject(r0);
45
+ } finally {
46
+ wasm.__wbindgen_add_to_stack_pointer(16);
47
+ }
48
+ }
49
+ /**
50
+ * Get chain specs for a smoldot chain. Returns [relaySpec, paraSpec] or null.
51
+ * @param {string} chain_name
52
+ * @returns {any}
53
+ */
54
+ chainSpecs(chain_name) {
55
+ try {
56
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
57
+ const ptr0 = passStringToWasm0(chain_name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
58
+ const len0 = WASM_VECTOR_LEN;
59
+ wasm.chainclienthandle_chainSpecs(retptr, this.__wbg_ptr, ptr0, len0);
60
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
61
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
62
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
63
+ if (r2) {
64
+ throw takeObject(r1);
65
+ }
66
+ return takeObject(r0);
67
+ } finally {
68
+ wasm.__wbindgen_add_to_stack_pointer(16);
69
+ }
70
+ }
71
+ /**
72
+ * Create a handle backed by a custom JS store (e.g. IndexedDB).
73
+ *
74
+ * The `store` object must implement `load(key: string): string | null | undefined` and
75
+ * `save(key: string, data: string): void`.
76
+ * @param {any} store
77
+ * @returns {ChainClientHandle}
78
+ */
79
+ static fromStore(store) {
80
+ const ret = wasm.chainclienthandle_fromStore(addHeapObject(store));
81
+ return ChainClientHandle.__wrap(ret);
82
+ }
83
+ /**
84
+ * JSON-RPC health check request (incrementing ID per chain).
85
+ * @param {string} chain_name
86
+ * @returns {string}
87
+ */
88
+ healthCheckRequest(chain_name) {
89
+ let deferred3_0;
90
+ let deferred3_1;
91
+ try {
92
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
93
+ const ptr0 = passStringToWasm0(chain_name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
94
+ const len0 = WASM_VECTOR_LEN;
95
+ wasm.chainclienthandle_healthCheckRequest(retptr, this.__wbg_ptr, ptr0, len0);
96
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
97
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
98
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
99
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
100
+ var ptr2 = r0;
101
+ var len2 = r1;
102
+ if (r3) {
103
+ ptr2 = 0; len2 = 0;
104
+ throw takeObject(r2);
105
+ }
106
+ deferred3_0 = ptr2;
107
+ deferred3_1 = len2;
108
+ return getStringFromWasm0(ptr2, len2);
109
+ } finally {
110
+ wasm.__wbindgen_add_to_stack_pointer(16);
111
+ wasm.__wbindgen_export5(deferred3_0, deferred3_1, 1);
112
+ }
113
+ }
114
+ /**
115
+ * Load persisted parachain DB from localStorage.
116
+ * @param {string} chain_name
117
+ * @returns {string}
118
+ */
119
+ loadParaDb(chain_name) {
120
+ let deferred3_0;
121
+ let deferred3_1;
122
+ try {
123
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
124
+ const ptr0 = passStringToWasm0(chain_name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
125
+ const len0 = WASM_VECTOR_LEN;
126
+ wasm.chainclienthandle_loadParaDb(retptr, this.__wbg_ptr, ptr0, len0);
127
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
128
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
129
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
130
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
131
+ var ptr2 = r0;
132
+ var len2 = r1;
133
+ if (r3) {
134
+ ptr2 = 0; len2 = 0;
135
+ throw takeObject(r2);
136
+ }
137
+ deferred3_0 = ptr2;
138
+ deferred3_1 = len2;
139
+ return getStringFromWasm0(ptr2, len2);
140
+ } finally {
141
+ wasm.__wbindgen_add_to_stack_pointer(16);
142
+ wasm.__wbindgen_export5(deferred3_0, deferred3_1, 1);
143
+ }
144
+ }
145
+ /**
146
+ * Load persisted relay chain DB from localStorage.
147
+ * @param {string} chain_name
148
+ * @returns {string}
149
+ */
150
+ loadRelayDb(chain_name) {
151
+ let deferred3_0;
152
+ let deferred3_1;
153
+ try {
154
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
155
+ const ptr0 = passStringToWasm0(chain_name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
156
+ const len0 = WASM_VECTOR_LEN;
157
+ wasm.chainclienthandle_loadRelayDb(retptr, this.__wbg_ptr, ptr0, len0);
158
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
159
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
160
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
161
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
162
+ var ptr2 = r0;
163
+ var len2 = r1;
164
+ if (r3) {
165
+ ptr2 = 0; len2 = 0;
166
+ throw takeObject(r2);
167
+ }
168
+ deferred3_0 = ptr2;
169
+ deferred3_1 = len2;
170
+ return getStringFromWasm0(ptr2, len2);
171
+ } finally {
172
+ wasm.__wbindgen_add_to_stack_pointer(16);
173
+ wasm.__wbindgen_export5(deferred3_0, deferred3_1, 1);
174
+ }
175
+ }
176
+ constructor() {
177
+ const ret = wasm.chainclienthandle_new();
178
+ this.__wbg_ptr = ret;
179
+ ChainClientHandleFinalization.register(this, this.__wbg_ptr, this);
180
+ return this;
181
+ }
182
+ /**
183
+ * JSON-RPC request to save parachain DB (send to parachain).
184
+ * @returns {string}
185
+ */
186
+ paraDbSaveRequest() {
187
+ let deferred1_0;
188
+ let deferred1_1;
189
+ try {
190
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
191
+ wasm.chainclienthandle_paraDbSaveRequest(retptr, this.__wbg_ptr);
192
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
193
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
194
+ deferred1_0 = r0;
195
+ deferred1_1 = r1;
196
+ return getStringFromWasm0(r0, r1);
197
+ } finally {
198
+ wasm.__wbindgen_add_to_stack_pointer(16);
199
+ wasm.__wbindgen_export5(deferred1_0, deferred1_1, 1);
200
+ }
201
+ }
202
+ /**
203
+ * Parse a statement subscription notification. Returns Array<string> of hex statements.
204
+ * Returns an empty array if the text is not a statement notification.
205
+ * @param {string} text
206
+ * @returns {Array<any>}
207
+ */
208
+ parseStatementNotification(text) {
209
+ const ptr0 = passStringToWasm0(text, wasm.__wbindgen_export, wasm.__wbindgen_export2);
210
+ const len0 = WASM_VECTOR_LEN;
211
+ const ret = wasm.chainclienthandle_parseStatementNotification(this.__wbg_ptr, ptr0, len0);
212
+ return takeObject(ret);
213
+ }
214
+ /**
215
+ * Process a JSON-RPC response from the relay chain (for DB save only).
216
+ * @param {string} chain_name
217
+ * @param {string} text
218
+ */
219
+ processRelayResponse(chain_name, text) {
220
+ try {
221
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
222
+ const ptr0 = passStringToWasm0(chain_name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
223
+ const len0 = WASM_VECTOR_LEN;
224
+ const ptr1 = passStringToWasm0(text, wasm.__wbindgen_export, wasm.__wbindgen_export2);
225
+ const len1 = WASM_VECTOR_LEN;
226
+ wasm.chainclienthandle_processRelayResponse(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
227
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
228
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
229
+ if (r1) {
230
+ throw takeObject(r0);
231
+ }
232
+ } finally {
233
+ wasm.__wbindgen_add_to_stack_pointer(16);
234
+ }
235
+ }
236
+ /**
237
+ * Process a JSON-RPC response from smoldot for a parachain.
238
+ * Call this for every response from `chain.nextJsonRpcResponse()`.
239
+ * @param {string} chain_name
240
+ * @param {string} text
241
+ */
242
+ processResponse(chain_name, text) {
243
+ try {
244
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
245
+ const ptr0 = passStringToWasm0(chain_name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
246
+ const len0 = WASM_VECTOR_LEN;
247
+ const ptr1 = passStringToWasm0(text, wasm.__wbindgen_export, wasm.__wbindgen_export2);
248
+ const len1 = WASM_VECTOR_LEN;
249
+ wasm.chainclienthandle_processResponse(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
250
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
251
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
252
+ if (r1) {
253
+ throw takeObject(r0);
254
+ }
255
+ } finally {
256
+ wasm.__wbindgen_add_to_stack_pointer(16);
257
+ }
258
+ }
259
+ /**
260
+ * Register a chain for status tracking. Call after adding the chain to smoldot.
261
+ * @param {string} chain_name
262
+ */
263
+ registerChain(chain_name) {
264
+ try {
265
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
266
+ const ptr0 = passStringToWasm0(chain_name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
267
+ const len0 = WASM_VECTOR_LEN;
268
+ wasm.chainclienthandle_registerChain(retptr, this.__wbg_ptr, ptr0, len0);
269
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
270
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
271
+ if (r1) {
272
+ throw takeObject(r0);
273
+ }
274
+ } finally {
275
+ wasm.__wbindgen_add_to_stack_pointer(16);
276
+ }
277
+ }
278
+ /**
279
+ * JSON-RPC request to save relay chain DB (send to relay chain).
280
+ * @returns {string}
281
+ */
282
+ relayDbSaveRequest() {
283
+ let deferred1_0;
284
+ let deferred1_1;
285
+ try {
286
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
287
+ wasm.chainclienthandle_relayDbSaveRequest(retptr, this.__wbg_ptr);
288
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
289
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
290
+ deferred1_0 = r0;
291
+ deferred1_1 = r1;
292
+ return getStringFromWasm0(r0, r1);
293
+ } finally {
294
+ wasm.__wbindgen_add_to_stack_pointer(16);
295
+ wasm.__wbindgen_export5(deferred1_0, deferred1_1, 1);
296
+ }
297
+ }
298
+ /**
299
+ * Report an error for a chain (e.g. smoldot addChain failure).
300
+ * @param {string} chain_name
301
+ * @param {string} msg
302
+ */
303
+ setError(chain_name, msg) {
304
+ try {
305
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
306
+ const ptr0 = passStringToWasm0(chain_name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
307
+ const len0 = WASM_VECTOR_LEN;
308
+ const ptr1 = passStringToWasm0(msg, wasm.__wbindgen_export, wasm.__wbindgen_export2);
309
+ const len1 = WASM_VECTOR_LEN;
310
+ wasm.chainclienthandle_setError(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
311
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
312
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
313
+ if (r1) {
314
+ throw takeObject(r0);
315
+ }
316
+ } finally {
317
+ wasm.__wbindgen_add_to_stack_pointer(16);
318
+ }
319
+ }
320
+ /**
321
+ * JSON-RPC request to fetch broadcast statements by topic.
322
+ * @param {Array<any>} topic_hexes
323
+ * @param {number} request_id
324
+ * @returns {string}
325
+ */
326
+ statementBroadcastsRequest(topic_hexes, request_id) {
327
+ let deferred1_0;
328
+ let deferred1_1;
329
+ try {
330
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
331
+ wasm.chainclienthandle_statementBroadcastsRequest(retptr, this.__wbg_ptr, addHeapObject(topic_hexes), request_id);
332
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
333
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
334
+ deferred1_0 = r0;
335
+ deferred1_1 = r1;
336
+ return getStringFromWasm0(r0, r1);
337
+ } finally {
338
+ wasm.__wbindgen_add_to_stack_pointer(16);
339
+ wasm.__wbindgen_export5(deferred1_0, deferred1_1, 1);
340
+ }
341
+ }
342
+ /**
343
+ * JSON-RPC request to remove a statement by statement id/hash.
344
+ * @param {string} statement_id_hex
345
+ * @param {number} request_id
346
+ * @returns {string}
347
+ */
348
+ statementRemoveRequest(statement_id_hex, request_id) {
349
+ let deferred2_0;
350
+ let deferred2_1;
351
+ try {
352
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
353
+ const ptr0 = passStringToWasm0(statement_id_hex, wasm.__wbindgen_export, wasm.__wbindgen_export2);
354
+ const len0 = WASM_VECTOR_LEN;
355
+ wasm.chainclienthandle_statementRemoveRequest(retptr, this.__wbg_ptr, ptr0, len0, request_id);
356
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
357
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
358
+ deferred2_0 = r0;
359
+ deferred2_1 = r1;
360
+ return getStringFromWasm0(r0, r1);
361
+ } finally {
362
+ wasm.__wbindgen_add_to_stack_pointer(16);
363
+ wasm.__wbindgen_export5(deferred2_0, deferred2_1, 1);
364
+ }
365
+ }
366
+ /**
367
+ * JSON-RPC request to submit a statement (hex-encoded).
368
+ * @param {string} encoded_hex
369
+ * @param {number} request_id
370
+ * @returns {string}
371
+ */
372
+ statementSubmitRequest(encoded_hex, request_id) {
373
+ let deferred2_0;
374
+ let deferred2_1;
375
+ try {
376
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
377
+ const ptr0 = passStringToWasm0(encoded_hex, wasm.__wbindgen_export, wasm.__wbindgen_export2);
378
+ const len0 = WASM_VECTOR_LEN;
379
+ wasm.chainclienthandle_statementSubmitRequest(retptr, this.__wbg_ptr, ptr0, len0, request_id);
380
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
381
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
382
+ deferred2_0 = r0;
383
+ deferred2_1 = r1;
384
+ return getStringFromWasm0(r0, r1);
385
+ } finally {
386
+ wasm.__wbindgen_add_to_stack_pointer(16);
387
+ wasm.__wbindgen_export5(deferred2_0, deferred2_1, 1);
388
+ }
389
+ }
390
+ /**
391
+ * JSON-RPC request to subscribe to statement notifications.
392
+ * @param {number} request_id
393
+ * @returns {string}
394
+ */
395
+ statementSubscribeRequest(request_id) {
396
+ let deferred1_0;
397
+ let deferred1_1;
398
+ try {
399
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
400
+ wasm.chainclienthandle_statementSubscribeRequest(retptr, this.__wbg_ptr, request_id);
401
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
402
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
403
+ deferred1_0 = r0;
404
+ deferred1_1 = r1;
405
+ return getStringFromWasm0(r0, r1);
406
+ } finally {
407
+ wasm.__wbindgen_add_to_stack_pointer(16);
408
+ wasm.__wbindgen_export5(deferred1_0, deferred1_1, 1);
409
+ }
410
+ }
411
+ /**
412
+ * JSON-RPC request to unsubscribe from statement notifications.
413
+ * @param {string} sub_id
414
+ * @param {number} request_id
415
+ * @returns {string}
416
+ */
417
+ statementUnsubscribeRequest(sub_id, request_id) {
418
+ let deferred2_0;
419
+ let deferred2_1;
420
+ try {
421
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
422
+ const ptr0 = passStringToWasm0(sub_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
423
+ const len0 = WASM_VECTOR_LEN;
424
+ wasm.chainclienthandle_statementUnsubscribeRequest(retptr, this.__wbg_ptr, ptr0, len0, request_id);
425
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
426
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
427
+ deferred2_0 = r0;
428
+ deferred2_1 = r1;
429
+ return getStringFromWasm0(r0, r1);
430
+ } finally {
431
+ wasm.__wbindgen_add_to_stack_pointer(16);
432
+ wasm.__wbindgen_export5(deferred2_0, deferred2_1, 1);
433
+ }
434
+ }
435
+ /**
436
+ * Get the current status of a chain.
437
+ * @param {string} chain_name
438
+ * @returns {any}
439
+ */
440
+ status(chain_name) {
441
+ try {
442
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
443
+ const ptr0 = passStringToWasm0(chain_name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
444
+ const len0 = WASM_VECTOR_LEN;
445
+ wasm.chainclienthandle_status(retptr, this.__wbg_ptr, ptr0, len0);
446
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
447
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
448
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
449
+ if (r2) {
450
+ throw takeObject(r1);
451
+ }
452
+ return takeObject(r0);
453
+ } finally {
454
+ wasm.__wbindgen_add_to_stack_pointer(16);
455
+ }
456
+ }
457
+ /**
458
+ * JSON-RPC request to subscribe to finalized heads.
459
+ * @returns {string}
460
+ */
461
+ subscribeFinalizedHeadsRequest() {
462
+ let deferred1_0;
463
+ let deferred1_1;
464
+ try {
465
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
466
+ wasm.chainclienthandle_subscribeFinalizedHeadsRequest(retptr, this.__wbg_ptr);
467
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
468
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
469
+ deferred1_0 = r0;
470
+ deferred1_1 = r1;
471
+ return getStringFromWasm0(r0, r1);
472
+ } finally {
473
+ wasm.__wbindgen_add_to_stack_pointer(16);
474
+ wasm.__wbindgen_export5(deferred1_0, deferred1_1, 1);
475
+ }
476
+ }
477
+ /**
478
+ * JSON-RPC request to subscribe to new heads.
479
+ * @returns {string}
480
+ */
481
+ subscribeNewHeadsRequest() {
482
+ let deferred1_0;
483
+ let deferred1_1;
484
+ try {
485
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
486
+ wasm.chainclienthandle_subscribeNewHeadsRequest(retptr, this.__wbg_ptr);
487
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
488
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
489
+ deferred1_0 = r0;
490
+ deferred1_1 = r1;
491
+ return getStringFromWasm0(r0, r1);
492
+ } finally {
493
+ wasm.__wbindgen_add_to_stack_pointer(16);
494
+ wasm.__wbindgen_export5(deferred1_0, deferred1_1, 1);
495
+ }
496
+ }
497
+ /**
498
+ * Unregister a chain. Call after removing the chain from smoldot.
499
+ * @param {string} chain_name
500
+ */
501
+ unregisterChain(chain_name) {
502
+ try {
503
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
504
+ const ptr0 = passStringToWasm0(chain_name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
505
+ const len0 = WASM_VECTOR_LEN;
506
+ wasm.chainclienthandle_unregisterChain(retptr, this.__wbg_ptr, ptr0, len0);
507
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
508
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
509
+ if (r1) {
510
+ throw takeObject(r0);
511
+ }
512
+ } finally {
513
+ wasm.__wbindgen_add_to_stack_pointer(16);
514
+ }
515
+ }
516
+ }
517
+ if (Symbol.dispose) ChainClientHandle.prototype[Symbol.dispose] = ChainClientHandle.prototype.free;
518
+
519
+ /**
520
+ * JS-facing chat crypto handle for hosts that already own an attested
521
+ * sr25519 session account.
522
+ *
523
+ * This is intentionally narrower than `WalletHandle`: callers provide the
524
+ * account id and sr25519 session secret explicitly, and the handle only owns
525
+ * the P-256 material needed for chat request/session encryption. Statement
526
+ * signing stays with the embedding host via a callback in the TypeScript SDK.
527
+ */
528
+ export class ChatSessionHandle {
529
+ __destroy_into_raw() {
530
+ const ptr = this.__wbg_ptr;
531
+ this.__wbg_ptr = 0;
532
+ ChatSessionHandleFinalization.unregister(this);
533
+ return ptr;
534
+ }
535
+ free() {
536
+ const ptr = this.__destroy_into_raw();
537
+ wasm.__wbg_chatsessionhandle_free(ptr, 0);
538
+ }
539
+ /**
540
+ * Decrypt data produced by `chatP256Encrypt`.
541
+ * @param {Uint8Array} peer_identifier_key
542
+ * @param {Uint8Array} ciphertext
543
+ * @returns {Uint8Array}
544
+ */
545
+ chatP256Decrypt(peer_identifier_key, ciphertext) {
546
+ try {
547
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
548
+ const ptr0 = passArray8ToWasm0(peer_identifier_key, wasm.__wbindgen_export);
549
+ const len0 = WASM_VECTOR_LEN;
550
+ const ptr1 = passArray8ToWasm0(ciphertext, wasm.__wbindgen_export);
551
+ const len1 = WASM_VECTOR_LEN;
552
+ wasm.chatsessionhandle_chatP256Decrypt(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
553
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
554
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
555
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
556
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
557
+ if (r3) {
558
+ throw takeObject(r2);
559
+ }
560
+ var v3 = getArrayU8FromWasm0(r0, r1).slice();
561
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
562
+ return v3;
563
+ } finally {
564
+ wasm.__wbindgen_add_to_stack_pointer(16);
565
+ }
566
+ }
567
+ /**
568
+ * Encrypt with the v2 P-256/AES-GCM stack.
569
+ * @param {Uint8Array} peer_identifier_key
570
+ * @param {Uint8Array} plaintext
571
+ * @returns {Uint8Array}
572
+ */
573
+ chatP256Encrypt(peer_identifier_key, plaintext) {
574
+ try {
575
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
576
+ const ptr0 = passArray8ToWasm0(peer_identifier_key, wasm.__wbindgen_export);
577
+ const len0 = WASM_VECTOR_LEN;
578
+ const ptr1 = passArray8ToWasm0(plaintext, wasm.__wbindgen_export);
579
+ const len1 = WASM_VECTOR_LEN;
580
+ wasm.chatsessionhandle_chatP256Encrypt(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
581
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
582
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
583
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
584
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
585
+ if (r3) {
586
+ throw takeObject(r2);
587
+ }
588
+ var v3 = getArrayU8FromWasm0(r0, r1).slice();
589
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
590
+ return v3;
591
+ } finally {
592
+ wasm.__wbindgen_add_to_stack_pointer(16);
593
+ }
594
+ }
595
+ /**
596
+ * Build v2-compatible directional P-256 session ids and channels.
597
+ * @param {Uint8Array} peer_account_id
598
+ * @param {Uint8Array} peer_identifier_key
599
+ * @param {string | null} [own_pin]
600
+ * @param {string | null} [peer_pin]
601
+ * @returns {any}
602
+ */
603
+ chatP256Session(peer_account_id, peer_identifier_key, own_pin, peer_pin) {
604
+ try {
605
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
606
+ const ptr0 = passArray8ToWasm0(peer_account_id, wasm.__wbindgen_export);
607
+ const len0 = WASM_VECTOR_LEN;
608
+ const ptr1 = passArray8ToWasm0(peer_identifier_key, wasm.__wbindgen_export);
609
+ const len1 = WASM_VECTOR_LEN;
610
+ var ptr2 = isLikeNone(own_pin) ? 0 : passStringToWasm0(own_pin, wasm.__wbindgen_export, wasm.__wbindgen_export2);
611
+ var len2 = WASM_VECTOR_LEN;
612
+ var ptr3 = isLikeNone(peer_pin) ? 0 : passStringToWasm0(peer_pin, wasm.__wbindgen_export, wasm.__wbindgen_export2);
613
+ var len3 = WASM_VECTOR_LEN;
614
+ wasm.chatsessionhandle_chatP256Session(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
615
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
616
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
617
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
618
+ if (r2) {
619
+ throw takeObject(r1);
620
+ }
621
+ return takeObject(r0);
622
+ } finally {
623
+ wasm.__wbindgen_add_to_stack_pointer(16);
624
+ }
625
+ }
626
+ /**
627
+ * Canonical 65-byte uncompressed P-256 identifier key for this chat identity.
628
+ * @returns {Uint8Array}
629
+ */
630
+ identifierKey() {
631
+ try {
632
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
633
+ wasm.chatsessionhandle_identifierKey(retptr, this.__wbg_ptr);
634
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
635
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
636
+ var v1 = getArrayU8FromWasm0(r0, r1).slice();
637
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
638
+ return v1;
639
+ } finally {
640
+ wasm.__wbindgen_add_to_stack_pointer(16);
641
+ }
642
+ }
643
+ /**
644
+ * Build chat P-256 material from an existing sr25519 session account.
645
+ *
646
+ * `account_id` must be the 32-byte public key registered on People chain.
647
+ * `session_secret` must contain at least the 32-byte scalar half used by
648
+ * sr25519 signing implementations such as host-papp.
649
+ * @param {Uint8Array} account_id
650
+ * @param {Uint8Array} session_secret
651
+ */
652
+ constructor(account_id, session_secret) {
653
+ try {
654
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
655
+ const ptr0 = passArray8ToWasm0(account_id, wasm.__wbindgen_export);
656
+ const len0 = WASM_VECTOR_LEN;
657
+ const ptr1 = passArray8ToWasm0(session_secret, wasm.__wbindgen_export);
658
+ const len1 = WASM_VECTOR_LEN;
659
+ wasm.chatsessionhandle_new(retptr, ptr0, len0, ptr1, len1);
660
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
661
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
662
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
663
+ if (r2) {
664
+ throw takeObject(r1);
665
+ }
666
+ this.__wbg_ptr = r0;
667
+ ChatSessionHandleFinalization.register(this, this.__wbg_ptr, this);
668
+ return this;
669
+ } finally {
670
+ wasm.__wbindgen_add_to_stack_pointer(16);
671
+ }
672
+ }
673
+ /**
674
+ * 32-byte sr25519 public key for this chat identity.
675
+ * @returns {Uint8Array}
676
+ */
677
+ walletPublicKey() {
678
+ try {
679
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
680
+ wasm.chatsessionhandle_walletPublicKey(retptr, this.__wbg_ptr);
681
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
682
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
683
+ var v1 = getArrayU8FromWasm0(r0, r1).slice();
684
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
685
+ return v1;
686
+ } finally {
687
+ wasm.__wbindgen_add_to_stack_pointer(16);
688
+ }
689
+ }
690
+ }
691
+ if (Symbol.dispose) ChatSessionHandle.prototype[Symbol.dispose] = ChatSessionHandle.prototype.free;
692
+
693
+ /**
694
+ * JS-facing DOTNS encoding utilities.
695
+ *
696
+ * All functions are pure — no I/O or network. The browser is responsible
697
+ * for transport (e.g. polkadot-api / smoldot-js).
698
+ */
699
+ export class DotnsHandle {
700
+ __destroy_into_raw() {
701
+ const ptr = this.__wbg_ptr;
702
+ this.__wbg_ptr = 0;
703
+ DotnsHandleFinalization.unregister(this);
704
+ return ptr;
705
+ }
706
+ free() {
707
+ const ptr = this.__destroy_into_raw();
708
+ wasm.__wbg_dotnshandle_free(ptr, 0);
709
+ }
710
+ /**
711
+ * Parse a contenthash into a CIDv1 base32 string.
712
+ * @param {Uint8Array} contenthash
713
+ * @returns {string}
714
+ */
715
+ contenthashToCid(contenthash) {
716
+ let deferred3_0;
717
+ let deferred3_1;
718
+ try {
719
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
720
+ const ptr0 = passArray8ToWasm0(contenthash, wasm.__wbindgen_export);
721
+ const len0 = WASM_VECTOR_LEN;
722
+ wasm.dotnshandle_contenthashToCid(retptr, this.__wbg_ptr, ptr0, len0);
723
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
724
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
725
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
726
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
727
+ var ptr2 = r0;
728
+ var len2 = r1;
729
+ if (r3) {
730
+ ptr2 = 0; len2 = 0;
731
+ throw takeObject(r2);
732
+ }
733
+ deferred3_0 = ptr2;
734
+ deferred3_1 = len2;
735
+ return getStringFromWasm0(ptr2, len2);
736
+ } finally {
737
+ wasm.__wbindgen_add_to_stack_pointer(16);
738
+ wasm.__wbindgen_export5(deferred3_0, deferred3_1, 1);
739
+ }
740
+ }
741
+ /**
742
+ * Decode ABI-encoded `bytes` from Solidity return data.
743
+ * @param {Uint8Array} data
744
+ * @returns {Uint8Array}
745
+ */
746
+ decodeAbiBytes(data) {
747
+ try {
748
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
749
+ const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export);
750
+ const len0 = WASM_VECTOR_LEN;
751
+ wasm.dotnshandle_decodeAbiBytes(retptr, this.__wbg_ptr, ptr0, len0);
752
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
753
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
754
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
755
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
756
+ if (r3) {
757
+ throw takeObject(r2);
758
+ }
759
+ var v2 = getArrayU8FromWasm0(r0, r1).slice();
760
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
761
+ return v2;
762
+ } finally {
763
+ wasm.__wbindgen_add_to_stack_pointer(16);
764
+ }
765
+ }
766
+ /**
767
+ * Decode the ContractResult from a `ReviveApi_call` response.
768
+ * @param {Uint8Array} response
769
+ * @returns {Uint8Array}
770
+ */
771
+ decodeContractResult(response) {
772
+ try {
773
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
774
+ const ptr0 = passArray8ToWasm0(response, wasm.__wbindgen_export);
775
+ const len0 = WASM_VECTOR_LEN;
776
+ wasm.dotnshandle_decodeContractResult(retptr, this.__wbg_ptr, ptr0, len0);
777
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
778
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
779
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
780
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
781
+ if (r3) {
782
+ throw takeObject(r2);
783
+ }
784
+ var v2 = getArrayU8FromWasm0(r0, r1).slice();
785
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
786
+ return v2;
787
+ } finally {
788
+ wasm.__wbindgen_add_to_stack_pointer(16);
789
+ }
790
+ }
791
+ /**
792
+ * ABI-encode `contenthash(bytes32)` call data for the given namehash.
793
+ * @param {Uint8Array} node
794
+ * @returns {Uint8Array}
795
+ */
796
+ encodeContenthashCall(node) {
797
+ try {
798
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
799
+ const ptr0 = passArray8ToWasm0(node, wasm.__wbindgen_export);
800
+ const len0 = WASM_VECTOR_LEN;
801
+ wasm.dotnshandle_encodeContenthashCall(retptr, this.__wbg_ptr, ptr0, len0);
802
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
803
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
804
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
805
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
806
+ if (r3) {
807
+ throw takeObject(r2);
808
+ }
809
+ var v2 = getArrayU8FromWasm0(r0, r1).slice();
810
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
811
+ return v2;
812
+ } finally {
813
+ wasm.__wbindgen_add_to_stack_pointer(16);
814
+ }
815
+ }
816
+ /**
817
+ * Hex-decode a `0x`-prefixed (or bare) hex string.
818
+ * @param {string} s
819
+ * @returns {Uint8Array}
820
+ */
821
+ hexDecode(s) {
822
+ try {
823
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
824
+ const ptr0 = passStringToWasm0(s, wasm.__wbindgen_export, wasm.__wbindgen_export2);
825
+ const len0 = WASM_VECTOR_LEN;
826
+ wasm.dotnshandle_hexDecode(retptr, this.__wbg_ptr, ptr0, len0);
827
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
828
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
829
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
830
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
831
+ if (r3) {
832
+ throw takeObject(r2);
833
+ }
834
+ var v2 = getArrayU8FromWasm0(r0, r1).slice();
835
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
836
+ return v2;
837
+ } finally {
838
+ wasm.__wbindgen_add_to_stack_pointer(16);
839
+ }
840
+ }
841
+ /**
842
+ * Hex-encode bytes with `0x` prefix.
843
+ * @param {Uint8Array} bytes
844
+ * @returns {string}
845
+ */
846
+ hexEncode(bytes) {
847
+ let deferred2_0;
848
+ let deferred2_1;
849
+ try {
850
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
851
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
852
+ const len0 = WASM_VECTOR_LEN;
853
+ wasm.dotnshandle_hexEncode(retptr, this.__wbg_ptr, ptr0, len0);
854
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
855
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
856
+ deferred2_0 = r0;
857
+ deferred2_1 = r1;
858
+ return getStringFromWasm0(r0, r1);
859
+ } finally {
860
+ wasm.__wbindgen_add_to_stack_pointer(16);
861
+ wasm.__wbindgen_export5(deferred2_0, deferred2_1, 1);
862
+ }
863
+ }
864
+ /**
865
+ * Compute ENS-style namehash for a `.dot` domain.
866
+ * @param {string} name
867
+ * @returns {Uint8Array}
868
+ */
869
+ namehash(name) {
870
+ try {
871
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
872
+ const ptr0 = passStringToWasm0(name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
873
+ const len0 = WASM_VECTOR_LEN;
874
+ wasm.dotnshandle_namehash(retptr, this.__wbg_ptr, ptr0, len0);
875
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
876
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
877
+ var v2 = getArrayU8FromWasm0(r0, r1).slice();
878
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
879
+ return v2;
880
+ } finally {
881
+ wasm.__wbindgen_add_to_stack_pointer(16);
882
+ }
883
+ }
884
+ constructor() {
885
+ const ret = wasm.dotnshandle_new();
886
+ this.__wbg_ptr = ret;
887
+ DotnsHandleFinalization.register(this, this.__wbg_ptr, this);
888
+ return this;
889
+ }
890
+ /**
891
+ * Parse a CARv1 `.prod` bundle into an asset map.
892
+ *
893
+ * Returns a plain JS object where each key is a filename and each value is a `Uint8Array`.
894
+ * @param {Uint8Array} data
895
+ * @returns {any}
896
+ */
897
+ parseCarAssets(data) {
898
+ try {
899
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
900
+ const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export);
901
+ const len0 = WASM_VECTOR_LEN;
902
+ wasm.dotnshandle_parseCarAssets(retptr, this.__wbg_ptr, ptr0, len0);
903
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
904
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
905
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
906
+ if (r2) {
907
+ throw takeObject(r1);
908
+ }
909
+ return takeObject(r0);
910
+ } finally {
911
+ wasm.__wbindgen_add_to_stack_pointer(16);
912
+ }
913
+ }
914
+ /**
915
+ * Resolve a `.dot` name, fetch from IPFS, and return an asset map as a JS object.
916
+ *
917
+ * The returned value is a plain JS object where each key is a filename (string)
918
+ * and each value is a `Uint8Array`. Automatically converts to a `Promise` for JS callers.
919
+ * @param {string} name
920
+ * @returns {Promise<any>}
921
+ */
922
+ resolveAndFetch(name) {
923
+ const ptr0 = passStringToWasm0(name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
924
+ const len0 = WASM_VECTOR_LEN;
925
+ const ret = wasm.dotnshandle_resolveAndFetch(this.__wbg_ptr, ptr0, len0);
926
+ return takeObject(ret);
927
+ }
928
+ /**
929
+ * SCALE-encode `ReviveApi::call()` parameters.
930
+ * @param {Uint8Array} contract_addr
931
+ * @param {Uint8Array} call_data
932
+ * @returns {Uint8Array}
933
+ */
934
+ scaleEncodeReviveCall(contract_addr, call_data) {
935
+ try {
936
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
937
+ const ptr0 = passArray8ToWasm0(contract_addr, wasm.__wbindgen_export);
938
+ const len0 = WASM_VECTOR_LEN;
939
+ const ptr1 = passArray8ToWasm0(call_data, wasm.__wbindgen_export);
940
+ const len1 = WASM_VECTOR_LEN;
941
+ wasm.dotnshandle_scaleEncodeReviveCall(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
942
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
943
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
944
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
945
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
946
+ if (r3) {
947
+ throw takeObject(r2);
948
+ }
949
+ var v3 = getArrayU8FromWasm0(r0, r1).slice();
950
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
951
+ return v3;
952
+ } finally {
953
+ wasm.__wbindgen_add_to_stack_pointer(16);
954
+ }
955
+ }
956
+ }
957
+ if (Symbol.dispose) DotnsHandle.prototype[Symbol.dispose] = DotnsHandle.prototype.free;
958
+
959
+ /**
960
+ * JS-facing wrapper over `useragent_api::HostApi`.
961
+ *
962
+ * Processes binary SCALE-encoded messages from Polkadot apps and returns
963
+ * structured outcomes that the TypeScript adapter routes to the appropriate
964
+ * subsystem (smoldot JS, wallet, navigation).
965
+ */
966
+ export class HostApiHandle {
967
+ __destroy_into_raw() {
968
+ const ptr = this.__wbg_ptr;
969
+ this.__wbg_ptr = 0;
970
+ HostApiHandleFinalization.unregister(this);
971
+ return ptr;
972
+ }
973
+ free() {
974
+ const ptr = this.__destroy_into_raw();
975
+ wasm.__wbg_hostapihandle_free(ptr, 0);
976
+ }
977
+ /**
978
+ * Get the HOST_API_BRIDGE_SCRIPT for WebView injection.
979
+ * @returns {string}
980
+ */
981
+ static bridgeScript() {
982
+ let deferred1_0;
983
+ let deferred1_1;
984
+ try {
985
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
986
+ wasm.hostapihandle_bridgeScript(retptr);
987
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
988
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
989
+ deferred1_0 = r0;
990
+ deferred1_1 = r1;
991
+ return getStringFromWasm0(r0, r1);
992
+ } finally {
993
+ wasm.__wbindgen_add_to_stack_pointer(16);
994
+ wasm.__wbindgen_export5(deferred1_0, deferred1_1, 1);
995
+ }
996
+ }
997
+ /**
998
+ * @param {string} request_id
999
+ * @param {string} error_kind
1000
+ * @param {string | null} [reason]
1001
+ * @returns {Uint8Array}
1002
+ */
1003
+ encodeAccountCreateProofError(request_id, error_kind, reason) {
1004
+ try {
1005
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1006
+ const ptr0 = passStringToWasm0(request_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1007
+ const len0 = WASM_VECTOR_LEN;
1008
+ const ptr1 = passStringToWasm0(error_kind, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1009
+ const len1 = WASM_VECTOR_LEN;
1010
+ var ptr2 = isLikeNone(reason) ? 0 : passStringToWasm0(reason, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1011
+ var len2 = WASM_VECTOR_LEN;
1012
+ wasm.hostapihandle_encodeAccountCreateProofError(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
1013
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1014
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1015
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
1016
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
1017
+ if (r3) {
1018
+ throw takeObject(r2);
1019
+ }
1020
+ var v4 = getArrayU8FromWasm0(r0, r1).slice();
1021
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
1022
+ return v4;
1023
+ } finally {
1024
+ wasm.__wbindgen_add_to_stack_pointer(16);
1025
+ }
1026
+ }
1027
+ /**
1028
+ * @param {string} request_id
1029
+ * @param {Uint8Array} proof
1030
+ * @returns {Uint8Array}
1031
+ */
1032
+ encodeAccountCreateProofResponse(request_id, proof) {
1033
+ try {
1034
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1035
+ const ptr0 = passStringToWasm0(request_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1036
+ const len0 = WASM_VECTOR_LEN;
1037
+ const ptr1 = passArray8ToWasm0(proof, wasm.__wbindgen_export);
1038
+ const len1 = WASM_VECTOR_LEN;
1039
+ wasm.hostapihandle_encodeAccountCreateProofResponse(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
1040
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1041
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1042
+ var v3 = getArrayU8FromWasm0(r0, r1).slice();
1043
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
1044
+ return v3;
1045
+ } finally {
1046
+ wasm.__wbindgen_add_to_stack_pointer(16);
1047
+ }
1048
+ }
1049
+ /**
1050
+ * @param {string} request_id
1051
+ * @param {string} error_kind
1052
+ * @param {string | null} [reason]
1053
+ * @returns {Uint8Array}
1054
+ */
1055
+ encodeAccountGetAliasError(request_id, error_kind, reason) {
1056
+ try {
1057
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1058
+ const ptr0 = passStringToWasm0(request_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1059
+ const len0 = WASM_VECTOR_LEN;
1060
+ const ptr1 = passStringToWasm0(error_kind, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1061
+ const len1 = WASM_VECTOR_LEN;
1062
+ var ptr2 = isLikeNone(reason) ? 0 : passStringToWasm0(reason, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1063
+ var len2 = WASM_VECTOR_LEN;
1064
+ wasm.hostapihandle_encodeAccountGetAliasError(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
1065
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1066
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1067
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
1068
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
1069
+ if (r3) {
1070
+ throw takeObject(r2);
1071
+ }
1072
+ var v4 = getArrayU8FromWasm0(r0, r1).slice();
1073
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
1074
+ return v4;
1075
+ } finally {
1076
+ wasm.__wbindgen_add_to_stack_pointer(16);
1077
+ }
1078
+ }
1079
+ /**
1080
+ * @param {string} request_id
1081
+ * @param {Uint8Array} context
1082
+ * @param {Uint8Array} alias
1083
+ * @returns {Uint8Array}
1084
+ */
1085
+ encodeAccountGetAliasResponse(request_id, context, alias) {
1086
+ try {
1087
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1088
+ const ptr0 = passStringToWasm0(request_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1089
+ const len0 = WASM_VECTOR_LEN;
1090
+ const ptr1 = passArray8ToWasm0(context, wasm.__wbindgen_export);
1091
+ const len1 = WASM_VECTOR_LEN;
1092
+ const ptr2 = passArray8ToWasm0(alias, wasm.__wbindgen_export);
1093
+ const len2 = WASM_VECTOR_LEN;
1094
+ wasm.hostapihandle_encodeAccountGetAliasResponse(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
1095
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1096
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1097
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
1098
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
1099
+ if (r3) {
1100
+ throw takeObject(r2);
1101
+ }
1102
+ var v4 = getArrayU8FromWasm0(r0, r1).slice();
1103
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
1104
+ return v4;
1105
+ } finally {
1106
+ wasm.__wbindgen_add_to_stack_pointer(16);
1107
+ }
1108
+ }
1109
+ /**
1110
+ * @param {string} request_id
1111
+ * @param {string} error_kind
1112
+ * @param {string | null} [reason]
1113
+ * @returns {Uint8Array}
1114
+ */
1115
+ encodeAccountGetError(request_id, error_kind, reason) {
1116
+ try {
1117
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1118
+ const ptr0 = passStringToWasm0(request_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1119
+ const len0 = WASM_VECTOR_LEN;
1120
+ const ptr1 = passStringToWasm0(error_kind, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1121
+ const len1 = WASM_VECTOR_LEN;
1122
+ var ptr2 = isLikeNone(reason) ? 0 : passStringToWasm0(reason, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1123
+ var len2 = WASM_VECTOR_LEN;
1124
+ wasm.hostapihandle_encodeAccountGetError(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
1125
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1126
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1127
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
1128
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
1129
+ if (r3) {
1130
+ throw takeObject(r2);
1131
+ }
1132
+ var v4 = getArrayU8FromWasm0(r0, r1).slice();
1133
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
1134
+ return v4;
1135
+ } finally {
1136
+ wasm.__wbindgen_add_to_stack_pointer(16);
1137
+ }
1138
+ }
1139
+ /**
1140
+ * Encode a `host_account_get` success response (v0.7.4).
1141
+ *
1142
+ * Wire shape: `Result::Ok(ProductAccount { publicKey })` — `name` was
1143
+ * removed in v0.7.4; SPAs use `host_get_user_id` for display names.
1144
+ * @param {string} request_id
1145
+ * @param {Uint8Array} public_key
1146
+ * @returns {Uint8Array}
1147
+ */
1148
+ encodeAccountGetResponse(request_id, public_key) {
1149
+ try {
1150
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1151
+ const ptr0 = passStringToWasm0(request_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1152
+ const len0 = WASM_VECTOR_LEN;
1153
+ const ptr1 = passArray8ToWasm0(public_key, wasm.__wbindgen_export);
1154
+ const len1 = WASM_VECTOR_LEN;
1155
+ wasm.hostapihandle_encodeAccountGetResponse(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
1156
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1157
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1158
+ var v3 = getArrayU8FromWasm0(r0, r1).slice();
1159
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
1160
+ return v3;
1161
+ } finally {
1162
+ wasm.__wbindgen_add_to_stack_pointer(16);
1163
+ }
1164
+ }
1165
+ /**
1166
+ * Encode a chain-head follow event notification.
1167
+ * @param {string} request_id
1168
+ * @param {string} json_rpc_msg
1169
+ * @returns {Uint8Array}
1170
+ */
1171
+ encodeChainFollowEvent(request_id, json_rpc_msg) {
1172
+ try {
1173
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1174
+ const ptr0 = passStringToWasm0(request_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1175
+ const len0 = WASM_VECTOR_LEN;
1176
+ const ptr1 = passStringToWasm0(json_rpc_msg, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1177
+ const len1 = WASM_VECTOR_LEN;
1178
+ wasm.hostapihandle_encodeChainFollowEvent(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
1179
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1180
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1181
+ var v3 = getArrayU8FromWasm0(r0, r1).slice();
1182
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
1183
+ return v3;
1184
+ } finally {
1185
+ wasm.__wbindgen_add_to_stack_pointer(16);
1186
+ }
1187
+ }
1188
+ /**
1189
+ * Encode a synthetic follow stop event for unsupported/disconnected chains.
1190
+ * @param {string} request_id
1191
+ * @returns {Uint8Array}
1192
+ */
1193
+ encodeChainFollowStop(request_id) {
1194
+ try {
1195
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1196
+ const ptr0 = passStringToWasm0(request_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1197
+ const len0 = WASM_VECTOR_LEN;
1198
+ wasm.hostapihandle_encodeChainFollowStop(retptr, this.__wbg_ptr, ptr0, len0);
1199
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1200
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1201
+ var v2 = getArrayU8FromWasm0(r0, r1).slice();
1202
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
1203
+ return v2;
1204
+ } finally {
1205
+ wasm.__wbindgen_add_to_stack_pointer(16);
1206
+ }
1207
+ }
1208
+ /**
1209
+ * Encode a one-shot JSON-RPC error for `NeedsChainQuery`.
1210
+ * @param {string} request_id
1211
+ * @returns {Uint8Array}
1212
+ */
1213
+ encodeChainQueryError(request_id) {
1214
+ try {
1215
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1216
+ const ptr0 = passStringToWasm0(request_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1217
+ const len0 = WASM_VECTOR_LEN;
1218
+ wasm.hostapihandle_encodeChainQueryError(retptr, this.__wbg_ptr, ptr0, len0);
1219
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1220
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1221
+ var v2 = getArrayU8FromWasm0(r0, r1).slice();
1222
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
1223
+ return v2;
1224
+ } finally {
1225
+ wasm.__wbindgen_add_to_stack_pointer(16);
1226
+ }
1227
+ }
1228
+ /**
1229
+ * Encode a one-shot JSON-RPC response for `NeedsChainQuery`.
1230
+ * @param {string} request_id
1231
+ * @param {string} json_rpc_result
1232
+ * @returns {Uint8Array}
1233
+ */
1234
+ encodeChainQueryResponse(request_id, json_rpc_result) {
1235
+ try {
1236
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1237
+ const ptr0 = passStringToWasm0(request_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1238
+ const len0 = WASM_VECTOR_LEN;
1239
+ const ptr1 = passStringToWasm0(json_rpc_result, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1240
+ const len1 = WASM_VECTOR_LEN;
1241
+ wasm.hostapihandle_encodeChainQueryResponse(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
1242
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1243
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1244
+ var v3 = getArrayU8FromWasm0(r0, r1).slice();
1245
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
1246
+ return v3;
1247
+ } finally {
1248
+ wasm.__wbindgen_add_to_stack_pointer(16);
1249
+ }
1250
+ }
1251
+ /**
1252
+ * Encode a chain RPC error using the correct chain protocol envelope.
1253
+ * @param {string} request_id
1254
+ * @param {number} request_tag
1255
+ * @param {string} reason
1256
+ * @returns {Uint8Array}
1257
+ */
1258
+ encodeChainRpcError(request_id, request_tag, reason) {
1259
+ try {
1260
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1261
+ const ptr0 = passStringToWasm0(request_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1262
+ const len0 = WASM_VECTOR_LEN;
1263
+ const ptr1 = passStringToWasm0(reason, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1264
+ const len1 = WASM_VECTOR_LEN;
1265
+ wasm.hostapihandle_encodeChainRpcError(retptr, this.__wbg_ptr, ptr0, len0, request_tag, ptr1, len1);
1266
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1267
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1268
+ var v3 = getArrayU8FromWasm0(r0, r1).slice();
1269
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
1270
+ return v3;
1271
+ } finally {
1272
+ wasm.__wbindgen_add_to_stack_pointer(16);
1273
+ }
1274
+ }
1275
+ /**
1276
+ * Encode a chain RPC response using the correct chain protocol envelope.
1277
+ * @param {string} request_id
1278
+ * @param {number} request_tag
1279
+ * @param {string} json_rpc_msg
1280
+ * @returns {Uint8Array}
1281
+ */
1282
+ encodeChainRpcResponse(request_id, request_tag, json_rpc_msg) {
1283
+ try {
1284
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1285
+ const ptr0 = passStringToWasm0(request_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1286
+ const len0 = WASM_VECTOR_LEN;
1287
+ const ptr1 = passStringToWasm0(json_rpc_msg, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1288
+ const len1 = WASM_VECTOR_LEN;
1289
+ wasm.hostapihandle_encodeChainRpcResponse(retptr, this.__wbg_ptr, ptr0, len0, request_tag, ptr1, len1);
1290
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1291
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1292
+ var v3 = getArrayU8FromWasm0(r0, r1).slice();
1293
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
1294
+ return v3;
1295
+ } finally {
1296
+ wasm.__wbindgen_add_to_stack_pointer(16);
1297
+ }
1298
+ }
1299
+ /**
1300
+ * Encode a streaming JSON-RPC subscription message for `NeedsChainSubscription`.
1301
+ * @param {string} request_id
1302
+ * @param {string} json_rpc_msg
1303
+ * @returns {Uint8Array}
1304
+ */
1305
+ encodeChainSubNotification(request_id, json_rpc_msg) {
1306
+ try {
1307
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1308
+ const ptr0 = passStringToWasm0(request_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1309
+ const len0 = WASM_VECTOR_LEN;
1310
+ const ptr1 = passStringToWasm0(json_rpc_msg, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1311
+ const len1 = WASM_VECTOR_LEN;
1312
+ wasm.hostapihandle_encodeChainSubNotification(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
1313
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1314
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1315
+ var v3 = getArrayU8FromWasm0(r0, r1).slice();
1316
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
1317
+ return v3;
1318
+ } finally {
1319
+ wasm.__wbindgen_add_to_stack_pointer(16);
1320
+ }
1321
+ }
1322
+ /**
1323
+ * Encode a `host_create_transaction` error response.
1324
+ *
1325
+ * `error_kind`: one of `"rejected"`, `"not_supported"`, `"permission_denied"`,
1326
+ * `"failed_to_decode"`, or `"unknown"` (default).
1327
+ * @param {string} request_id
1328
+ * @param {string} error_kind
1329
+ * @param {string | null} [reason]
1330
+ * @returns {Uint8Array}
1331
+ */
1332
+ encodeCreateTransactionError(request_id, error_kind, reason) {
1333
+ try {
1334
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1335
+ const ptr0 = passStringToWasm0(request_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1336
+ const len0 = WASM_VECTOR_LEN;
1337
+ const ptr1 = passStringToWasm0(error_kind, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1338
+ const len1 = WASM_VECTOR_LEN;
1339
+ var ptr2 = isLikeNone(reason) ? 0 : passStringToWasm0(reason, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1340
+ var len2 = WASM_VECTOR_LEN;
1341
+ wasm.hostapihandle_encodeCreateTransactionError(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
1342
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1343
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1344
+ var v4 = getArrayU8FromWasm0(r0, r1).slice();
1345
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
1346
+ return v4;
1347
+ } finally {
1348
+ wasm.__wbindgen_add_to_stack_pointer(16);
1349
+ }
1350
+ }
1351
+ /**
1352
+ * Encode a successful `host_create_transaction` response.
1353
+ * @param {string} request_id
1354
+ * @param {Uint8Array} signed_tx_bytes
1355
+ * @returns {Uint8Array}
1356
+ */
1357
+ encodeCreateTransactionResponse(request_id, signed_tx_bytes) {
1358
+ try {
1359
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1360
+ const ptr0 = passStringToWasm0(request_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1361
+ const len0 = WASM_VECTOR_LEN;
1362
+ const ptr1 = passArray8ToWasm0(signed_tx_bytes, wasm.__wbindgen_export);
1363
+ const len1 = WASM_VECTOR_LEN;
1364
+ wasm.hostapihandle_encodeCreateTransactionResponse(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
1365
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1366
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1367
+ var v3 = getArrayU8FromWasm0(r0, r1).slice();
1368
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
1369
+ return v3;
1370
+ } finally {
1371
+ wasm.__wbindgen_add_to_stack_pointer(16);
1372
+ }
1373
+ }
1374
+ /**
1375
+ * Encode a `host_create_transaction_with_legacy_account` error response.
1376
+ * @param {string} request_id
1377
+ * @param {string} error_kind
1378
+ * @param {string | null} [reason]
1379
+ * @returns {Uint8Array}
1380
+ */
1381
+ encodeCreateTxNonProductError(request_id, error_kind, reason) {
1382
+ try {
1383
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1384
+ const ptr0 = passStringToWasm0(request_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1385
+ const len0 = WASM_VECTOR_LEN;
1386
+ const ptr1 = passStringToWasm0(error_kind, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1387
+ const len1 = WASM_VECTOR_LEN;
1388
+ var ptr2 = isLikeNone(reason) ? 0 : passStringToWasm0(reason, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1389
+ var len2 = WASM_VECTOR_LEN;
1390
+ wasm.hostapihandle_encodeCreateTxNonProductError(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
1391
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1392
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1393
+ var v4 = getArrayU8FromWasm0(r0, r1).slice();
1394
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
1395
+ return v4;
1396
+ } finally {
1397
+ wasm.__wbindgen_add_to_stack_pointer(16);
1398
+ }
1399
+ }
1400
+ /**
1401
+ * Encode a successful `host_create_transaction_with_legacy_account` response.
1402
+ * @param {string} request_id
1403
+ * @param {Uint8Array} signed_tx_bytes
1404
+ * @returns {Uint8Array}
1405
+ */
1406
+ encodeCreateTxNonProductResponse(request_id, signed_tx_bytes) {
1407
+ try {
1408
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1409
+ const ptr0 = passStringToWasm0(request_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1410
+ const len0 = WASM_VECTOR_LEN;
1411
+ const ptr1 = passArray8ToWasm0(signed_tx_bytes, wasm.__wbindgen_export);
1412
+ const len1 = WASM_VECTOR_LEN;
1413
+ wasm.hostapihandle_encodeCreateTxNonProductResponse(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
1414
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1415
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1416
+ var v3 = getArrayU8FromWasm0(r0, r1).slice();
1417
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
1418
+ return v3;
1419
+ } finally {
1420
+ wasm.__wbindgen_add_to_stack_pointer(16);
1421
+ }
1422
+ }
1423
+ /**
1424
+ * Encode a `host_device_permission` error response.
1425
+ * @param {string} request_id
1426
+ * @returns {Uint8Array}
1427
+ */
1428
+ encodeDevicePermissionError(request_id) {
1429
+ try {
1430
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1431
+ const ptr0 = passStringToWasm0(request_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1432
+ const len0 = WASM_VECTOR_LEN;
1433
+ wasm.hostapihandle_encodeDevicePermissionError(retptr, this.__wbg_ptr, ptr0, len0);
1434
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1435
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1436
+ var v2 = getArrayU8FromWasm0(r0, r1).slice();
1437
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
1438
+ return v2;
1439
+ } finally {
1440
+ wasm.__wbindgen_add_to_stack_pointer(16);
1441
+ }
1442
+ }
1443
+ /**
1444
+ * Encode a `host_device_permission` response.
1445
+ * @param {string} request_id
1446
+ * @param {boolean} granted
1447
+ * @returns {Uint8Array}
1448
+ */
1449
+ encodeDevicePermissionResponse(request_id, granted) {
1450
+ try {
1451
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1452
+ const ptr0 = passStringToWasm0(request_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1453
+ const len0 = WASM_VECTOR_LEN;
1454
+ wasm.hostapihandle_encodeDevicePermissionResponse(retptr, this.__wbg_ptr, ptr0, len0, granted);
1455
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1456
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1457
+ var v2 = getArrayU8FromWasm0(r0, r1).slice();
1458
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
1459
+ return v2;
1460
+ } finally {
1461
+ wasm.__wbindgen_add_to_stack_pointer(16);
1462
+ }
1463
+ }
1464
+ /**
1465
+ * Encode a navigation acknowledgement.
1466
+ * @param {string} request_id
1467
+ * @returns {Uint8Array}
1468
+ */
1469
+ encodeNavigateResponse(request_id) {
1470
+ try {
1471
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1472
+ const ptr0 = passStringToWasm0(request_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1473
+ const len0 = WASM_VECTOR_LEN;
1474
+ wasm.hostapihandle_encodeNavigateResponse(retptr, this.__wbg_ptr, ptr0, len0);
1475
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1476
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1477
+ var v2 = getArrayU8FromWasm0(r0, r1).slice();
1478
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
1479
+ return v2;
1480
+ } finally {
1481
+ wasm.__wbindgen_add_to_stack_pointer(16);
1482
+ }
1483
+ }
1484
+ /**
1485
+ * Encode a payment balance snapshot for `NeedsPaymentBalanceSubscription`.
1486
+ *
1487
+ * `balance` must be a JS object with shape:
1488
+ * `{ available: { currency: string, minor_units: string }, pending: { currency: string, minor_units: string } }`.
1489
+ * @param {string} request_id
1490
+ * @param {any} balance
1491
+ * @returns {Uint8Array}
1492
+ */
1493
+ encodePaymentBalance(request_id, balance) {
1494
+ try {
1495
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1496
+ const ptr0 = passStringToWasm0(request_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1497
+ const len0 = WASM_VECTOR_LEN;
1498
+ wasm.hostapihandle_encodePaymentBalance(retptr, this.__wbg_ptr, ptr0, len0, addHeapObject(balance));
1499
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1500
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1501
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
1502
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
1503
+ if (r3) {
1504
+ throw takeObject(r2);
1505
+ }
1506
+ var v2 = getArrayU8FromWasm0(r0, r1).slice();
1507
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
1508
+ return v2;
1509
+ } finally {
1510
+ wasm.__wbindgen_add_to_stack_pointer(16);
1511
+ }
1512
+ }
1513
+ /**
1514
+ * Encode a failed payment request response for `NeedsPaymentRequest`.
1515
+ * @param {string} request_id
1516
+ * @param {string} reason
1517
+ * @returns {Uint8Array}
1518
+ */
1519
+ encodePaymentRequestError(request_id, reason) {
1520
+ try {
1521
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1522
+ const ptr0 = passStringToWasm0(request_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1523
+ const len0 = WASM_VECTOR_LEN;
1524
+ const ptr1 = passStringToWasm0(reason, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1525
+ const len1 = WASM_VECTOR_LEN;
1526
+ wasm.hostapihandle_encodePaymentRequestError(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
1527
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1528
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1529
+ var v3 = getArrayU8FromWasm0(r0, r1).slice();
1530
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
1531
+ return v3;
1532
+ } finally {
1533
+ wasm.__wbindgen_add_to_stack_pointer(16);
1534
+ }
1535
+ }
1536
+ /**
1537
+ * Encode a successful payment request response for `NeedsPaymentRequest`.
1538
+ *
1539
+ * `receipt_id` is the ID of the payment receipt returned by the host.
1540
+ * @param {string} request_id
1541
+ * @param {string} receipt_id
1542
+ * @returns {Uint8Array}
1543
+ */
1544
+ encodePaymentRequestResponse(request_id, receipt_id) {
1545
+ try {
1546
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1547
+ const ptr0 = passStringToWasm0(request_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1548
+ const len0 = WASM_VECTOR_LEN;
1549
+ const ptr1 = passStringToWasm0(receipt_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1550
+ const len1 = WASM_VECTOR_LEN;
1551
+ wasm.hostapihandle_encodePaymentRequestResponse(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
1552
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1553
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1554
+ var v3 = getArrayU8FromWasm0(r0, r1).slice();
1555
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
1556
+ return v3;
1557
+ } finally {
1558
+ wasm.__wbindgen_add_to_stack_pointer(16);
1559
+ }
1560
+ }
1561
+ /**
1562
+ * Encode a payment status update for `NeedsPaymentStatusSubscription`.
1563
+ *
1564
+ * `status` must be a JS object with shape:
1565
+ * `{ type: "Processing" | "Completed" | "Failed", reason?: string }`.
1566
+ * @param {string} request_id
1567
+ * @param {any} status
1568
+ * @returns {Uint8Array}
1569
+ */
1570
+ encodePaymentStatus(request_id, status) {
1571
+ try {
1572
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1573
+ const ptr0 = passStringToWasm0(request_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1574
+ const len0 = WASM_VECTOR_LEN;
1575
+ wasm.hostapihandle_encodePaymentStatus(retptr, this.__wbg_ptr, ptr0, len0, addHeapObject(status));
1576
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1577
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1578
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
1579
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
1580
+ if (r3) {
1581
+ throw takeObject(r2);
1582
+ }
1583
+ var v2 = getArrayU8FromWasm0(r0, r1).slice();
1584
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
1585
+ return v2;
1586
+ } finally {
1587
+ wasm.__wbindgen_add_to_stack_pointer(16);
1588
+ }
1589
+ }
1590
+ /**
1591
+ * Encode a failed payment top-up response for `NeedsPaymentTopUp`.
1592
+ * @param {string} request_id
1593
+ * @param {string} reason
1594
+ * @returns {Uint8Array}
1595
+ */
1596
+ encodePaymentTopUpError(request_id, reason) {
1597
+ try {
1598
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1599
+ const ptr0 = passStringToWasm0(request_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1600
+ const len0 = WASM_VECTOR_LEN;
1601
+ const ptr1 = passStringToWasm0(reason, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1602
+ const len1 = WASM_VECTOR_LEN;
1603
+ wasm.hostapihandle_encodePaymentTopUpError(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
1604
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1605
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1606
+ var v3 = getArrayU8FromWasm0(r0, r1).slice();
1607
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
1608
+ return v3;
1609
+ } finally {
1610
+ wasm.__wbindgen_add_to_stack_pointer(16);
1611
+ }
1612
+ }
1613
+ /**
1614
+ * Encode a successful payment top-up acknowledgement for `NeedsPaymentTopUp`.
1615
+ * @param {string} request_id
1616
+ * @returns {Uint8Array}
1617
+ */
1618
+ encodePaymentTopUpResponse(request_id) {
1619
+ try {
1620
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1621
+ const ptr0 = passStringToWasm0(request_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1622
+ const len0 = WASM_VECTOR_LEN;
1623
+ wasm.hostapihandle_encodePaymentTopUpResponse(retptr, this.__wbg_ptr, ptr0, len0);
1624
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1625
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1626
+ var v2 = getArrayU8FromWasm0(r0, r1).slice();
1627
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
1628
+ return v2;
1629
+ } finally {
1630
+ wasm.__wbindgen_add_to_stack_pointer(16);
1631
+ }
1632
+ }
1633
+ /**
1634
+ * Encode a push notification acknowledgement.
1635
+ * @param {string} request_id
1636
+ * @returns {Uint8Array}
1637
+ */
1638
+ encodePushNotificationResponse(request_id) {
1639
+ try {
1640
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1641
+ const ptr0 = passStringToWasm0(request_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1642
+ const len0 = WASM_VECTOR_LEN;
1643
+ wasm.hostapihandle_encodePushNotificationResponse(retptr, this.__wbg_ptr, ptr0, len0);
1644
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1645
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1646
+ var v2 = getArrayU8FromWasm0(r0, r1).slice();
1647
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
1648
+ return v2;
1649
+ } finally {
1650
+ wasm.__wbindgen_add_to_stack_pointer(16);
1651
+ }
1652
+ }
1653
+ /**
1654
+ * Encode a `remote_permission` error response.
1655
+ * @param {string} request_id
1656
+ * @returns {Uint8Array}
1657
+ */
1658
+ encodeRemotePermissionError(request_id) {
1659
+ try {
1660
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1661
+ const ptr0 = passStringToWasm0(request_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1662
+ const len0 = WASM_VECTOR_LEN;
1663
+ wasm.hostapihandle_encodeRemotePermissionError(retptr, this.__wbg_ptr, ptr0, len0);
1664
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1665
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1666
+ var v2 = getArrayU8FromWasm0(r0, r1).slice();
1667
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
1668
+ return v2;
1669
+ } finally {
1670
+ wasm.__wbindgen_add_to_stack_pointer(16);
1671
+ }
1672
+ }
1673
+ /**
1674
+ * Encode a `remote_permission` response.
1675
+ * @param {string} request_id
1676
+ * @param {boolean} granted
1677
+ * @returns {Uint8Array}
1678
+ */
1679
+ encodeRemotePermissionResponse(request_id, granted) {
1680
+ try {
1681
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1682
+ const ptr0 = passStringToWasm0(request_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1683
+ const len0 = WASM_VECTOR_LEN;
1684
+ wasm.hostapihandle_encodeRemotePermissionResponse(retptr, this.__wbg_ptr, ptr0, len0, granted);
1685
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1686
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1687
+ var v2 = getArrayU8FromWasm0(r0, r1).slice();
1688
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
1689
+ return v2;
1690
+ } finally {
1691
+ wasm.__wbindgen_add_to_stack_pointer(16);
1692
+ }
1693
+ }
1694
+ /**
1695
+ * Encode a sign_payload or sign_raw error response.
1696
+ * @param {string} request_id
1697
+ * @param {number} request_tag
1698
+ * @returns {Uint8Array}
1699
+ */
1700
+ encodeSignError(request_id, request_tag) {
1701
+ try {
1702
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1703
+ const ptr0 = passStringToWasm0(request_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1704
+ const len0 = WASM_VECTOR_LEN;
1705
+ wasm.hostapihandle_encodeSignError(retptr, this.__wbg_ptr, ptr0, len0, request_tag);
1706
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1707
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1708
+ var v2 = getArrayU8FromWasm0(r0, r1).slice();
1709
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
1710
+ return v2;
1711
+ } finally {
1712
+ wasm.__wbindgen_add_to_stack_pointer(16);
1713
+ }
1714
+ }
1715
+ /**
1716
+ * Encode a sign_payload or sign_raw success response.
1717
+ * @param {string} request_id
1718
+ * @param {number} request_tag
1719
+ * @param {Uint8Array} signature
1720
+ * @returns {Uint8Array}
1721
+ */
1722
+ encodeSignResponse(request_id, request_tag, signature) {
1723
+ try {
1724
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1725
+ const ptr0 = passStringToWasm0(request_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1726
+ const len0 = WASM_VECTOR_LEN;
1727
+ const ptr1 = passArray8ToWasm0(signature, wasm.__wbindgen_export);
1728
+ const len1 = WASM_VECTOR_LEN;
1729
+ wasm.hostapihandle_encodeSignResponse(retptr, this.__wbg_ptr, ptr0, len0, request_tag, ptr1, len1);
1730
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1731
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1732
+ var v3 = getArrayU8FromWasm0(r0, r1).slice();
1733
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
1734
+ return v3;
1735
+ } finally {
1736
+ wasm.__wbindgen_add_to_stack_pointer(16);
1737
+ }
1738
+ }
1739
+ /**
1740
+ * Encode a storage clear acknowledgement for `NeedsStorageClear`.
1741
+ * @param {string} request_id
1742
+ * @returns {Uint8Array}
1743
+ */
1744
+ encodeStorageClearResponse(request_id) {
1745
+ try {
1746
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1747
+ const ptr0 = passStringToWasm0(request_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1748
+ const len0 = WASM_VECTOR_LEN;
1749
+ wasm.hostapihandle_encodeStorageClearResponse(retptr, this.__wbg_ptr, ptr0, len0);
1750
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1751
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1752
+ var v2 = getArrayU8FromWasm0(r0, r1).slice();
1753
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
1754
+ return v2;
1755
+ } finally {
1756
+ wasm.__wbindgen_add_to_stack_pointer(16);
1757
+ }
1758
+ }
1759
+ /**
1760
+ * Encode a storage read response for `NeedsStorageRead`.
1761
+ *
1762
+ * Pass `None` if the key was not found; `Some(bytes)` with the stored value otherwise.
1763
+ * @param {string} request_id
1764
+ * @param {Uint8Array | null} [value]
1765
+ * @returns {Uint8Array}
1766
+ */
1767
+ encodeStorageReadResponse(request_id, value) {
1768
+ try {
1769
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1770
+ const ptr0 = passStringToWasm0(request_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1771
+ const len0 = WASM_VECTOR_LEN;
1772
+ var ptr1 = isLikeNone(value) ? 0 : passArray8ToWasm0(value, wasm.__wbindgen_export);
1773
+ var len1 = WASM_VECTOR_LEN;
1774
+ wasm.hostapihandle_encodeStorageReadResponse(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
1775
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1776
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1777
+ var v3 = getArrayU8FromWasm0(r0, r1).slice();
1778
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
1779
+ return v3;
1780
+ } finally {
1781
+ wasm.__wbindgen_add_to_stack_pointer(16);
1782
+ }
1783
+ }
1784
+ /**
1785
+ * Encode a storage write acknowledgement for `NeedsStorageWrite`.
1786
+ * @param {string} request_id
1787
+ * @returns {Uint8Array}
1788
+ */
1789
+ encodeStorageWriteResponse(request_id) {
1790
+ try {
1791
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1792
+ const ptr0 = passStringToWasm0(request_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1793
+ const len0 = WASM_VECTOR_LEN;
1794
+ wasm.hostapihandle_encodeStorageWriteResponse(retptr, this.__wbg_ptr, ptr0, len0);
1795
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1796
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1797
+ var v2 = getArrayU8FromWasm0(r0, r1).slice();
1798
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
1799
+ return v2;
1800
+ } finally {
1801
+ wasm.__wbindgen_add_to_stack_pointer(16);
1802
+ }
1803
+ }
1804
+ /**
1805
+ * Process a binary SCALE message from the app.
1806
+ *
1807
+ * Returns a JS object describing the outcome. The `type` field indicates
1808
+ * the variant:
1809
+ *
1810
+ * - `"Response"` — send `data` (byte array) back to the app
1811
+ * - `"NeedsSign"` — route to wallet for signing
1812
+ * - `"NeedsChainQuery"` — route to smoldot/polkadot-api
1813
+ * - `"NeedsChainSubscription"` — start a streaming subscription
1814
+ * - `"NeedsNavigate"` — open a URL
1815
+ * - `"NeedsPushNotification"` — display a push notification/toast
1816
+ * - `"NeedsChainFollow"` — start chainHead follow
1817
+ * - `"NeedsChainRpc"` — route to chain RPC
1818
+ * - `"Silent"` — no response needed
1819
+ * @param {Uint8Array} raw
1820
+ * @param {string} app_id
1821
+ * @returns {any}
1822
+ */
1823
+ handleMessage(raw, app_id) {
1824
+ try {
1825
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1826
+ const ptr0 = passArray8ToWasm0(raw, wasm.__wbindgen_export);
1827
+ const len0 = WASM_VECTOR_LEN;
1828
+ const ptr1 = passStringToWasm0(app_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1829
+ const len1 = WASM_VECTOR_LEN;
1830
+ wasm.hostapihandle_handleMessage(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
1831
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1832
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1833
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
1834
+ if (r2) {
1835
+ throw takeObject(r1);
1836
+ }
1837
+ return takeObject(r0);
1838
+ } finally {
1839
+ wasm.__wbindgen_add_to_stack_pointer(16);
1840
+ }
1841
+ }
1842
+ /**
1843
+ * Create a new host API engine.
1844
+ */
1845
+ constructor() {
1846
+ const ret = wasm.hostapihandle_new();
1847
+ this.__wbg_ptr = ret;
1848
+ HostApiHandleFinalization.register(this, this.__wbg_ptr, this);
1849
+ return this;
1850
+ }
1851
+ /**
1852
+ * Set accounts for host-api compatibility.
1853
+ *
1854
+ * `host_get_legacy_accounts` currently returns an empty list to avoid
1855
+ * exposing a stable cross-product identifier. This setter is retained so
1856
+ * existing hosts do not fail during initialization.
1857
+ *
1858
+ * Accepts a JSON array of `LegacyAccount` records:
1859
+ * `[{"public_key": [1,2,...], "name": "Alice"}, ...]`
1860
+ * @param {string} accounts_json
1861
+ */
1862
+ setAccounts(accounts_json) {
1863
+ try {
1864
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1865
+ const ptr0 = passStringToWasm0(accounts_json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1866
+ const len0 = WASM_VECTOR_LEN;
1867
+ wasm.hostapihandle_setAccounts(retptr, this.__wbg_ptr, ptr0, len0);
1868
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1869
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1870
+ if (r1) {
1871
+ throw takeObject(r0);
1872
+ }
1873
+ } finally {
1874
+ wasm.__wbindgen_add_to_stack_pointer(16);
1875
+ }
1876
+ }
1877
+ /**
1878
+ * Set the set of supported chain genesis hashes for feature detection.
1879
+ *
1880
+ * Expects a JS array of `Uint8Array` values, each exactly 32 bytes.
1881
+ * @param {Array<any>} chains
1882
+ */
1883
+ setSupportedChains(chains) {
1884
+ try {
1885
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1886
+ wasm.hostapihandle_setSupportedChains(retptr, this.__wbg_ptr, addHeapObject(chains));
1887
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1888
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1889
+ if (r1) {
1890
+ throw takeObject(r0);
1891
+ }
1892
+ } finally {
1893
+ wasm.__wbindgen_add_to_stack_pointer(16);
1894
+ }
1895
+ }
1896
+ }
1897
+ if (Symbol.dispose) HostApiHandle.prototype[Symbol.dispose] = HostApiHandle.prototype.free;
1898
+
1899
+ /**
1900
+ * JS-facing Resources pallet encoding utilities for People chains.
1901
+ *
1902
+ * All functions are pure — no I/O or network. The browser is responsible
1903
+ * for the actual `state_getStorage` RPC call using the smoldot driver it
1904
+ * already manages.
1905
+ */
1906
+ export class IdentityHandle {
1907
+ __destroy_into_raw() {
1908
+ const ptr = this.__wbg_ptr;
1909
+ this.__wbg_ptr = 0;
1910
+ IdentityHandleFinalization.unregister(this);
1911
+ return ptr;
1912
+ }
1913
+ free() {
1914
+ const ptr = this.__destroy_into_raw();
1915
+ wasm.__wbg_identityhandle_free(ptr, 0);
1916
+ }
1917
+ /**
1918
+ * Build the `state_getStorage` key hex for `Resources.Consumers`.
1919
+ *
1920
+ * `account_id_hex` must be a `0x`-prefixed or bare 64-character hex
1921
+ * string representing a 32-byte `AccountId32`.
1922
+ *
1923
+ * Returns the key as a `0x`-prefixed hex string, or throws on invalid
1924
+ * input.
1925
+ * @param {string} account_id_hex
1926
+ * @returns {string}
1927
+ */
1928
+ consumersKey(account_id_hex) {
1929
+ let deferred3_0;
1930
+ let deferred3_1;
1931
+ try {
1932
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1933
+ const ptr0 = passStringToWasm0(account_id_hex, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1934
+ const len0 = WASM_VECTOR_LEN;
1935
+ wasm.identityhandle_consumersKey(retptr, this.__wbg_ptr, ptr0, len0);
1936
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1937
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1938
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
1939
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
1940
+ var ptr2 = r0;
1941
+ var len2 = r1;
1942
+ if (r3) {
1943
+ ptr2 = 0; len2 = 0;
1944
+ throw takeObject(r2);
1945
+ }
1946
+ deferred3_0 = ptr2;
1947
+ deferred3_1 = len2;
1948
+ return getStringFromWasm0(ptr2, len2);
1949
+ } finally {
1950
+ wasm.__wbindgen_add_to_stack_pointer(16);
1951
+ wasm.__wbindgen_export5(deferred3_0, deferred3_1, 1);
1952
+ }
1953
+ }
1954
+ /**
1955
+ * Decode a `Resources.UsernameOwnerOf` storage response.
1956
+ *
1957
+ * `PaseoPeopleNext` stores a bare `AccountId32` here, so the browser path
1958
+ * must decode the raw owner bytes rather than `Identity::UsernameInfoOf`.
1959
+ * @param {Uint8Array} data
1960
+ * @returns {any}
1961
+ */
1962
+ decodeAccountOfUsername(data) {
1963
+ try {
1964
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1965
+ const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export);
1966
+ const len0 = WASM_VECTOR_LEN;
1967
+ wasm.identityhandle_decodeAccountOfUsername(retptr, this.__wbg_ptr, ptr0, len0);
1968
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1969
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1970
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
1971
+ if (r2) {
1972
+ throw takeObject(r1);
1973
+ }
1974
+ return takeObject(r0);
1975
+ } finally {
1976
+ wasm.__wbindgen_add_to_stack_pointer(16);
1977
+ }
1978
+ }
1979
+ /**
1980
+ * Decode a SCALE-encoded `ConsumerInfo` from `Resources.Consumers`.
1981
+ *
1982
+ * `data` is the raw bytes from the `state_getStorage` response (after
1983
+ * hex-decoding the `"result"` field).
1984
+ *
1985
+ * Returns a JS object `{ identifierKey: Uint8Array, fullUsername: string |
1986
+ * null, liteUsername: string, credibility: object }`, or `null` if data is
1987
+ * empty (storage slot absent). Throws on malformed SCALE data.
1988
+ *
1989
+ * `credibility` is one of:
1990
+ * - `{ type: "Lite" }`
1991
+ * - `{ type: "Person", alias: Uint8Array, lastUpdate: number }`
1992
+ * @param {Uint8Array} data
1993
+ * @returns {any}
1994
+ */
1995
+ decodeConsumerInfo(data) {
1996
+ try {
1997
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1998
+ const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export);
1999
+ const len0 = WASM_VECTOR_LEN;
2000
+ wasm.identityhandle_decodeConsumerInfo(retptr, this.__wbg_ptr, ptr0, len0);
2001
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
2002
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
2003
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
2004
+ if (r2) {
2005
+ throw takeObject(r1);
2006
+ }
2007
+ return takeObject(r0);
2008
+ } finally {
2009
+ wasm.__wbindgen_add_to_stack_pointer(16);
2010
+ }
2011
+ }
2012
+ /**
2013
+ * Construct a full PeopleLite username from base and suffix.
2014
+ * @param {string} base
2015
+ * @param {string} suffix
2016
+ * @returns {string}
2017
+ */
2018
+ makeLiteFullUsername(base, suffix) {
2019
+ let deferred4_0;
2020
+ let deferred4_1;
2021
+ try {
2022
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2023
+ const ptr0 = passStringToWasm0(base, wasm.__wbindgen_export, wasm.__wbindgen_export2);
2024
+ const len0 = WASM_VECTOR_LEN;
2025
+ const ptr1 = passStringToWasm0(suffix, wasm.__wbindgen_export, wasm.__wbindgen_export2);
2026
+ const len1 = WASM_VECTOR_LEN;
2027
+ wasm.identityhandle_makeLiteFullUsername(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
2028
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
2029
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
2030
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
2031
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
2032
+ var ptr3 = r0;
2033
+ var len3 = r1;
2034
+ if (r3) {
2035
+ ptr3 = 0; len3 = 0;
2036
+ throw takeObject(r2);
2037
+ }
2038
+ deferred4_0 = ptr3;
2039
+ deferred4_1 = len3;
2040
+ return getStringFromWasm0(ptr3, len3);
2041
+ } finally {
2042
+ wasm.__wbindgen_add_to_stack_pointer(16);
2043
+ wasm.__wbindgen_export5(deferred4_0, deferred4_1, 1);
2044
+ }
2045
+ }
2046
+ constructor() {
2047
+ const ret = wasm.identityhandle_new();
2048
+ this.__wbg_ptr = ret;
2049
+ IdentityHandleFinalization.register(this, this.__wbg_ptr, this);
2050
+ return this;
2051
+ }
2052
+ /**
2053
+ * Normalize a PeopleLite username base for signup.
2054
+ *
2055
+ * Validates: lowercase letters only, 6-27 characters.
2056
+ * @param {string} base
2057
+ * @returns {string}
2058
+ */
2059
+ normalizeLiteUsernameBase(base) {
2060
+ let deferred3_0;
2061
+ let deferred3_1;
2062
+ try {
2063
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2064
+ const ptr0 = passStringToWasm0(base, wasm.__wbindgen_export, wasm.__wbindgen_export2);
2065
+ const len0 = WASM_VECTOR_LEN;
2066
+ wasm.identityhandle_normalizeLiteUsernameBase(retptr, this.__wbg_ptr, ptr0, len0);
2067
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
2068
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
2069
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
2070
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
2071
+ var ptr2 = r0;
2072
+ var len2 = r1;
2073
+ if (r3) {
2074
+ ptr2 = 0; len2 = 0;
2075
+ throw takeObject(r2);
2076
+ }
2077
+ deferred3_0 = ptr2;
2078
+ deferred3_1 = len2;
2079
+ return getStringFromWasm0(ptr2, len2);
2080
+ } finally {
2081
+ wasm.__wbindgen_add_to_stack_pointer(16);
2082
+ wasm.__wbindgen_export5(deferred3_0, deferred3_1, 1);
2083
+ }
2084
+ }
2085
+ /**
2086
+ * Normalize a username: ASCII lowercase, validate charset (`[a-z0-9.]`)
2087
+ * and maximum length (32 bytes).
2088
+ *
2089
+ * Returns the normalized UTF-8 bytes, or throws if the username is
2090
+ * invalid.
2091
+ * @param {string} username
2092
+ * @returns {Uint8Array}
2093
+ */
2094
+ normalizeUsername(username) {
2095
+ try {
2096
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2097
+ const ptr0 = passStringToWasm0(username, wasm.__wbindgen_export, wasm.__wbindgen_export2);
2098
+ const len0 = WASM_VECTOR_LEN;
2099
+ wasm.identityhandle_normalizeUsername(retptr, this.__wbg_ptr, ptr0, len0);
2100
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
2101
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
2102
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
2103
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
2104
+ if (r3) {
2105
+ throw takeObject(r2);
2106
+ }
2107
+ var v2 = getArrayU8FromWasm0(r0, r1).slice();
2108
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
2109
+ return v2;
2110
+ } finally {
2111
+ wasm.__wbindgen_add_to_stack_pointer(16);
2112
+ }
2113
+ }
2114
+ /**
2115
+ * Build the `state_getStorage` key hex for `Resources.UsernameOwnerOf`.
2116
+ *
2117
+ * Browser hosts use this for PeopleLite username lookup on
2118
+ * `PaseoPeopleNext`, where username ownership lives under the `Resources`
2119
+ * pallet instead of `Identity::UsernameInfoOf`.
2120
+ * @param {string} username
2121
+ * @returns {string}
2122
+ */
2123
+ usernameOwnerOfKey(username) {
2124
+ let deferred3_0;
2125
+ let deferred3_1;
2126
+ try {
2127
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2128
+ const ptr0 = passStringToWasm0(username, wasm.__wbindgen_export, wasm.__wbindgen_export2);
2129
+ const len0 = WASM_VECTOR_LEN;
2130
+ wasm.identityhandle_usernameOwnerOfKey(retptr, this.__wbg_ptr, ptr0, len0);
2131
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
2132
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
2133
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
2134
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
2135
+ var ptr2 = r0;
2136
+ var len2 = r1;
2137
+ if (r3) {
2138
+ ptr2 = 0; len2 = 0;
2139
+ throw takeObject(r2);
2140
+ }
2141
+ deferred3_0 = ptr2;
2142
+ deferred3_1 = len2;
2143
+ return getStringFromWasm0(ptr2, len2);
2144
+ } finally {
2145
+ wasm.__wbindgen_add_to_stack_pointer(16);
2146
+ wasm.__wbindgen_export5(deferred3_0, deferred3_1, 1);
2147
+ }
2148
+ }
2149
+ /**
2150
+ * Validate a PeopleLite numeric suffix.
2151
+ * @param {string} suffix
2152
+ */
2153
+ validateLiteUsernameSuffix(suffix) {
2154
+ try {
2155
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2156
+ const ptr0 = passStringToWasm0(suffix, wasm.__wbindgen_export, wasm.__wbindgen_export2);
2157
+ const len0 = WASM_VECTOR_LEN;
2158
+ wasm.identityhandle_validateLiteUsernameSuffix(retptr, this.__wbg_ptr, ptr0, len0);
2159
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
2160
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
2161
+ if (r1) {
2162
+ throw takeObject(r0);
2163
+ }
2164
+ } finally {
2165
+ wasm.__wbindgen_add_to_stack_pointer(16);
2166
+ }
2167
+ }
2168
+ }
2169
+ if (Symbol.dispose) IdentityHandle.prototype[Symbol.dispose] = IdentityHandle.prototype.free;
2170
+
2171
+ /**
2172
+ * JS-facing handle for QR code URI encoding and parsing.
2173
+ *
2174
+ * Pure functions — no I/O, no state. Handles the `substrate:` URI format
2175
+ * used in QR codes for Substrate address transfer.
2176
+ */
2177
+ export class QrHandle {
2178
+ __destroy_into_raw() {
2179
+ const ptr = this.__wbg_ptr;
2180
+ this.__wbg_ptr = 0;
2181
+ QrHandleFinalization.unregister(this);
2182
+ return ptr;
2183
+ }
2184
+ free() {
2185
+ const ptr = this.__destroy_into_raw();
2186
+ wasm.__wbg_qrhandle_free(ptr, 0);
2187
+ }
2188
+ /**
2189
+ * Decode an SS58 address, returning the 32-byte public key.
2190
+ *
2191
+ * Validates the base58 encoding and blake2b checksum.
2192
+ * @param {string} address
2193
+ * @returns {Uint8Array}
2194
+ */
2195
+ decodeSs58Address(address) {
2196
+ try {
2197
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2198
+ const ptr0 = passStringToWasm0(address, wasm.__wbindgen_export, wasm.__wbindgen_export2);
2199
+ const len0 = WASM_VECTOR_LEN;
2200
+ wasm.qrhandle_decodeSs58Address(retptr, this.__wbg_ptr, ptr0, len0);
2201
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
2202
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
2203
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
2204
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
2205
+ if (r3) {
2206
+ throw takeObject(r2);
2207
+ }
2208
+ var v2 = getArrayU8FromWasm0(r0, r1).slice();
2209
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
2210
+ return v2;
2211
+ } finally {
2212
+ wasm.__wbindgen_add_to_stack_pointer(16);
2213
+ }
2214
+ }
2215
+ /**
2216
+ * Encode a Substrate address into a QR-friendly URI string.
2217
+ *
2218
+ * Format: `substrate:{address}[?genesis_hash={hex}&amount={planck}]`
2219
+ *
2220
+ * `genesis_hash` must be exactly 32 bytes (Uint8Array) if provided.
2221
+ * `amount` is a decimal string (supports u128 range).
2222
+ * @param {string} address
2223
+ * @param {Uint8Array | null} [genesis_hash]
2224
+ * @param {string | null} [amount]
2225
+ * @returns {string}
2226
+ */
2227
+ encodeSubstrateUri(address, genesis_hash, amount) {
2228
+ let deferred5_0;
2229
+ let deferred5_1;
2230
+ try {
2231
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2232
+ const ptr0 = passStringToWasm0(address, wasm.__wbindgen_export, wasm.__wbindgen_export2);
2233
+ const len0 = WASM_VECTOR_LEN;
2234
+ var ptr1 = isLikeNone(genesis_hash) ? 0 : passArray8ToWasm0(genesis_hash, wasm.__wbindgen_export);
2235
+ var len1 = WASM_VECTOR_LEN;
2236
+ var ptr2 = isLikeNone(amount) ? 0 : passStringToWasm0(amount, wasm.__wbindgen_export, wasm.__wbindgen_export2);
2237
+ var len2 = WASM_VECTOR_LEN;
2238
+ wasm.qrhandle_encodeSubstrateUri(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
2239
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
2240
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
2241
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
2242
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
2243
+ var ptr4 = r0;
2244
+ var len4 = r1;
2245
+ if (r3) {
2246
+ ptr4 = 0; len4 = 0;
2247
+ throw takeObject(r2);
2248
+ }
2249
+ deferred5_0 = ptr4;
2250
+ deferred5_1 = len4;
2251
+ return getStringFromWasm0(ptr4, len4);
2252
+ } finally {
2253
+ wasm.__wbindgen_add_to_stack_pointer(16);
2254
+ wasm.__wbindgen_export5(deferred5_0, deferred5_1, 1);
2255
+ }
2256
+ }
2257
+ constructor() {
2258
+ const ret = wasm.qrhandle_new();
2259
+ this.__wbg_ptr = ret;
2260
+ QrHandleFinalization.register(this, this.__wbg_ptr, this);
2261
+ return this;
2262
+ }
2263
+ /**
2264
+ * Parse a QR code string into structured content.
2265
+ *
2266
+ * Returns a JS object with:
2267
+ * - `contentType`: `"substrate_transfer"`, `"raw_address"`, `"deep_link"`, or `"unknown"`
2268
+ * - `address`: SS58 address (for `substrate_transfer` and `raw_address`)
2269
+ * - `genesisHash`: Uint8Array (for `substrate_transfer`, if present)
2270
+ * - `amount`: decimal string (for `substrate_transfer`, if present)
2271
+ * - `rawContent`: string (for `deep_link` and `unknown`)
2272
+ * @param {string} data
2273
+ * @returns {any}
2274
+ */
2275
+ parseSubstrateUri(data) {
2276
+ try {
2277
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2278
+ const ptr0 = passStringToWasm0(data, wasm.__wbindgen_export, wasm.__wbindgen_export2);
2279
+ const len0 = WASM_VECTOR_LEN;
2280
+ wasm.qrhandle_parseSubstrateUri(retptr, this.__wbg_ptr, ptr0, len0);
2281
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
2282
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
2283
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
2284
+ if (r2) {
2285
+ throw takeObject(r1);
2286
+ }
2287
+ return takeObject(r0);
2288
+ } finally {
2289
+ wasm.__wbindgen_add_to_stack_pointer(16);
2290
+ }
2291
+ }
2292
+ }
2293
+ if (Symbol.dispose) QrHandle.prototype[Symbol.dispose] = QrHandle.prototype.free;
2294
+
2295
+ /**
2296
+ * JS-facing statement store encoding utilities.
2297
+ *
2298
+ * All functions are pure — no I/O. The browser is responsible for transport.
2299
+ */
2300
+ export class StatementHandle {
2301
+ __destroy_into_raw() {
2302
+ const ptr = this.__wbg_ptr;
2303
+ this.__wbg_ptr = 0;
2304
+ StatementHandleFinalization.unregister(this);
2305
+ return ptr;
2306
+ }
2307
+ free() {
2308
+ const ptr = this.__destroy_into_raw();
2309
+ wasm.__wbg_statementhandle_free(ptr, 0);
2310
+ }
2311
+ /**
2312
+ * Assemble a complete encoded statement from a signing payload and signature.
2313
+ *
2314
+ * `signing_payload_with_header` must be the exact bytes from `buildSigningPayload`.
2315
+ * @param {Uint8Array} signing_payload_with_header
2316
+ * @param {Uint8Array} sr25519_pubkey
2317
+ * @param {Uint8Array} sr25519_signature
2318
+ * @returns {Uint8Array}
2319
+ */
2320
+ assembleStatement(signing_payload_with_header, sr25519_pubkey, sr25519_signature) {
2321
+ try {
2322
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2323
+ const ptr0 = passArray8ToWasm0(signing_payload_with_header, wasm.__wbindgen_export);
2324
+ const len0 = WASM_VECTOR_LEN;
2325
+ const ptr1 = passArray8ToWasm0(sr25519_pubkey, wasm.__wbindgen_export);
2326
+ const len1 = WASM_VECTOR_LEN;
2327
+ const ptr2 = passArray8ToWasm0(sr25519_signature, wasm.__wbindgen_export);
2328
+ const len2 = WASM_VECTOR_LEN;
2329
+ wasm.statementhandle_assembleStatement(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
2330
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
2331
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
2332
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
2333
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
2334
+ if (r3) {
2335
+ throw takeObject(r2);
2336
+ }
2337
+ var v4 = getArrayU8FromWasm0(r0, r1).slice();
2338
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
2339
+ return v4;
2340
+ } finally {
2341
+ wasm.__wbindgen_add_to_stack_pointer(16);
2342
+ }
2343
+ }
2344
+ /**
2345
+ * Compute a blake2b-256 hash of arbitrary bytes.
2346
+ * @param {Uint8Array} data
2347
+ * @returns {Uint8Array}
2348
+ */
2349
+ blake2b256(data) {
2350
+ try {
2351
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2352
+ const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export);
2353
+ const len0 = WASM_VECTOR_LEN;
2354
+ wasm.statementhandle_blake2b256(retptr, this.__wbg_ptr, ptr0, len0);
2355
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
2356
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
2357
+ var v2 = getArrayU8FromWasm0(r0, r1).slice();
2358
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
2359
+ return v2;
2360
+ } finally {
2361
+ wasm.__wbindgen_add_to_stack_pointer(16);
2362
+ }
2363
+ }
2364
+ /**
2365
+ * Build the signing payload for a statement.
2366
+ *
2367
+ * Returns the raw bytes that must be signed. Use `WalletHandle.sign()` to
2368
+ * sign the payload, then pass the result to `assembleStatement()`.
2369
+ * @param {number} now_secs
2370
+ * @param {Uint8Array | null | undefined} decryption_key
2371
+ * @param {Uint8Array | null | undefined} channel
2372
+ * @param {number} priority
2373
+ * @param {Uint8Array} topics_flat
2374
+ * @param {Uint8Array} data
2375
+ * @returns {Uint8Array}
2376
+ */
2377
+ buildSigningPayload(now_secs, decryption_key, channel, priority, topics_flat, data) {
2378
+ try {
2379
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2380
+ var ptr0 = isLikeNone(decryption_key) ? 0 : passArray8ToWasm0(decryption_key, wasm.__wbindgen_export);
2381
+ var len0 = WASM_VECTOR_LEN;
2382
+ var ptr1 = isLikeNone(channel) ? 0 : passArray8ToWasm0(channel, wasm.__wbindgen_export);
2383
+ var len1 = WASM_VECTOR_LEN;
2384
+ const ptr2 = passArray8ToWasm0(topics_flat, wasm.__wbindgen_export);
2385
+ const len2 = WASM_VECTOR_LEN;
2386
+ const ptr3 = passArray8ToWasm0(data, wasm.__wbindgen_export);
2387
+ const len3 = WASM_VECTOR_LEN;
2388
+ wasm.statementhandle_buildSigningPayload(retptr, this.__wbg_ptr, now_secs, ptr0, len0, ptr1, len1, priority, ptr2, len2, ptr3, len3);
2389
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
2390
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
2391
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
2392
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
2393
+ if (r3) {
2394
+ throw takeObject(r2);
2395
+ }
2396
+ var v5 = getArrayU8FromWasm0(r0, r1).slice();
2397
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
2398
+ return v5;
2399
+ } finally {
2400
+ wasm.__wbindgen_add_to_stack_pointer(16);
2401
+ }
2402
+ }
2403
+ /**
2404
+ * Build the signing payload for a specific statement-store dialect.
2405
+ * @param {string} dialect_name
2406
+ * @param {number} now_secs
2407
+ * @param {Uint8Array | null | undefined} decryption_key
2408
+ * @param {Uint8Array | null | undefined} channel
2409
+ * @param {number} priority
2410
+ * @param {Uint8Array} topics_flat
2411
+ * @param {Uint8Array} data
2412
+ * @returns {Uint8Array}
2413
+ */
2414
+ buildSigningPayloadWithDialect(dialect_name, now_secs, decryption_key, channel, priority, topics_flat, data) {
2415
+ try {
2416
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2417
+ const ptr0 = passStringToWasm0(dialect_name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
2418
+ const len0 = WASM_VECTOR_LEN;
2419
+ var ptr1 = isLikeNone(decryption_key) ? 0 : passArray8ToWasm0(decryption_key, wasm.__wbindgen_export);
2420
+ var len1 = WASM_VECTOR_LEN;
2421
+ var ptr2 = isLikeNone(channel) ? 0 : passArray8ToWasm0(channel, wasm.__wbindgen_export);
2422
+ var len2 = WASM_VECTOR_LEN;
2423
+ const ptr3 = passArray8ToWasm0(topics_flat, wasm.__wbindgen_export);
2424
+ const len3 = WASM_VECTOR_LEN;
2425
+ const ptr4 = passArray8ToWasm0(data, wasm.__wbindgen_export);
2426
+ const len4 = WASM_VECTOR_LEN;
2427
+ wasm.statementhandle_buildSigningPayloadWithDialect(retptr, this.__wbg_ptr, ptr0, len0, now_secs, ptr1, len1, ptr2, len2, priority, ptr3, len3, ptr4, len4);
2428
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
2429
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
2430
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
2431
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
2432
+ if (r3) {
2433
+ throw takeObject(r2);
2434
+ }
2435
+ var v6 = getArrayU8FromWasm0(r0, r1).slice();
2436
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
2437
+ return v6;
2438
+ } finally {
2439
+ wasm.__wbindgen_add_to_stack_pointer(16);
2440
+ }
2441
+ }
2442
+ /**
2443
+ * Decode a statement from binary encoding.
2444
+ * Returns a JSON string with the decoded fields.
2445
+ * @param {Uint8Array} encoded
2446
+ * @returns {any}
2447
+ */
2448
+ decodeStatement(encoded) {
2449
+ try {
2450
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2451
+ const ptr0 = passArray8ToWasm0(encoded, wasm.__wbindgen_export);
2452
+ const len0 = WASM_VECTOR_LEN;
2453
+ wasm.statementhandle_decodeStatement(retptr, this.__wbg_ptr, ptr0, len0);
2454
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
2455
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
2456
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
2457
+ if (r2) {
2458
+ throw takeObject(r1);
2459
+ }
2460
+ return takeObject(r0);
2461
+ } finally {
2462
+ wasm.__wbindgen_add_to_stack_pointer(16);
2463
+ }
2464
+ }
2465
+ /**
2466
+ * Decode a statement using a specific statement-store dialect.
2467
+ * @param {string} dialect_name
2468
+ * @param {Uint8Array} encoded
2469
+ * @returns {any}
2470
+ */
2471
+ decodeStatementWithDialect(dialect_name, encoded) {
2472
+ try {
2473
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2474
+ const ptr0 = passStringToWasm0(dialect_name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
2475
+ const len0 = WASM_VECTOR_LEN;
2476
+ const ptr1 = passArray8ToWasm0(encoded, wasm.__wbindgen_export);
2477
+ const len1 = WASM_VECTOR_LEN;
2478
+ wasm.statementhandle_decodeStatementWithDialect(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
2479
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
2480
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
2481
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
2482
+ if (r2) {
2483
+ throw takeObject(r1);
2484
+ }
2485
+ return takeObject(r0);
2486
+ } finally {
2487
+ wasm.__wbindgen_add_to_stack_pointer(16);
2488
+ }
2489
+ }
2490
+ /**
2491
+ * Encode a statement into the sp-statement-store binary format.
2492
+ *
2493
+ * Convenience method that combines `buildSigningPayload` + `assembleStatement`
2494
+ * for callers who already have a pre-computed signature.
2495
+ *
2496
+ * `now_secs` is the current Unix timestamp in seconds (use `Date.now() / 1000 | 0`).
2497
+ * `topics_flat` is a flat `Uint8Array` of concatenated 32-byte topics.
2498
+ * @param {number} now_secs
2499
+ * @param {Uint8Array | null | undefined} decryption_key
2500
+ * @param {Uint8Array | null | undefined} channel
2501
+ * @param {number} priority
2502
+ * @param {Uint8Array} topics_flat
2503
+ * @param {Uint8Array} data
2504
+ * @param {Uint8Array} sr25519_pubkey
2505
+ * @param {Uint8Array} sr25519_signature
2506
+ * @returns {Uint8Array}
2507
+ */
2508
+ encodeStatement(now_secs, decryption_key, channel, priority, topics_flat, data, sr25519_pubkey, sr25519_signature) {
2509
+ try {
2510
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2511
+ var ptr0 = isLikeNone(decryption_key) ? 0 : passArray8ToWasm0(decryption_key, wasm.__wbindgen_export);
2512
+ var len0 = WASM_VECTOR_LEN;
2513
+ var ptr1 = isLikeNone(channel) ? 0 : passArray8ToWasm0(channel, wasm.__wbindgen_export);
2514
+ var len1 = WASM_VECTOR_LEN;
2515
+ const ptr2 = passArray8ToWasm0(topics_flat, wasm.__wbindgen_export);
2516
+ const len2 = WASM_VECTOR_LEN;
2517
+ const ptr3 = passArray8ToWasm0(data, wasm.__wbindgen_export);
2518
+ const len3 = WASM_VECTOR_LEN;
2519
+ const ptr4 = passArray8ToWasm0(sr25519_pubkey, wasm.__wbindgen_export);
2520
+ const len4 = WASM_VECTOR_LEN;
2521
+ const ptr5 = passArray8ToWasm0(sr25519_signature, wasm.__wbindgen_export);
2522
+ const len5 = WASM_VECTOR_LEN;
2523
+ wasm.statementhandle_encodeStatement(retptr, this.__wbg_ptr, now_secs, ptr0, len0, ptr1, len1, priority, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5);
2524
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
2525
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
2526
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
2527
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
2528
+ if (r3) {
2529
+ throw takeObject(r2);
2530
+ }
2531
+ var v7 = getArrayU8FromWasm0(r0, r1).slice();
2532
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
2533
+ return v7;
2534
+ } finally {
2535
+ wasm.__wbindgen_add_to_stack_pointer(16);
2536
+ }
2537
+ }
2538
+ /**
2539
+ * Encode a statement using a specific statement-store dialect.
2540
+ * @param {string} dialect_name
2541
+ * @param {number} now_secs
2542
+ * @param {Uint8Array | null | undefined} decryption_key
2543
+ * @param {Uint8Array | null | undefined} channel
2544
+ * @param {number} priority
2545
+ * @param {Uint8Array} topics_flat
2546
+ * @param {Uint8Array} data
2547
+ * @param {Uint8Array} sr25519_pubkey
2548
+ * @param {Uint8Array} sr25519_signature
2549
+ * @returns {Uint8Array}
2550
+ */
2551
+ encodeStatementWithDialect(dialect_name, now_secs, decryption_key, channel, priority, topics_flat, data, sr25519_pubkey, sr25519_signature) {
2552
+ try {
2553
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2554
+ const ptr0 = passStringToWasm0(dialect_name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
2555
+ const len0 = WASM_VECTOR_LEN;
2556
+ var ptr1 = isLikeNone(decryption_key) ? 0 : passArray8ToWasm0(decryption_key, wasm.__wbindgen_export);
2557
+ var len1 = WASM_VECTOR_LEN;
2558
+ var ptr2 = isLikeNone(channel) ? 0 : passArray8ToWasm0(channel, wasm.__wbindgen_export);
2559
+ var len2 = WASM_VECTOR_LEN;
2560
+ const ptr3 = passArray8ToWasm0(topics_flat, wasm.__wbindgen_export);
2561
+ const len3 = WASM_VECTOR_LEN;
2562
+ const ptr4 = passArray8ToWasm0(data, wasm.__wbindgen_export);
2563
+ const len4 = WASM_VECTOR_LEN;
2564
+ const ptr5 = passArray8ToWasm0(sr25519_pubkey, wasm.__wbindgen_export);
2565
+ const len5 = WASM_VECTOR_LEN;
2566
+ const ptr6 = passArray8ToWasm0(sr25519_signature, wasm.__wbindgen_export);
2567
+ const len6 = WASM_VECTOR_LEN;
2568
+ wasm.statementhandle_encodeStatementWithDialect(retptr, this.__wbg_ptr, ptr0, len0, now_secs, ptr1, len1, ptr2, len2, priority, ptr3, len3, ptr4, len4, ptr5, len5, ptr6, len6);
2569
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
2570
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
2571
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
2572
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
2573
+ if (r3) {
2574
+ throw takeObject(r2);
2575
+ }
2576
+ var v8 = getArrayU8FromWasm0(r0, r1).slice();
2577
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
2578
+ return v8;
2579
+ } finally {
2580
+ wasm.__wbindgen_add_to_stack_pointer(16);
2581
+ }
2582
+ }
2583
+ /**
2584
+ * Hex-decode a `0x`-prefixed (or bare) hex string.
2585
+ * @param {string} s
2586
+ * @returns {Uint8Array}
2587
+ */
2588
+ hexDecode(s) {
2589
+ try {
2590
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2591
+ const ptr0 = passStringToWasm0(s, wasm.__wbindgen_export, wasm.__wbindgen_export2);
2592
+ const len0 = WASM_VECTOR_LEN;
2593
+ wasm.statementhandle_hexDecode(retptr, this.__wbg_ptr, ptr0, len0);
2594
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
2595
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
2596
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
2597
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
2598
+ if (r3) {
2599
+ throw takeObject(r2);
2600
+ }
2601
+ var v2 = getArrayU8FromWasm0(r0, r1).slice();
2602
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
2603
+ return v2;
2604
+ } finally {
2605
+ wasm.__wbindgen_add_to_stack_pointer(16);
2606
+ }
2607
+ }
2608
+ /**
2609
+ * Hex-encode bytes with `0x` prefix.
2610
+ * @param {Uint8Array} bytes
2611
+ * @returns {string}
2612
+ */
2613
+ hexEncode(bytes) {
2614
+ let deferred2_0;
2615
+ let deferred2_1;
2616
+ try {
2617
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2618
+ const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
2619
+ const len0 = WASM_VECTOR_LEN;
2620
+ wasm.statementhandle_hexEncode(retptr, this.__wbg_ptr, ptr0, len0);
2621
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
2622
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
2623
+ deferred2_0 = r0;
2624
+ deferred2_1 = r1;
2625
+ return getStringFromWasm0(r0, r1);
2626
+ } finally {
2627
+ wasm.__wbindgen_add_to_stack_pointer(16);
2628
+ wasm.__wbindgen_export5(deferred2_0, deferred2_1, 1);
2629
+ }
2630
+ }
2631
+ constructor() {
2632
+ const ret = wasm.statementhandle_new();
2633
+ this.__wbg_ptr = ret;
2634
+ StatementHandleFinalization.register(this, this.__wbg_ptr, this);
2635
+ return this;
2636
+ }
2637
+ /**
2638
+ * Hash a string into a 32-byte Topic (blake2b-256).
2639
+ * @param {string} s
2640
+ * @returns {Uint8Array}
2641
+ */
2642
+ stringToTopic(s) {
2643
+ try {
2644
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2645
+ const ptr0 = passStringToWasm0(s, wasm.__wbindgen_export, wasm.__wbindgen_export2);
2646
+ const len0 = WASM_VECTOR_LEN;
2647
+ wasm.statementhandle_stringToTopic(retptr, this.__wbg_ptr, ptr0, len0);
2648
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
2649
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
2650
+ var v2 = getArrayU8FromWasm0(r0, r1).slice();
2651
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
2652
+ return v2;
2653
+ } finally {
2654
+ wasm.__wbindgen_add_to_stack_pointer(16);
2655
+ }
2656
+ }
2657
+ }
2658
+ if (Symbol.dispose) StatementHandle.prototype[Symbol.dispose] = StatementHandle.prototype.free;
2659
+
2660
+ /**
2661
+ * JS-facing handle for the statement store subscription system.
2662
+ *
2663
+ * The JS host calls `pushStatement()` for each raw statement received
2664
+ * from the SmoldotDriver. The Rust side decodes, deduplicates, and
2665
+ * dispatches to registered handlers.
2666
+ *
2667
+ * # Example (TypeScript)
2668
+ * ```typescript
2669
+ * const store = new StatementStoreHandle();
2670
+ * store.addTopic("0xabc..."); // 32-byte topic hex
2671
+ * // In your smoldot notification handler:
2672
+ * store.pushStatement(rawBytes);
2673
+ * // When done:
2674
+ * store.stop();
2675
+ * ```
2676
+ */
2677
+ export class StatementStoreHandle {
2678
+ __destroy_into_raw() {
2679
+ const ptr = this.__wbg_ptr;
2680
+ this.__wbg_ptr = 0;
2681
+ StatementStoreHandleFinalization.unregister(this);
2682
+ return ptr;
2683
+ }
2684
+ free() {
2685
+ const ptr = this.__destroy_into_raw();
2686
+ wasm.__wbg_statementstorehandle_free(ptr, 0);
2687
+ }
2688
+ /**
2689
+ * Add a topic to the subscription filter (hex-encoded 32 bytes).
2690
+ *
2691
+ * Accepts both `0x`-prefixed and bare hex strings.
2692
+ * @param {string} topic_hex
2693
+ */
2694
+ addTopic(topic_hex) {
2695
+ try {
2696
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2697
+ const ptr0 = passStringToWasm0(topic_hex, wasm.__wbindgen_export, wasm.__wbindgen_export2);
2698
+ const len0 = WASM_VECTOR_LEN;
2699
+ wasm.statementstorehandle_addTopic(retptr, this.__wbg_ptr, ptr0, len0);
2700
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
2701
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
2702
+ if (r1) {
2703
+ throw takeObject(r0);
2704
+ }
2705
+ } finally {
2706
+ wasm.__wbindgen_add_to_stack_pointer(16);
2707
+ }
2708
+ }
2709
+ /**
2710
+ * Whether the subscription is accepting statement deliveries.
2711
+ * @returns {boolean}
2712
+ */
2713
+ isRunning() {
2714
+ const ret = wasm.statementstorehandle_isRunning(this.__wbg_ptr);
2715
+ return ret !== 0;
2716
+ }
2717
+ /**
2718
+ * Create a new statement store handle and start push-based delivery.
2719
+ */
2720
+ constructor() {
2721
+ const ret = wasm.statementstorehandle_new();
2722
+ this.__wbg_ptr = ret;
2723
+ StatementStoreHandleFinalization.register(this, this.__wbg_ptr, this);
2724
+ return this;
2725
+ }
2726
+ /**
2727
+ * Push a raw statement from the JS transport layer.
2728
+ *
2729
+ * The statement is decoded, deduplicated, and dispatched to registered
2730
+ * handlers. Malformed bytes are logged and silently dropped.
2731
+ * @param {Uint8Array} raw
2732
+ */
2733
+ pushStatement(raw) {
2734
+ const ptr0 = passArray8ToWasm0(raw, wasm.__wbindgen_export);
2735
+ const len0 = WASM_VECTOR_LEN;
2736
+ wasm.statementstorehandle_pushStatement(this.__wbg_ptr, ptr0, len0);
2737
+ }
2738
+ /**
2739
+ * Remove a topic from the subscription filter.
2740
+ *
2741
+ * Accepts both `0x`-prefixed and bare hex strings.
2742
+ * @param {string} topic_hex
2743
+ */
2744
+ removeTopic(topic_hex) {
2745
+ try {
2746
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2747
+ const ptr0 = passStringToWasm0(topic_hex, wasm.__wbindgen_export, wasm.__wbindgen_export2);
2748
+ const len0 = WASM_VECTOR_LEN;
2749
+ wasm.statementstorehandle_removeTopic(retptr, this.__wbg_ptr, ptr0, len0);
2750
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
2751
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
2752
+ if (r1) {
2753
+ throw takeObject(r0);
2754
+ }
2755
+ } finally {
2756
+ wasm.__wbindgen_add_to_stack_pointer(16);
2757
+ }
2758
+ }
2759
+ /**
2760
+ * Stop the subscription and prevent further delivery. Idempotent.
2761
+ */
2762
+ stop() {
2763
+ wasm.statementstorehandle_stop(this.__wbg_ptr);
2764
+ }
2765
+ }
2766
+ if (Symbol.dispose) StatementStoreHandle.prototype[Symbol.dispose] = StatementStoreHandle.prototype.free;
2767
+
2768
+ /**
2769
+ * JS-facing wrapper over `useragent_wallet::WalletManager`.
2770
+ *
2771
+ * Manages sr25519/secp256k1 key material in WASM memory. The platform
2772
+ * keystore is not available — use `load_mnemonic()` to supply the phrase
2773
+ * and `lock()` to clear keys from memory.
2774
+ */
2775
+ export class WalletHandle {
2776
+ __destroy_into_raw() {
2777
+ const ptr = this.__wbg_ptr;
2778
+ this.__wbg_ptr = 0;
2779
+ WalletHandleFinalization.unregister(this);
2780
+ return ptr;
2781
+ }
2782
+ free() {
2783
+ const ptr = this.__destroy_into_raw();
2784
+ wasm.__wbg_wallethandle_free(ptr, 0);
2785
+ }
2786
+ /**
2787
+ * SS58 address for a derived app account (Polkadot prefix 0).
2788
+ * @param {string} app_id
2789
+ * @param {number} index
2790
+ * @returns {string}
2791
+ */
2792
+ appAddress(app_id, index) {
2793
+ let deferred3_0;
2794
+ let deferred3_1;
2795
+ try {
2796
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2797
+ const ptr0 = passStringToWasm0(app_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
2798
+ const len0 = WASM_VECTOR_LEN;
2799
+ wasm.wallethandle_appAddress(retptr, this.__wbg_ptr, ptr0, len0, index);
2800
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
2801
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
2802
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
2803
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
2804
+ var ptr2 = r0;
2805
+ var len2 = r1;
2806
+ if (r3) {
2807
+ ptr2 = 0; len2 = 0;
2808
+ throw takeObject(r2);
2809
+ }
2810
+ deferred3_0 = ptr2;
2811
+ deferred3_1 = len2;
2812
+ return getStringFromWasm0(ptr2, len2);
2813
+ } finally {
2814
+ wasm.__wbindgen_add_to_stack_pointer(16);
2815
+ wasm.__wbindgen_export5(deferred3_0, deferred3_1, 1);
2816
+ }
2817
+ }
2818
+ /**
2819
+ * 32-byte sr25519 public key for a derived app account.
2820
+ * @param {string} app_id
2821
+ * @param {number} index
2822
+ * @returns {Uint8Array}
2823
+ */
2824
+ appPublicKey(app_id, index) {
2825
+ try {
2826
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2827
+ const ptr0 = passStringToWasm0(app_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
2828
+ const len0 = WASM_VECTOR_LEN;
2829
+ wasm.wallethandle_appPublicKey(retptr, this.__wbg_ptr, ptr0, len0, index);
2830
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
2831
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
2832
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
2833
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
2834
+ if (r3) {
2835
+ throw takeObject(r2);
2836
+ }
2837
+ var v2 = getArrayU8FromWasm0(r0, r1).slice();
2838
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
2839
+ return v2;
2840
+ } finally {
2841
+ wasm.__wbindgen_add_to_stack_pointer(16);
2842
+ }
2843
+ }
2844
+ /**
2845
+ * P2WPKH (bech32) Bitcoin mainnet address.
2846
+ * @returns {string}
2847
+ */
2848
+ btcAddress() {
2849
+ let deferred2_0;
2850
+ let deferred2_1;
2851
+ try {
2852
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2853
+ wasm.wallethandle_btcAddress(retptr, this.__wbg_ptr);
2854
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
2855
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
2856
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
2857
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
2858
+ var ptr1 = r0;
2859
+ var len1 = r1;
2860
+ if (r3) {
2861
+ ptr1 = 0; len1 = 0;
2862
+ throw takeObject(r2);
2863
+ }
2864
+ deferred2_0 = ptr1;
2865
+ deferred2_1 = len1;
2866
+ return getStringFromWasm0(ptr1, len1);
2867
+ } finally {
2868
+ wasm.__wbindgen_add_to_stack_pointer(16);
2869
+ wasm.__wbindgen_export5(deferred2_0, deferred2_1, 1);
2870
+ }
2871
+ }
2872
+ /**
2873
+ * BIP-137 message signing with BTC key. Returns Base64 string.
2874
+ * @param {Uint8Array} msg
2875
+ * @returns {string}
2876
+ */
2877
+ btcSignMessage(msg) {
2878
+ let deferred3_0;
2879
+ let deferred3_1;
2880
+ try {
2881
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2882
+ const ptr0 = passArray8ToWasm0(msg, wasm.__wbindgen_export);
2883
+ const len0 = WASM_VECTOR_LEN;
2884
+ wasm.wallethandle_btcSignMessage(retptr, this.__wbg_ptr, ptr0, len0);
2885
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
2886
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
2887
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
2888
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
2889
+ var ptr2 = r0;
2890
+ var len2 = r1;
2891
+ if (r3) {
2892
+ ptr2 = 0; len2 = 0;
2893
+ throw takeObject(r2);
2894
+ }
2895
+ deferred3_0 = ptr2;
2896
+ deferred3_1 = len2;
2897
+ return getStringFromWasm0(ptr2, len2);
2898
+ } finally {
2899
+ wasm.__wbindgen_add_to_stack_pointer(16);
2900
+ wasm.__wbindgen_export5(deferred3_0, deferred3_1, 1);
2901
+ }
2902
+ }
2903
+ /**
2904
+ * Sign a raw 32-byte digest with BTC key. Returns DER-encoded signature.
2905
+ * @param {Uint8Array} digest
2906
+ * @returns {Uint8Array}
2907
+ */
2908
+ btcSignRaw(digest) {
2909
+ try {
2910
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2911
+ const ptr0 = passArray8ToWasm0(digest, wasm.__wbindgen_export);
2912
+ const len0 = WASM_VECTOR_LEN;
2913
+ wasm.wallethandle_btcSignRaw(retptr, this.__wbg_ptr, ptr0, len0);
2914
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
2915
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
2916
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
2917
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
2918
+ if (r3) {
2919
+ throw takeObject(r2);
2920
+ }
2921
+ var v2 = getArrayU8FromWasm0(r0, r1).slice();
2922
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
2923
+ return v2;
2924
+ } finally {
2925
+ wasm.__wbindgen_add_to_stack_pointer(16);
2926
+ }
2927
+ }
2928
+ /**
2929
+ * Decrypt data produced by `chatP256Encrypt`.
2930
+ * @param {Uint8Array} peer_identifier_key
2931
+ * @param {Uint8Array} ciphertext
2932
+ * @returns {Uint8Array}
2933
+ */
2934
+ chatP256Decrypt(peer_identifier_key, ciphertext) {
2935
+ try {
2936
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2937
+ const ptr0 = passArray8ToWasm0(peer_identifier_key, wasm.__wbindgen_export);
2938
+ const len0 = WASM_VECTOR_LEN;
2939
+ const ptr1 = passArray8ToWasm0(ciphertext, wasm.__wbindgen_export);
2940
+ const len1 = WASM_VECTOR_LEN;
2941
+ wasm.wallethandle_chatP256Decrypt(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
2942
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
2943
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
2944
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
2945
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
2946
+ if (r3) {
2947
+ throw takeObject(r2);
2948
+ }
2949
+ var v3 = getArrayU8FromWasm0(r0, r1).slice();
2950
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
2951
+ return v3;
2952
+ } finally {
2953
+ wasm.__wbindgen_add_to_stack_pointer(16);
2954
+ }
2955
+ }
2956
+ /**
2957
+ * Encrypt with the v2 P-256/AES-GCM stack.
2958
+ *
2959
+ * Output is `nonce(12) || ciphertext || tag(16)`, matching CryptoKit's
2960
+ * combined AES-GCM sealed box representation.
2961
+ * @param {Uint8Array} peer_identifier_key
2962
+ * @param {Uint8Array} plaintext
2963
+ * @returns {Uint8Array}
2964
+ */
2965
+ chatP256Encrypt(peer_identifier_key, plaintext) {
2966
+ try {
2967
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2968
+ const ptr0 = passArray8ToWasm0(peer_identifier_key, wasm.__wbindgen_export);
2969
+ const len0 = WASM_VECTOR_LEN;
2970
+ const ptr1 = passArray8ToWasm0(plaintext, wasm.__wbindgen_export);
2971
+ const len1 = WASM_VECTOR_LEN;
2972
+ wasm.wallethandle_chatP256Encrypt(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
2973
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
2974
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
2975
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
2976
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
2977
+ if (r3) {
2978
+ throw takeObject(r2);
2979
+ }
2980
+ var v3 = getArrayU8FromWasm0(r0, r1).slice();
2981
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
2982
+ return v3;
2983
+ } finally {
2984
+ wasm.__wbindgen_add_to_stack_pointer(16);
2985
+ }
2986
+ }
2987
+ /**
2988
+ * Build v2-compatible directional P-256 session ids and channels.
2989
+ *
2990
+ * Returns a JS object with the same fields as native
2991
+ * `MobileChatP256Session`, using `Uint8Array` for byte fields.
2992
+ * @param {Uint8Array} peer_account_id
2993
+ * @param {Uint8Array} peer_identifier_key
2994
+ * @param {string | null} [own_pin]
2995
+ * @param {string | null} [peer_pin]
2996
+ * @returns {any}
2997
+ */
2998
+ chatP256Session(peer_account_id, peer_identifier_key, own_pin, peer_pin) {
2999
+ try {
3000
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
3001
+ const ptr0 = passArray8ToWasm0(peer_account_id, wasm.__wbindgen_export);
3002
+ const len0 = WASM_VECTOR_LEN;
3003
+ const ptr1 = passArray8ToWasm0(peer_identifier_key, wasm.__wbindgen_export);
3004
+ const len1 = WASM_VECTOR_LEN;
3005
+ var ptr2 = isLikeNone(own_pin) ? 0 : passStringToWasm0(own_pin, wasm.__wbindgen_export, wasm.__wbindgen_export2);
3006
+ var len2 = WASM_VECTOR_LEN;
3007
+ var ptr3 = isLikeNone(peer_pin) ? 0 : passStringToWasm0(peer_pin, wasm.__wbindgen_export, wasm.__wbindgen_export2);
3008
+ var len3 = WASM_VECTOR_LEN;
3009
+ wasm.wallethandle_chatP256Session(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
3010
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
3011
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
3012
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
3013
+ if (r2) {
3014
+ throw takeObject(r1);
3015
+ }
3016
+ return takeObject(r0);
3017
+ } finally {
3018
+ wasm.__wbindgen_add_to_stack_pointer(16);
3019
+ }
3020
+ }
3021
+ /**
3022
+ * Decode and verify a first-contact chat request using the canonical host-sdk wire format.
3023
+ * @param {Uint8Array} data
3024
+ * @returns {any}
3025
+ */
3026
+ decodeChatRequest(data) {
3027
+ try {
3028
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
3029
+ const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export);
3030
+ const len0 = WASM_VECTOR_LEN;
3031
+ wasm.wallethandle_decodeChatRequest(retptr, this.__wbg_ptr, ptr0, len0);
3032
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
3033
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
3034
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
3035
+ if (r2) {
3036
+ throw takeObject(r1);
3037
+ }
3038
+ return takeObject(r0);
3039
+ } finally {
3040
+ wasm.__wbindgen_add_to_stack_pointer(16);
3041
+ }
3042
+ }
3043
+ /**
3044
+ * 32-byte Ed25519 public key at `//ed25519//<app_id>//<index>`.
3045
+ * @param {string} app_id
3046
+ * @param {number} index
3047
+ * @returns {Uint8Array}
3048
+ */
3049
+ ed25519PublicKey(app_id, index) {
3050
+ try {
3051
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
3052
+ const ptr0 = passStringToWasm0(app_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
3053
+ const len0 = WASM_VECTOR_LEN;
3054
+ wasm.wallethandle_ed25519PublicKey(retptr, this.__wbg_ptr, ptr0, len0, index);
3055
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
3056
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
3057
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
3058
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
3059
+ if (r3) {
3060
+ throw takeObject(r2);
3061
+ }
3062
+ var v2 = getArrayU8FromWasm0(r0, r1).slice();
3063
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
3064
+ return v2;
3065
+ } finally {
3066
+ wasm.__wbindgen_add_to_stack_pointer(16);
3067
+ }
3068
+ }
3069
+ /**
3070
+ * Encode a chat-accept request using the canonical host-sdk wire format.
3071
+ * @param {string} request_id
3072
+ * @param {string} text
3073
+ * @param {number} timestamp
3074
+ * @param {Uint8Array | null} [recipient_identifier_key]
3075
+ * @returns {Uint8Array}
3076
+ */
3077
+ encodeChatAccept(request_id, text, timestamp, recipient_identifier_key) {
3078
+ try {
3079
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
3080
+ const ptr0 = passStringToWasm0(request_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
3081
+ const len0 = WASM_VECTOR_LEN;
3082
+ const ptr1 = passStringToWasm0(text, wasm.__wbindgen_export, wasm.__wbindgen_export2);
3083
+ const len1 = WASM_VECTOR_LEN;
3084
+ var ptr2 = isLikeNone(recipient_identifier_key) ? 0 : passArray8ToWasm0(recipient_identifier_key, wasm.__wbindgen_export);
3085
+ var len2 = WASM_VECTOR_LEN;
3086
+ wasm.wallethandle_encodeChatAccept(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, timestamp, ptr2, len2);
3087
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
3088
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
3089
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
3090
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
3091
+ if (r3) {
3092
+ throw takeObject(r2);
3093
+ }
3094
+ var v4 = getArrayU8FromWasm0(r0, r1).slice();
3095
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
3096
+ return v4;
3097
+ } finally {
3098
+ wasm.__wbindgen_add_to_stack_pointer(16);
3099
+ }
3100
+ }
3101
+ /**
3102
+ * Encode a first-contact chat request using the canonical host-sdk wire format.
3103
+ * @param {string} text
3104
+ * @param {number} timestamp
3105
+ * @param {Uint8Array | null} [recipient_identifier_key]
3106
+ * @returns {Uint8Array}
3107
+ */
3108
+ encodeChatRequest(text, timestamp, recipient_identifier_key) {
3109
+ try {
3110
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
3111
+ const ptr0 = passStringToWasm0(text, wasm.__wbindgen_export, wasm.__wbindgen_export2);
3112
+ const len0 = WASM_VECTOR_LEN;
3113
+ var ptr1 = isLikeNone(recipient_identifier_key) ? 0 : passArray8ToWasm0(recipient_identifier_key, wasm.__wbindgen_export);
3114
+ var len1 = WASM_VECTOR_LEN;
3115
+ wasm.wallethandle_encodeChatRequest(retptr, this.__wbg_ptr, ptr0, len0, timestamp, ptr1, len1);
3116
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
3117
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
3118
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
3119
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
3120
+ if (r3) {
3121
+ throw takeObject(r2);
3122
+ }
3123
+ var v3 = getArrayU8FromWasm0(r0, r1).slice();
3124
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
3125
+ return v3;
3126
+ } finally {
3127
+ wasm.__wbindgen_add_to_stack_pointer(16);
3128
+ }
3129
+ }
3130
+ /**
3131
+ * EIP-55 checksummed Ethereum address.
3132
+ * @returns {string}
3133
+ */
3134
+ ethAddress() {
3135
+ let deferred2_0;
3136
+ let deferred2_1;
3137
+ try {
3138
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
3139
+ wasm.wallethandle_ethAddress(retptr, this.__wbg_ptr);
3140
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
3141
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
3142
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
3143
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
3144
+ var ptr1 = r0;
3145
+ var len1 = r1;
3146
+ if (r3) {
3147
+ ptr1 = 0; len1 = 0;
3148
+ throw takeObject(r2);
3149
+ }
3150
+ deferred2_0 = ptr1;
3151
+ deferred2_1 = len1;
3152
+ return getStringFromWasm0(ptr1, len1);
3153
+ } finally {
3154
+ wasm.__wbindgen_add_to_stack_pointer(16);
3155
+ wasm.__wbindgen_export5(deferred2_0, deferred2_1, 1);
3156
+ }
3157
+ }
3158
+ /**
3159
+ * EIP-191 personal_sign with ETH key. Returns 65-byte signature (r+s+v).
3160
+ * @param {Uint8Array} data
3161
+ * @returns {Uint8Array}
3162
+ */
3163
+ ethSignPersonal(data) {
3164
+ try {
3165
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
3166
+ const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_export);
3167
+ const len0 = WASM_VECTOR_LEN;
3168
+ wasm.wallethandle_ethSignPersonal(retptr, this.__wbg_ptr, ptr0, len0);
3169
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
3170
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
3171
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
3172
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
3173
+ if (r3) {
3174
+ throw takeObject(r2);
3175
+ }
3176
+ var v2 = getArrayU8FromWasm0(r0, r1).slice();
3177
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
3178
+ return v2;
3179
+ } finally {
3180
+ wasm.__wbindgen_add_to_stack_pointer(16);
3181
+ }
3182
+ }
3183
+ /**
3184
+ * Canonical 65-byte uncompressed P-256 identifier key at `//wallet//chat`.
3185
+ * @returns {Uint8Array}
3186
+ */
3187
+ identifierKey() {
3188
+ try {
3189
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
3190
+ wasm.wallethandle_identifierKey(retptr, this.__wbg_ptr);
3191
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
3192
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
3193
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
3194
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
3195
+ if (r3) {
3196
+ throw takeObject(r2);
3197
+ }
3198
+ var v1 = getArrayU8FromWasm0(r0, r1).slice();
3199
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
3200
+ return v1;
3201
+ } finally {
3202
+ wasm.__wbindgen_add_to_stack_pointer(16);
3203
+ }
3204
+ }
3205
+ /**
3206
+ * Load key material from a BIP-39 mnemonic phrase.
3207
+ *
3208
+ * The wallet is unlocked immediately. The mnemonic is NOT persisted —
3209
+ * the browser host must store it externally (e.g. encrypted localStorage).
3210
+ * @param {string} phrase
3211
+ */
3212
+ loadMnemonic(phrase) {
3213
+ try {
3214
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
3215
+ const ptr0 = passStringToWasm0(phrase, wasm.__wbindgen_export, wasm.__wbindgen_export2);
3216
+ const len0 = WASM_VECTOR_LEN;
3217
+ wasm.wallethandle_loadMnemonic(retptr, this.__wbg_ptr, ptr0, len0);
3218
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
3219
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
3220
+ if (r1) {
3221
+ throw takeObject(r0);
3222
+ }
3223
+ } finally {
3224
+ wasm.__wbindgen_add_to_stack_pointer(16);
3225
+ }
3226
+ }
3227
+ /**
3228
+ * Lock the wallet — clear all in-memory key material.
3229
+ */
3230
+ lock() {
3231
+ wasm.wallethandle_lock(this.__wbg_ptr);
3232
+ }
3233
+ /**
3234
+ * Create a new (locked, empty) wallet handle.
3235
+ */
3236
+ constructor() {
3237
+ const ret = wasm.wallethandle_new();
3238
+ this.__wbg_ptr = ret;
3239
+ WalletHandleFinalization.register(this, this.__wbg_ptr, this);
3240
+ return this;
3241
+ }
3242
+ /**
3243
+ * Root SS58 address (Polkadot format, prefix 0).
3244
+ * @returns {string}
3245
+ */
3246
+ rootAddress() {
3247
+ let deferred2_0;
3248
+ let deferred2_1;
3249
+ try {
3250
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
3251
+ wasm.wallethandle_rootAddress(retptr, this.__wbg_ptr);
3252
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
3253
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
3254
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
3255
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
3256
+ var ptr1 = r0;
3257
+ var len1 = r1;
3258
+ if (r3) {
3259
+ ptr1 = 0; len1 = 0;
3260
+ throw takeObject(r2);
3261
+ }
3262
+ deferred2_0 = ptr1;
3263
+ deferred2_1 = len1;
3264
+ return getStringFromWasm0(ptr1, len1);
3265
+ } finally {
3266
+ wasm.__wbindgen_add_to_stack_pointer(16);
3267
+ wasm.__wbindgen_export5(deferred2_0, deferred2_1, 1);
3268
+ }
3269
+ }
3270
+ /**
3271
+ * Root 32-byte sr25519 public key.
3272
+ * @returns {Uint8Array | undefined}
3273
+ */
3274
+ rootPublicKey() {
3275
+ try {
3276
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
3277
+ wasm.wallethandle_rootPublicKey(retptr, this.__wbg_ptr);
3278
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
3279
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
3280
+ let v1;
3281
+ if (r0 !== 0) {
3282
+ v1 = getArrayU8FromWasm0(r0, r1).slice();
3283
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
3284
+ }
3285
+ return v1;
3286
+ } finally {
3287
+ wasm.__wbindgen_add_to_stack_pointer(16);
3288
+ }
3289
+ }
3290
+ /**
3291
+ * Sign with app-scoped sr25519 keypair. Returns 64-byte signature.
3292
+ * @param {string} app_id
3293
+ * @param {number} index
3294
+ * @param {Uint8Array} payload
3295
+ * @returns {Uint8Array}
3296
+ */
3297
+ sign(app_id, index, payload) {
3298
+ try {
3299
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
3300
+ const ptr0 = passStringToWasm0(app_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
3301
+ const len0 = WASM_VECTOR_LEN;
3302
+ const ptr1 = passArray8ToWasm0(payload, wasm.__wbindgen_export);
3303
+ const len1 = WASM_VECTOR_LEN;
3304
+ wasm.wallethandle_sign(retptr, this.__wbg_ptr, ptr0, len0, index, ptr1, len1);
3305
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
3306
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
3307
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
3308
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
3309
+ if (r3) {
3310
+ throw takeObject(r2);
3311
+ }
3312
+ var v3 = getArrayU8FromWasm0(r0, r1).slice();
3313
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
3314
+ return v3;
3315
+ } finally {
3316
+ wasm.__wbindgen_add_to_stack_pointer(16);
3317
+ }
3318
+ }
3319
+ /**
3320
+ * Sign with Ed25519 key at `//ed25519//<app_id>//<index>`. Returns 64-byte signature.
3321
+ * @param {string} app_id
3322
+ * @param {number} index
3323
+ * @param {Uint8Array} payload
3324
+ * @returns {Uint8Array}
3325
+ */
3326
+ signEd25519(app_id, index, payload) {
3327
+ try {
3328
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
3329
+ const ptr0 = passStringToWasm0(app_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
3330
+ const len0 = WASM_VECTOR_LEN;
3331
+ const ptr1 = passArray8ToWasm0(payload, wasm.__wbindgen_export);
3332
+ const len1 = WASM_VECTOR_LEN;
3333
+ wasm.wallethandle_signEd25519(retptr, this.__wbg_ptr, ptr0, len0, index, ptr1, len1);
3334
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
3335
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
3336
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
3337
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
3338
+ if (r3) {
3339
+ throw takeObject(r2);
3340
+ }
3341
+ var v3 = getArrayU8FromWasm0(r0, r1).slice();
3342
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
3343
+ return v3;
3344
+ } finally {
3345
+ wasm.__wbindgen_add_to_stack_pointer(16);
3346
+ }
3347
+ }
3348
+ /**
3349
+ * Sign with root sr25519 keypair. Returns 64-byte signature.
3350
+ * @param {Uint8Array} payload
3351
+ * @returns {Uint8Array}
3352
+ */
3353
+ signRoot(payload) {
3354
+ try {
3355
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
3356
+ const ptr0 = passArray8ToWasm0(payload, wasm.__wbindgen_export);
3357
+ const len0 = WASM_VECTOR_LEN;
3358
+ wasm.wallethandle_signRoot(retptr, this.__wbg_ptr, ptr0, len0);
3359
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
3360
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
3361
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
3362
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
3363
+ if (r3) {
3364
+ throw takeObject(r2);
3365
+ }
3366
+ var v2 = getArrayU8FromWasm0(r0, r1).slice();
3367
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
3368
+ return v2;
3369
+ } finally {
3370
+ wasm.__wbindgen_add_to_stack_pointer(16);
3371
+ }
3372
+ }
3373
+ /**
3374
+ * Sign with Substrate ECDSA key at `//ecdsa//<app_id>//<index>`. Returns 65 bytes (r+s+recovery).
3375
+ * @param {string} app_id
3376
+ * @param {number} index
3377
+ * @param {Uint8Array} payload
3378
+ * @returns {Uint8Array}
3379
+ */
3380
+ signSubstrateEcdsa(app_id, index, payload) {
3381
+ try {
3382
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
3383
+ const ptr0 = passStringToWasm0(app_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
3384
+ const len0 = WASM_VECTOR_LEN;
3385
+ const ptr1 = passArray8ToWasm0(payload, wasm.__wbindgen_export);
3386
+ const len1 = WASM_VECTOR_LEN;
3387
+ wasm.wallethandle_signSubstrateEcdsa(retptr, this.__wbg_ptr, ptr0, len0, index, ptr1, len1);
3388
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
3389
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
3390
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
3391
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
3392
+ if (r3) {
3393
+ throw takeObject(r2);
3394
+ }
3395
+ var v3 = getArrayU8FromWasm0(r0, r1).slice();
3396
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
3397
+ return v3;
3398
+ } finally {
3399
+ wasm.__wbindgen_add_to_stack_pointer(16);
3400
+ }
3401
+ }
3402
+ /**
3403
+ * Sign with the `//wallet` sr25519 keypair. Returns 64-byte signature.
3404
+ *
3405
+ * This matches the signing identity used by the native chat-request and
3406
+ * statement-store flows.
3407
+ * @param {Uint8Array} payload
3408
+ * @returns {Uint8Array}
3409
+ */
3410
+ signWallet(payload) {
3411
+ try {
3412
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
3413
+ const ptr0 = passArray8ToWasm0(payload, wasm.__wbindgen_export);
3414
+ const len0 = WASM_VECTOR_LEN;
3415
+ wasm.wallethandle_signWallet(retptr, this.__wbg_ptr, ptr0, len0);
3416
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
3417
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
3418
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
3419
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
3420
+ if (r3) {
3421
+ throw takeObject(r2);
3422
+ }
3423
+ var v2 = getArrayU8FromWasm0(r0, r1).slice();
3424
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
3425
+ return v2;
3426
+ } finally {
3427
+ wasm.__wbindgen_add_to_stack_pointer(16);
3428
+ }
3429
+ }
3430
+ /**
3431
+ * Current wallet state: "NoWallet" | "Locked" | "Unlocked".
3432
+ * @returns {string}
3433
+ */
3434
+ state() {
3435
+ let deferred1_0;
3436
+ let deferred1_1;
3437
+ try {
3438
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
3439
+ wasm.wallethandle_state(retptr, this.__wbg_ptr);
3440
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
3441
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
3442
+ deferred1_0 = r0;
3443
+ deferred1_1 = r1;
3444
+ return getStringFromWasm0(r0, r1);
3445
+ } finally {
3446
+ wasm.__wbindgen_add_to_stack_pointer(16);
3447
+ wasm.__wbindgen_export5(deferred1_0, deferred1_1, 1);
3448
+ }
3449
+ }
3450
+ /**
3451
+ * 33-byte compressed secp256k1 public key at `//ecdsa//<app_id>//<index>`.
3452
+ * @param {string} app_id
3453
+ * @param {number} index
3454
+ * @returns {Uint8Array}
3455
+ */
3456
+ substrateEcdsaPublicKey(app_id, index) {
3457
+ try {
3458
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
3459
+ const ptr0 = passStringToWasm0(app_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
3460
+ const len0 = WASM_VECTOR_LEN;
3461
+ wasm.wallethandle_substrateEcdsaPublicKey(retptr, this.__wbg_ptr, ptr0, len0, index);
3462
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
3463
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
3464
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
3465
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
3466
+ if (r3) {
3467
+ throw takeObject(r2);
3468
+ }
3469
+ var v2 = getArrayU8FromWasm0(r0, r1).slice();
3470
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
3471
+ return v2;
3472
+ } finally {
3473
+ wasm.__wbindgen_add_to_stack_pointer(16);
3474
+ }
3475
+ }
3476
+ /**
3477
+ * Check auto-lock timeout. Call once per frame. Returns true if locked.
3478
+ * @returns {boolean}
3479
+ */
3480
+ tick() {
3481
+ const ret = wasm.wallethandle_tick(this.__wbg_ptr);
3482
+ return ret !== 0;
3483
+ }
3484
+ /**
3485
+ * 32-byte sr25519 public key at `//wallet`.
3486
+ *
3487
+ * This is the chat identity account ID used by the native chat-request
3488
+ * and statement-store protocol.
3489
+ * @returns {Uint8Array}
3490
+ */
3491
+ walletPublicKey() {
3492
+ try {
3493
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
3494
+ wasm.wallethandle_walletPublicKey(retptr, this.__wbg_ptr);
3495
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
3496
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
3497
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
3498
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
3499
+ if (r3) {
3500
+ throw takeObject(r2);
3501
+ }
3502
+ var v1 = getArrayU8FromWasm0(r0, r1).slice();
3503
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
3504
+ return v1;
3505
+ } finally {
3506
+ wasm.__wbindgen_add_to_stack_pointer(16);
3507
+ }
3508
+ }
3509
+ }
3510
+ if (Symbol.dispose) WalletHandle.prototype[Symbol.dispose] = WalletHandle.prototype.free;
3511
+
3512
+ /**
3513
+ * Decode raw call data bytes against runtime metadata.
3514
+ *
3515
+ * Returns a JS object: `{ pallet: string, call: string, argsJson: object, nestedCalls: array }`.
3516
+ *
3517
+ * `call_data` is the raw bytes starting with the pallet index byte and call
3518
+ * index byte, followed by SCALE-encoded call arguments — exactly the prefix of
3519
+ * `callDataAndExtra` from `decodeSignPayload`, minus the signed-extension extra
3520
+ * bytes. Trailing signed-extension bytes are silently ignored.
3521
+ *
3522
+ * `metadata_scale` must be SCALE bytes for `RuntimeMetadataPrefixed` (V14, V15,
3523
+ * or V16 with the magic prefix `0x6d657461`).
3524
+ *
3525
+ * Throws a `JsError` on any decoding failure.
3526
+ * @param {Uint8Array} call_data
3527
+ * @param {Uint8Array} metadata_scale
3528
+ * @returns {any}
3529
+ */
3530
+ export function decodeCallData(call_data, metadata_scale) {
3531
+ try {
3532
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
3533
+ const ptr0 = passArray8ToWasm0(call_data, wasm.__wbindgen_export);
3534
+ const len0 = WASM_VECTOR_LEN;
3535
+ const ptr1 = passArray8ToWasm0(metadata_scale, wasm.__wbindgen_export);
3536
+ const len1 = WASM_VECTOR_LEN;
3537
+ wasm.decodeCallData(retptr, ptr0, len0, ptr1, len1);
3538
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
3539
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
3540
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
3541
+ if (r2) {
3542
+ throw takeObject(r1);
3543
+ }
3544
+ return takeObject(r0);
3545
+ } finally {
3546
+ wasm.__wbindgen_add_to_stack_pointer(16);
3547
+ }
3548
+ }
3549
+
3550
+ /**
3551
+ * Decode a Substrate extrinsic against runtime metadata.
3552
+ *
3553
+ * Returns a JS object: `{ pallet: string, call: string, argsJson: object, nestedCalls: array }`.
3554
+ *
3555
+ * `extrinsic_scale` must be compact-length-prefixed SCALE bytes for one extrinsic,
3556
+ * exactly as returned by a Substrate node (the outer `Vec<u8>` element from the block body).
3557
+ *
3558
+ * `metadata_scale` must be SCALE bytes for `RuntimeMetadataPrefixed` (V14, V15, or V16
3559
+ * with the magic prefix `0x6d657461`).
3560
+ *
3561
+ * Throws a `JsError` on any decoding failure. On success the returned `argsJson` contains
3562
+ * each argument name mapped to its decoded JSON value, and `nestedCalls` is a (possibly empty)
3563
+ * array of the same structure for inner calls in batch/proxy/multisig extrinsics.
3564
+ * @param {Uint8Array} extrinsic_scale
3565
+ * @param {Uint8Array} metadata_scale
3566
+ * @returns {any}
3567
+ */
3568
+ export function decodeExtrinsic(extrinsic_scale, metadata_scale) {
3569
+ try {
3570
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
3571
+ const ptr0 = passArray8ToWasm0(extrinsic_scale, wasm.__wbindgen_export);
3572
+ const len0 = WASM_VECTOR_LEN;
3573
+ const ptr1 = passArray8ToWasm0(metadata_scale, wasm.__wbindgen_export);
3574
+ const len1 = WASM_VECTOR_LEN;
3575
+ wasm.decodeExtrinsic(retptr, ptr0, len0, ptr1, len1);
3576
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
3577
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
3578
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
3579
+ if (r2) {
3580
+ throw takeObject(r1);
3581
+ }
3582
+ return takeObject(r0);
3583
+ } finally {
3584
+ wasm.__wbindgen_add_to_stack_pointer(16);
3585
+ }
3586
+ }
3587
+
3588
+ /**
3589
+ * Decode a Substrate extrinsic signing payload into structured fields.
3590
+ *
3591
+ * Use this on the `payload` bytes from a `NeedsSign` outcome when
3592
+ * `request_tag` equals `TAG_SIGN_PAYLOAD_REQ` (116 in v0.7.4 — formerly 36
3593
+ * in v0.7.3). Returns a JS object with `genesisHash`, `blockHash`,
3594
+ * `specVersion`, `txVersion`, `metadataHash` (Uint8Array or null), and
3595
+ * `callDataAndExtra`.
3596
+ *
3597
+ * This is a heuristic decoder for display purposes — see the
3598
+ * `useragent_encoding::extrinsic` module docs for limitations.
3599
+ * @param {Uint8Array} payload
3600
+ * @returns {any}
3601
+ */
3602
+ export function decodeSignPayload(payload) {
3603
+ try {
3604
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
3605
+ const ptr0 = passArray8ToWasm0(payload, wasm.__wbindgen_export);
3606
+ const len0 = WASM_VECTOR_LEN;
3607
+ wasm.decodeSignPayload(retptr, ptr0, len0);
3608
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
3609
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
3610
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
3611
+ if (r2) {
3612
+ throw takeObject(r1);
3613
+ }
3614
+ return takeObject(r0);
3615
+ } finally {
3616
+ wasm.__wbindgen_add_to_stack_pointer(16);
3617
+ }
3618
+ }
3619
+
3620
+ /**
3621
+ * SCALE-encode a raw signature as a Substrate MultiSignature.
3622
+ * `scheme`: 0 = Ed25519, 1 = Sr25519, 2 = Ecdsa.
3623
+ * @param {Uint8Array} sig_bytes
3624
+ * @param {number} scheme
3625
+ * @returns {Uint8Array}
3626
+ */
3627
+ export function encodeMultiSignature(sig_bytes, scheme) {
3628
+ try {
3629
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
3630
+ const ptr0 = passArray8ToWasm0(sig_bytes, wasm.__wbindgen_export);
3631
+ const len0 = WASM_VECTOR_LEN;
3632
+ wasm.encodeMultiSignature(retptr, ptr0, len0, scheme);
3633
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
3634
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
3635
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
3636
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
3637
+ if (r3) {
3638
+ throw takeObject(r2);
3639
+ }
3640
+ var v2 = getArrayU8FromWasm0(r0, r1).slice();
3641
+ wasm.__wbindgen_export5(r0, r1 * 1, 1);
3642
+ return v2;
3643
+ } finally {
3644
+ wasm.__wbindgen_add_to_stack_pointer(16);
3645
+ }
3646
+ }
3647
+
3648
+ /**
3649
+ * Generate a fresh 12-word BIP-39 mnemonic.
3650
+ * @returns {string}
3651
+ */
3652
+ export function generateMnemonic() {
3653
+ let deferred2_0;
3654
+ let deferred2_1;
3655
+ try {
3656
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
3657
+ wasm.generateMnemonic(retptr);
3658
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
3659
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
3660
+ var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
3661
+ var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
3662
+ var ptr1 = r0;
3663
+ var len1 = r1;
3664
+ if (r3) {
3665
+ ptr1 = 0; len1 = 0;
3666
+ throw takeObject(r2);
3667
+ }
3668
+ deferred2_0 = ptr1;
3669
+ deferred2_1 = len1;
3670
+ return getStringFromWasm0(ptr1, len1);
3671
+ } finally {
3672
+ wasm.__wbindgen_add_to_stack_pointer(16);
3673
+ wasm.__wbindgen_export5(deferred2_0, deferred2_1, 1);
3674
+ }
3675
+ }
3676
+ export function __wbg_Error_3639a60ed15f87e7(arg0, arg1) {
3677
+ const ret = Error(getStringFromWasm0(arg0, arg1));
3678
+ return addHeapObject(ret);
3679
+ }
3680
+ export function __wbg_String_8564e559799eccda(arg0, arg1) {
3681
+ const ret = String(getObject(arg1));
3682
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
3683
+ const len1 = WASM_VECTOR_LEN;
3684
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
3685
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
3686
+ }
3687
+ export function __wbg___wbindgen_bigint_get_as_i64_3af6d4ca77193a4b(arg0, arg1) {
3688
+ const v = getObject(arg1);
3689
+ const ret = typeof(v) === 'bigint' ? v : undefined;
3690
+ getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);
3691
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
3692
+ }
3693
+ export function __wbg___wbindgen_boolean_get_c3dd5c39f1b5a12b(arg0) {
3694
+ const v = getObject(arg0);
3695
+ const ret = typeof(v) === 'boolean' ? v : undefined;
3696
+ return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
3697
+ }
3698
+ export function __wbg___wbindgen_debug_string_07cb72cfcc952e2b(arg0, arg1) {
3699
+ const ret = debugString(getObject(arg1));
3700
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
3701
+ const len1 = WASM_VECTOR_LEN;
3702
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
3703
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
3704
+ }
3705
+ export function __wbg___wbindgen_in_2617fa76397620d3(arg0, arg1) {
3706
+ const ret = getObject(arg0) in getObject(arg1);
3707
+ return ret;
3708
+ }
3709
+ export function __wbg___wbindgen_is_bigint_d6a8167cac401b95(arg0) {
3710
+ const ret = typeof(getObject(arg0)) === 'bigint';
3711
+ return ret;
3712
+ }
3713
+ export function __wbg___wbindgen_is_function_2f0fd7ceb86e64c5(arg0) {
3714
+ const ret = typeof(getObject(arg0)) === 'function';
3715
+ return ret;
3716
+ }
3717
+ export function __wbg___wbindgen_is_object_5b22ff2418063a9c(arg0) {
3718
+ const val = getObject(arg0);
3719
+ const ret = typeof(val) === 'object' && val !== null;
3720
+ return ret;
3721
+ }
3722
+ export function __wbg___wbindgen_is_string_eddc07a3efad52e6(arg0) {
3723
+ const ret = typeof(getObject(arg0)) === 'string';
3724
+ return ret;
3725
+ }
3726
+ export function __wbg___wbindgen_is_undefined_244a92c34d3b6ec0(arg0) {
3727
+ const ret = getObject(arg0) === undefined;
3728
+ return ret;
3729
+ }
3730
+ export function __wbg___wbindgen_jsval_eq_403eaa3610500a25(arg0, arg1) {
3731
+ const ret = getObject(arg0) === getObject(arg1);
3732
+ return ret;
3733
+ }
3734
+ export function __wbg___wbindgen_jsval_loose_eq_1978f1e77b4bce62(arg0, arg1) {
3735
+ const ret = getObject(arg0) == getObject(arg1);
3736
+ return ret;
3737
+ }
3738
+ export function __wbg___wbindgen_number_get_dd6d69a6079f26f1(arg0, arg1) {
3739
+ const obj = getObject(arg1);
3740
+ const ret = typeof(obj) === 'number' ? obj : undefined;
3741
+ getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
3742
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
3743
+ }
3744
+ export function __wbg___wbindgen_string_get_965592073e5d848c(arg0, arg1) {
3745
+ const obj = getObject(arg1);
3746
+ const ret = typeof(obj) === 'string' ? obj : undefined;
3747
+ var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
3748
+ var len1 = WASM_VECTOR_LEN;
3749
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
3750
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
3751
+ }
3752
+ export function __wbg___wbindgen_throw_9c75d47bf9e7731e(arg0, arg1) {
3753
+ throw new Error(getStringFromWasm0(arg0, arg1));
3754
+ }
3755
+ export function __wbg__wbg_cb_unref_158e43e869788cdc(arg0) {
3756
+ getObject(arg0)._wbg_cb_unref();
3757
+ }
3758
+ export function __wbg_abort_43913e33ecb83d0d(arg0, arg1) {
3759
+ getObject(arg0).abort(getObject(arg1));
3760
+ }
3761
+ export function __wbg_abort_87eb7f23cf4b73d1(arg0) {
3762
+ getObject(arg0).abort();
3763
+ }
3764
+ export function __wbg_append_8df396311184f750() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
3765
+ getObject(arg0).append(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
3766
+ }, arguments); }
3767
+ export function __wbg_arrayBuffer_87e3ac06d961f7a0() { return handleError(function (arg0) {
3768
+ const ret = getObject(arg0).arrayBuffer();
3769
+ return addHeapObject(ret);
3770
+ }, arguments); }
3771
+ export function __wbg_call_a41d6421b30a32c5() { return handleError(function (arg0, arg1, arg2) {
3772
+ const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
3773
+ return addHeapObject(ret);
3774
+ }, arguments); }
3775
+ export function __wbg_call_add9e5a76382e668() { return handleError(function (arg0, arg1) {
3776
+ const ret = getObject(arg0).call(getObject(arg1));
3777
+ return addHeapObject(ret);
3778
+ }, arguments); }
3779
+ export function __wbg_clearTimeout_6b8d9a38b9263d65(arg0) {
3780
+ const ret = clearTimeout(takeObject(arg0));
3781
+ return addHeapObject(ret);
3782
+ }
3783
+ export function __wbg_crypto_38df2bab126b63dc(arg0) {
3784
+ const ret = getObject(arg0).crypto;
3785
+ return addHeapObject(ret);
3786
+ }
3787
+ export function __wbg_done_b1afd6201ac045e0(arg0) {
3788
+ const ret = getObject(arg0).done;
3789
+ return ret;
3790
+ }
3791
+ export function __wbg_entries_bb9843ba73dc70d6(arg0) {
3792
+ const ret = Object.entries(getObject(arg0));
3793
+ return addHeapObject(ret);
3794
+ }
3795
+ export function __wbg_fetch_1a030943aa8e0c38(arg0, arg1) {
3796
+ const ret = getObject(arg0).fetch(getObject(arg1));
3797
+ return addHeapObject(ret);
3798
+ }
3799
+ export function __wbg_fetch_9dad4fe911207b37(arg0) {
3800
+ const ret = fetch(getObject(arg0));
3801
+ return addHeapObject(ret);
3802
+ }
3803
+ export function __wbg_getItem_f68808a9230dd173() { return handleError(function (arg0, arg1, arg2, arg3) {
3804
+ const ret = getObject(arg1).getItem(getStringFromWasm0(arg2, arg3));
3805
+ var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
3806
+ var len1 = WASM_VECTOR_LEN;
3807
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
3808
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
3809
+ }, arguments); }
3810
+ export function __wbg_getRandomValues_c44a50d8cfdaebeb() { return handleError(function (arg0, arg1) {
3811
+ getObject(arg0).getRandomValues(getObject(arg1));
3812
+ }, arguments); }
3813
+ export function __wbg_get_652f640b3b0b6e3e(arg0, arg1) {
3814
+ const ret = getObject(arg0)[arg1 >>> 0];
3815
+ return addHeapObject(ret);
3816
+ }
3817
+ export function __wbg_get_9cfea9b7bbf12a15() { return handleError(function (arg0, arg1) {
3818
+ const ret = Reflect.get(getObject(arg0), getObject(arg1));
3819
+ return addHeapObject(ret);
3820
+ }, arguments); }
3821
+ export function __wbg_get_unchecked_be562b1421656321(arg0, arg1) {
3822
+ const ret = getObject(arg0)[arg1 >>> 0];
3823
+ return addHeapObject(ret);
3824
+ }
3825
+ export function __wbg_get_with_ref_key_6412cf3094599694(arg0, arg1) {
3826
+ const ret = getObject(arg0)[getObject(arg1)];
3827
+ return addHeapObject(ret);
3828
+ }
3829
+ export function __wbg_has_3a6f31f647e0ba22() { return handleError(function (arg0, arg1) {
3830
+ const ret = Reflect.has(getObject(arg0), getObject(arg1));
3831
+ return ret;
3832
+ }, arguments); }
3833
+ export function __wbg_headers_de17f740bce997ae(arg0) {
3834
+ const ret = getObject(arg0).headers;
3835
+ return addHeapObject(ret);
3836
+ }
3837
+ export function __wbg_instanceof_ArrayBuffer_eab9f28fbec23477(arg0) {
3838
+ let result;
3839
+ try {
3840
+ result = getObject(arg0) instanceof ArrayBuffer;
3841
+ } catch (_) {
3842
+ result = false;
3843
+ }
3844
+ const ret = result;
3845
+ return ret;
3846
+ }
3847
+ export function __wbg_instanceof_Map_10d4edf60fcf9327(arg0) {
3848
+ let result;
3849
+ try {
3850
+ result = getObject(arg0) instanceof Map;
3851
+ } catch (_) {
3852
+ result = false;
3853
+ }
3854
+ const ret = result;
3855
+ return ret;
3856
+ }
3857
+ export function __wbg_instanceof_Response_370b83aa6c17e88a(arg0) {
3858
+ let result;
3859
+ try {
3860
+ result = getObject(arg0) instanceof Response;
3861
+ } catch (_) {
3862
+ result = false;
3863
+ }
3864
+ const ret = result;
3865
+ return ret;
3866
+ }
3867
+ export function __wbg_instanceof_Uint8Array_57d77acd50e4c44d(arg0) {
3868
+ let result;
3869
+ try {
3870
+ result = getObject(arg0) instanceof Uint8Array;
3871
+ } catch (_) {
3872
+ result = false;
3873
+ }
3874
+ const ret = result;
3875
+ return ret;
3876
+ }
3877
+ export function __wbg_instanceof_Window_4153c1818a1c0c0b(arg0) {
3878
+ let result;
3879
+ try {
3880
+ result = getObject(arg0) instanceof Window;
3881
+ } catch (_) {
3882
+ result = false;
3883
+ }
3884
+ const ret = result;
3885
+ return ret;
3886
+ }
3887
+ export function __wbg_isArray_c6c6ef8308995bcf(arg0) {
3888
+ const ret = Array.isArray(getObject(arg0));
3889
+ return ret;
3890
+ }
3891
+ export function __wbg_isSafeInteger_3c56c421a5b4cce4(arg0) {
3892
+ const ret = Number.isSafeInteger(getObject(arg0));
3893
+ return ret;
3894
+ }
3895
+ export function __wbg_iterator_9d68985a1d096fc2() {
3896
+ const ret = Symbol.iterator;
3897
+ return addHeapObject(ret);
3898
+ }
3899
+ export function __wbg_length_0a6ce016dc1460b0(arg0) {
3900
+ const ret = getObject(arg0).length;
3901
+ return ret;
3902
+ }
3903
+ export function __wbg_length_ba3c032602efe310(arg0) {
3904
+ const ret = getObject(arg0).length;
3905
+ return ret;
3906
+ }
3907
+ export function __wbg_load_5dfeb2529031743d() { return handleError(function (arg0, arg1, arg2, arg3) {
3908
+ const ret = getObject(arg1).load(getStringFromWasm0(arg2, arg3));
3909
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
3910
+ const len1 = WASM_VECTOR_LEN;
3911
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
3912
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
3913
+ }, arguments); }
3914
+ export function __wbg_localStorage_11b5275c3ad2bab7() { return handleError(function (arg0) {
3915
+ const ret = getObject(arg0).localStorage;
3916
+ return isLikeNone(ret) ? 0 : addHeapObject(ret);
3917
+ }, arguments); }
3918
+ export function __wbg_msCrypto_bd5a034af96bcba6(arg0) {
3919
+ const ret = getObject(arg0).msCrypto;
3920
+ return addHeapObject(ret);
3921
+ }
3922
+ export function __wbg_new_18865c63fa645c6f() { return handleError(function () {
3923
+ const ret = new Headers();
3924
+ return addHeapObject(ret);
3925
+ }, arguments); }
3926
+ export function __wbg_new_2fad8ca02fd00684() {
3927
+ const ret = new Object();
3928
+ return addHeapObject(ret);
3929
+ }
3930
+ export function __wbg_new_3baa8d9866155c79() {
3931
+ const ret = new Array();
3932
+ return addHeapObject(ret);
3933
+ }
3934
+ export function __wbg_new_46ae4e4ff2a07a64() {
3935
+ const ret = new Map();
3936
+ return addHeapObject(ret);
3937
+ }
3938
+ export function __wbg_new_51ff470dc2f61e27() { return handleError(function () {
3939
+ const ret = new AbortController();
3940
+ return addHeapObject(ret);
3941
+ }, arguments); }
3942
+ export function __wbg_new_8454eee672b2ba6e(arg0) {
3943
+ const ret = new Uint8Array(getObject(arg0));
3944
+ return addHeapObject(ret);
3945
+ }
3946
+ export function __wbg_new_from_slice_5a173c243af2e823(arg0, arg1) {
3947
+ const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
3948
+ return addHeapObject(ret);
3949
+ }
3950
+ export function __wbg_new_typed_1137602701dc87d4(arg0, arg1) {
3951
+ try {
3952
+ var state0 = {a: arg0, b: arg1};
3953
+ var cb0 = (arg0, arg1) => {
3954
+ const a = state0.a;
3955
+ state0.a = 0;
3956
+ try {
3957
+ return __wasm_bindgen_func_elem_6009(a, state0.b, arg0, arg1);
3958
+ } finally {
3959
+ state0.a = a;
3960
+ }
3961
+ };
3962
+ const ret = new Promise(cb0);
3963
+ return addHeapObject(ret);
3964
+ } finally {
3965
+ state0.a = 0;
3966
+ }
3967
+ }
3968
+ export function __wbg_new_with_length_9011f5da794bf5d9(arg0) {
3969
+ const ret = new Uint8Array(arg0 >>> 0);
3970
+ return addHeapObject(ret);
3971
+ }
3972
+ export function __wbg_new_with_str_and_init_da311e12114f4d1e() { return handleError(function (arg0, arg1, arg2) {
3973
+ const ret = new Request(getStringFromWasm0(arg0, arg1), getObject(arg2));
3974
+ return addHeapObject(ret);
3975
+ }, arguments); }
3976
+ export function __wbg_next_261c3c48c6e309a5(arg0) {
3977
+ const ret = getObject(arg0).next;
3978
+ return addHeapObject(ret);
3979
+ }
3980
+ export function __wbg_next_aacee310bcfe6461() { return handleError(function (arg0) {
3981
+ const ret = getObject(arg0).next();
3982
+ return addHeapObject(ret);
3983
+ }, arguments); }
3984
+ export function __wbg_node_84ea875411254db1(arg0) {
3985
+ const ret = getObject(arg0).node;
3986
+ return addHeapObject(ret);
3987
+ }
3988
+ export function __wbg_now_e7c6795a7f81e10f(arg0) {
3989
+ const ret = getObject(arg0).now();
3990
+ return ret;
3991
+ }
3992
+ export function __wbg_performance_3fcf6e32a7e1ed0a(arg0) {
3993
+ const ret = getObject(arg0).performance;
3994
+ return addHeapObject(ret);
3995
+ }
3996
+ export function __wbg_process_44c7a14e11e9f69e(arg0) {
3997
+ const ret = getObject(arg0).process;
3998
+ return addHeapObject(ret);
3999
+ }
4000
+ export function __wbg_prototypesetcall_fd4050e806e1d519(arg0, arg1, arg2) {
4001
+ Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), getObject(arg2));
4002
+ }
4003
+ export function __wbg_push_60a5366c0bb22a7d(arg0, arg1) {
4004
+ const ret = getObject(arg0).push(getObject(arg1));
4005
+ return ret;
4006
+ }
4007
+ export function __wbg_queueMicrotask_40ac6ffc2848ba77(arg0) {
4008
+ queueMicrotask(getObject(arg0));
4009
+ }
4010
+ export function __wbg_queueMicrotask_74d092439f6494c1(arg0) {
4011
+ const ret = getObject(arg0).queueMicrotask;
4012
+ return addHeapObject(ret);
4013
+ }
4014
+ export function __wbg_randomFillSync_6c25eac9869eb53c() { return handleError(function (arg0, arg1) {
4015
+ getObject(arg0).randomFillSync(takeObject(arg1));
4016
+ }, arguments); }
4017
+ export function __wbg_require_b4edbdcf3e2a1ef0() { return handleError(function () {
4018
+ const ret = module.require;
4019
+ return addHeapObject(ret);
4020
+ }, arguments); }
4021
+ export function __wbg_resolve_9feb5d906ca62419(arg0) {
4022
+ const ret = Promise.resolve(getObject(arg0));
4023
+ return addHeapObject(ret);
4024
+ }
4025
+ export function __wbg_save_1facc7fba41f6f25() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
4026
+ getObject(arg0).save(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
4027
+ }, arguments); }
4028
+ export function __wbg_setItem_bb1a692eb19d66d0() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
4029
+ getObject(arg0).setItem(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
4030
+ }, arguments); }
4031
+ export function __wbg_setTimeout_f757f00851f76c42(arg0, arg1) {
4032
+ const ret = setTimeout(getObject(arg0), arg1);
4033
+ return addHeapObject(ret);
4034
+ }
4035
+ export function __wbg_set_5337f8ac82364a3f() { return handleError(function (arg0, arg1, arg2) {
4036
+ const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
4037
+ return ret;
4038
+ }, arguments); }
4039
+ export function __wbg_set_6be42768c690e380(arg0, arg1, arg2) {
4040
+ getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
4041
+ }
4042
+ export function __wbg_set_82f7a370f604db70(arg0, arg1, arg2) {
4043
+ const ret = getObject(arg0).set(getObject(arg1), getObject(arg2));
4044
+ return addHeapObject(ret);
4045
+ }
4046
+ export function __wbg_set_body_aaff4f5f9991f342(arg0, arg1) {
4047
+ getObject(arg0).body = getObject(arg1);
4048
+ }
4049
+ export function __wbg_set_cache_d1f2b7b4dfa39317(arg0, arg1) {
4050
+ getObject(arg0).cache = __wbindgen_enum_RequestCache[arg1];
4051
+ }
4052
+ export function __wbg_set_credentials_f31e4d30b974ce14(arg0, arg1) {
4053
+ getObject(arg0).credentials = __wbindgen_enum_RequestCredentials[arg1];
4054
+ }
4055
+ export function __wbg_set_f614f6a0608d1d1d(arg0, arg1, arg2) {
4056
+ getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
4057
+ }
4058
+ export function __wbg_set_headers_ae96049ea40e9eef(arg0, arg1) {
4059
+ getObject(arg0).headers = getObject(arg1);
4060
+ }
4061
+ export function __wbg_set_method_0eea8a5597775fa1(arg0, arg1, arg2) {
4062
+ getObject(arg0).method = getStringFromWasm0(arg1, arg2);
4063
+ }
4064
+ export function __wbg_set_mode_9fe47bff60a1580d(arg0, arg1) {
4065
+ getObject(arg0).mode = __wbindgen_enum_RequestMode[arg1];
4066
+ }
4067
+ export function __wbg_set_signal_8c5cf4c3b27bd8a8(arg0, arg1) {
4068
+ getObject(arg0).signal = getObject(arg1);
4069
+ }
4070
+ export function __wbg_signal_4643ce883b92b553(arg0) {
4071
+ const ret = getObject(arg0).signal;
4072
+ return addHeapObject(ret);
4073
+ }
4074
+ export function __wbg_static_accessor_GLOBAL_THIS_1c7f1bd6c6941fdb() {
4075
+ const ret = typeof globalThis === 'undefined' ? null : globalThis;
4076
+ return isLikeNone(ret) ? 0 : addHeapObject(ret);
4077
+ }
4078
+ export function __wbg_static_accessor_GLOBAL_e039bc914f83e74e() {
4079
+ const ret = typeof global === 'undefined' ? null : global;
4080
+ return isLikeNone(ret) ? 0 : addHeapObject(ret);
4081
+ }
4082
+ export function __wbg_static_accessor_SELF_8bf8c48c28420ad5() {
4083
+ const ret = typeof self === 'undefined' ? null : self;
4084
+ return isLikeNone(ret) ? 0 : addHeapObject(ret);
4085
+ }
4086
+ export function __wbg_static_accessor_WINDOW_6aeee9b51652ee0f() {
4087
+ const ret = typeof window === 'undefined' ? null : window;
4088
+ return isLikeNone(ret) ? 0 : addHeapObject(ret);
4089
+ }
4090
+ export function __wbg_status_157e67ab07d01f8a(arg0) {
4091
+ const ret = getObject(arg0).status;
4092
+ return ret;
4093
+ }
4094
+ export function __wbg_stringify_7fd5cae8859a6f10() { return handleError(function (arg0) {
4095
+ const ret = JSON.stringify(getObject(arg0));
4096
+ return addHeapObject(ret);
4097
+ }, arguments); }
4098
+ export function __wbg_subarray_fbe3cef290e1fa43(arg0, arg1, arg2) {
4099
+ const ret = getObject(arg0).subarray(arg1 >>> 0, arg2 >>> 0);
4100
+ return addHeapObject(ret);
4101
+ }
4102
+ export function __wbg_then_20a157d939b514f5(arg0, arg1) {
4103
+ const ret = getObject(arg0).then(getObject(arg1));
4104
+ return addHeapObject(ret);
4105
+ }
4106
+ export function __wbg_then_5ef9b762bc91555c(arg0, arg1, arg2) {
4107
+ const ret = getObject(arg0).then(getObject(arg1), getObject(arg2));
4108
+ return addHeapObject(ret);
4109
+ }
4110
+ export function __wbg_url_a0e994e7d0317efc(arg0, arg1) {
4111
+ const ret = getObject(arg1).url;
4112
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
4113
+ const len1 = WASM_VECTOR_LEN;
4114
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
4115
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
4116
+ }
4117
+ export function __wbg_value_f852716acdeb3e82(arg0) {
4118
+ const ret = getObject(arg0).value;
4119
+ return addHeapObject(ret);
4120
+ }
4121
+ export function __wbg_versions_276b2795b1c6a219(arg0) {
4122
+ const ret = getObject(arg0).versions;
4123
+ return addHeapObject(ret);
4124
+ }
4125
+ export function __wbindgen_cast_0000000000000001(arg0, arg1) {
4126
+ // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 634, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
4127
+ const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_6006);
4128
+ return addHeapObject(ret);
4129
+ }
4130
+ export function __wbindgen_cast_0000000000000002(arg0, arg1) {
4131
+ // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 457, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
4132
+ const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_4236);
4133
+ return addHeapObject(ret);
4134
+ }
4135
+ export function __wbindgen_cast_0000000000000003(arg0) {
4136
+ // Cast intrinsic for `F64 -> Externref`.
4137
+ const ret = arg0;
4138
+ return addHeapObject(ret);
4139
+ }
4140
+ export function __wbindgen_cast_0000000000000004(arg0) {
4141
+ // Cast intrinsic for `I64 -> Externref`.
4142
+ const ret = arg0;
4143
+ return addHeapObject(ret);
4144
+ }
4145
+ export function __wbindgen_cast_0000000000000005(arg0, arg1) {
4146
+ // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
4147
+ const ret = getArrayU8FromWasm0(arg0, arg1);
4148
+ return addHeapObject(ret);
4149
+ }
4150
+ export function __wbindgen_cast_0000000000000006(arg0, arg1) {
4151
+ // Cast intrinsic for `Ref(String) -> Externref`.
4152
+ const ret = getStringFromWasm0(arg0, arg1);
4153
+ return addHeapObject(ret);
4154
+ }
4155
+ export function __wbindgen_cast_0000000000000007(arg0) {
4156
+ // Cast intrinsic for `U64 -> Externref`.
4157
+ const ret = BigInt.asUintN(64, arg0);
4158
+ return addHeapObject(ret);
4159
+ }
4160
+ export function __wbindgen_object_clone_ref(arg0) {
4161
+ const ret = getObject(arg0);
4162
+ return addHeapObject(ret);
4163
+ }
4164
+ export function __wbindgen_object_drop_ref(arg0) {
4165
+ takeObject(arg0);
4166
+ }
4167
+ function __wasm_bindgen_func_elem_4236(arg0, arg1) {
4168
+ wasm.__wasm_bindgen_func_elem_4236(arg0, arg1);
4169
+ }
4170
+
4171
+ function __wasm_bindgen_func_elem_6006(arg0, arg1, arg2) {
4172
+ try {
4173
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
4174
+ wasm.__wasm_bindgen_func_elem_6006(retptr, arg0, arg1, addHeapObject(arg2));
4175
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
4176
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
4177
+ if (r1) {
4178
+ throw takeObject(r0);
4179
+ }
4180
+ } finally {
4181
+ wasm.__wbindgen_add_to_stack_pointer(16);
4182
+ }
4183
+ }
4184
+
4185
+ function __wasm_bindgen_func_elem_6009(arg0, arg1, arg2, arg3) {
4186
+ wasm.__wasm_bindgen_func_elem_6009(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
4187
+ }
4188
+
4189
+
4190
+ const __wbindgen_enum_RequestCache = ["default", "no-store", "reload", "no-cache", "force-cache", "only-if-cached"];
4191
+
4192
+
4193
+ const __wbindgen_enum_RequestCredentials = ["omit", "same-origin", "include"];
4194
+
4195
+
4196
+ const __wbindgen_enum_RequestMode = ["same-origin", "no-cors", "cors", "navigate"];
4197
+ const ChainClientHandleFinalization = (typeof FinalizationRegistry === 'undefined')
4198
+ ? { register: () => {}, unregister: () => {} }
4199
+ : new FinalizationRegistry(ptr => wasm.__wbg_chainclienthandle_free(ptr, 1));
4200
+ const ChatSessionHandleFinalization = (typeof FinalizationRegistry === 'undefined')
4201
+ ? { register: () => {}, unregister: () => {} }
4202
+ : new FinalizationRegistry(ptr => wasm.__wbg_chatsessionhandle_free(ptr, 1));
4203
+ const DotnsHandleFinalization = (typeof FinalizationRegistry === 'undefined')
4204
+ ? { register: () => {}, unregister: () => {} }
4205
+ : new FinalizationRegistry(ptr => wasm.__wbg_dotnshandle_free(ptr, 1));
4206
+ const HostApiHandleFinalization = (typeof FinalizationRegistry === 'undefined')
4207
+ ? { register: () => {}, unregister: () => {} }
4208
+ : new FinalizationRegistry(ptr => wasm.__wbg_hostapihandle_free(ptr, 1));
4209
+ const IdentityHandleFinalization = (typeof FinalizationRegistry === 'undefined')
4210
+ ? { register: () => {}, unregister: () => {} }
4211
+ : new FinalizationRegistry(ptr => wasm.__wbg_identityhandle_free(ptr, 1));
4212
+ const QrHandleFinalization = (typeof FinalizationRegistry === 'undefined')
4213
+ ? { register: () => {}, unregister: () => {} }
4214
+ : new FinalizationRegistry(ptr => wasm.__wbg_qrhandle_free(ptr, 1));
4215
+ const StatementHandleFinalization = (typeof FinalizationRegistry === 'undefined')
4216
+ ? { register: () => {}, unregister: () => {} }
4217
+ : new FinalizationRegistry(ptr => wasm.__wbg_statementhandle_free(ptr, 1));
4218
+ const StatementStoreHandleFinalization = (typeof FinalizationRegistry === 'undefined')
4219
+ ? { register: () => {}, unregister: () => {} }
4220
+ : new FinalizationRegistry(ptr => wasm.__wbg_statementstorehandle_free(ptr, 1));
4221
+ const WalletHandleFinalization = (typeof FinalizationRegistry === 'undefined')
4222
+ ? { register: () => {}, unregister: () => {} }
4223
+ : new FinalizationRegistry(ptr => wasm.__wbg_wallethandle_free(ptr, 1));
4224
+
4225
+ function addHeapObject(obj) {
4226
+ if (heap_next === heap.length) heap.push(heap.length + 1);
4227
+ const idx = heap_next;
4228
+ heap_next = heap[idx];
4229
+
4230
+ heap[idx] = obj;
4231
+ return idx;
4232
+ }
4233
+
4234
+ const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
4235
+ ? { register: () => {}, unregister: () => {} }
4236
+ : new FinalizationRegistry(state => wasm.__wbindgen_export4(state.a, state.b));
4237
+
4238
+ function debugString(val) {
4239
+ // primitive types
4240
+ const type = typeof val;
4241
+ if (type == 'number' || type == 'boolean' || val == null) {
4242
+ return `${val}`;
4243
+ }
4244
+ if (type == 'string') {
4245
+ return `"${val}"`;
4246
+ }
4247
+ if (type == 'symbol') {
4248
+ const description = val.description;
4249
+ if (description == null) {
4250
+ return 'Symbol';
4251
+ } else {
4252
+ return `Symbol(${description})`;
4253
+ }
4254
+ }
4255
+ if (type == 'function') {
4256
+ const name = val.name;
4257
+ if (typeof name == 'string' && name.length > 0) {
4258
+ return `Function(${name})`;
4259
+ } else {
4260
+ return 'Function';
4261
+ }
4262
+ }
4263
+ // objects
4264
+ if (Array.isArray(val)) {
4265
+ const length = val.length;
4266
+ let debug = '[';
4267
+ if (length > 0) {
4268
+ debug += debugString(val[0]);
4269
+ }
4270
+ for(let i = 1; i < length; i++) {
4271
+ debug += ', ' + debugString(val[i]);
4272
+ }
4273
+ debug += ']';
4274
+ return debug;
4275
+ }
4276
+ // Test for built-in
4277
+ const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
4278
+ let className;
4279
+ if (builtInMatches && builtInMatches.length > 1) {
4280
+ className = builtInMatches[1];
4281
+ } else {
4282
+ // Failed to match the standard '[object ClassName]'
4283
+ return toString.call(val);
4284
+ }
4285
+ if (className == 'Object') {
4286
+ // we're a user defined class or Object
4287
+ // JSON.stringify avoids problems with cycles, and is generally much
4288
+ // easier than looping through ownProperties of `val`.
4289
+ try {
4290
+ return 'Object(' + JSON.stringify(val) + ')';
4291
+ } catch (_) {
4292
+ return 'Object';
4293
+ }
4294
+ }
4295
+ // errors
4296
+ if (val instanceof Error) {
4297
+ return `${val.name}: ${val.message}\n${val.stack}`;
4298
+ }
4299
+ // TODO we could test for more things here, like `Set`s and `Map`s.
4300
+ return className;
4301
+ }
4302
+
4303
+ function dropObject(idx) {
4304
+ if (idx < 1028) return;
4305
+ heap[idx] = heap_next;
4306
+ heap_next = idx;
4307
+ }
4308
+
4309
+ function getArrayU8FromWasm0(ptr, len) {
4310
+ ptr = ptr >>> 0;
4311
+ return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
4312
+ }
4313
+
4314
+ let cachedDataViewMemory0 = null;
4315
+ function getDataViewMemory0() {
4316
+ if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
4317
+ cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
4318
+ }
4319
+ return cachedDataViewMemory0;
4320
+ }
4321
+
4322
+ function getStringFromWasm0(ptr, len) {
4323
+ return decodeText(ptr >>> 0, len);
4324
+ }
4325
+
4326
+ let cachedUint8ArrayMemory0 = null;
4327
+ function getUint8ArrayMemory0() {
4328
+ if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
4329
+ cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
4330
+ }
4331
+ return cachedUint8ArrayMemory0;
4332
+ }
4333
+
4334
+ function getObject(idx) { return heap[idx]; }
4335
+
4336
+ function handleError(f, args) {
4337
+ try {
4338
+ return f.apply(this, args);
4339
+ } catch (e) {
4340
+ wasm.__wbindgen_export3(addHeapObject(e));
4341
+ }
4342
+ }
4343
+
4344
+ let heap = new Array(1024).fill(undefined);
4345
+ heap.push(undefined, null, true, false);
4346
+
4347
+ let heap_next = heap.length;
4348
+
4349
+ function isLikeNone(x) {
4350
+ return x === undefined || x === null;
4351
+ }
4352
+
4353
+ function makeMutClosure(arg0, arg1, f) {
4354
+ const state = { a: arg0, b: arg1, cnt: 1 };
4355
+ const real = (...args) => {
4356
+
4357
+ // First up with a closure we increment the internal reference
4358
+ // count. This ensures that the Rust closure environment won't
4359
+ // be deallocated while we're invoking it.
4360
+ state.cnt++;
4361
+ const a = state.a;
4362
+ state.a = 0;
4363
+ try {
4364
+ return f(a, state.b, ...args);
4365
+ } finally {
4366
+ state.a = a;
4367
+ real._wbg_cb_unref();
4368
+ }
4369
+ };
4370
+ real._wbg_cb_unref = () => {
4371
+ if (--state.cnt === 0) {
4372
+ wasm.__wbindgen_export4(state.a, state.b);
4373
+ state.a = 0;
4374
+ CLOSURE_DTORS.unregister(state);
4375
+ }
4376
+ };
4377
+ CLOSURE_DTORS.register(real, state, state);
4378
+ return real;
4379
+ }
4380
+
4381
+ function passArray8ToWasm0(arg, malloc) {
4382
+ const ptr = malloc(arg.length * 1, 1) >>> 0;
4383
+ getUint8ArrayMemory0().set(arg, ptr / 1);
4384
+ WASM_VECTOR_LEN = arg.length;
4385
+ return ptr;
4386
+ }
4387
+
4388
+ function passStringToWasm0(arg, malloc, realloc) {
4389
+ if (realloc === undefined) {
4390
+ const buf = cachedTextEncoder.encode(arg);
4391
+ const ptr = malloc(buf.length, 1) >>> 0;
4392
+ getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
4393
+ WASM_VECTOR_LEN = buf.length;
4394
+ return ptr;
4395
+ }
4396
+
4397
+ let len = arg.length;
4398
+ let ptr = malloc(len, 1) >>> 0;
4399
+
4400
+ const mem = getUint8ArrayMemory0();
4401
+
4402
+ let offset = 0;
4403
+
4404
+ for (; offset < len; offset++) {
4405
+ const code = arg.charCodeAt(offset);
4406
+ if (code > 0x7F) break;
4407
+ mem[ptr + offset] = code;
4408
+ }
4409
+ if (offset !== len) {
4410
+ if (offset !== 0) {
4411
+ arg = arg.slice(offset);
4412
+ }
4413
+ ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
4414
+ const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
4415
+ const ret = cachedTextEncoder.encodeInto(arg, view);
4416
+
4417
+ offset += ret.written;
4418
+ ptr = realloc(ptr, len, offset, 1) >>> 0;
4419
+ }
4420
+
4421
+ WASM_VECTOR_LEN = offset;
4422
+ return ptr;
4423
+ }
4424
+
4425
+ function takeObject(idx) {
4426
+ const ret = getObject(idx);
4427
+ dropObject(idx);
4428
+ return ret;
4429
+ }
4430
+
4431
+ let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
4432
+ cachedTextDecoder.decode();
4433
+ const MAX_SAFARI_DECODE_BYTES = 2146435072;
4434
+ let numBytesDecoded = 0;
4435
+ function decodeText(ptr, len) {
4436
+ numBytesDecoded += len;
4437
+ if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
4438
+ cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
4439
+ cachedTextDecoder.decode();
4440
+ numBytesDecoded = len;
4441
+ }
4442
+ return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
4443
+ }
4444
+
4445
+ const cachedTextEncoder = new TextEncoder();
4446
+
4447
+ if (!('encodeInto' in cachedTextEncoder)) {
4448
+ cachedTextEncoder.encodeInto = function (arg, view) {
4449
+ const buf = cachedTextEncoder.encode(arg);
4450
+ view.set(buf);
4451
+ return {
4452
+ read: arg.length,
4453
+ written: buf.length
4454
+ };
4455
+ };
4456
+ }
4457
+
4458
+ let WASM_VECTOR_LEN = 0;
4459
+
4460
+
4461
+ let wasm;
4462
+ export function __wbg_set_wasm(val) {
4463
+ wasm = val;
4464
+ }