unwallet-client-sdk 0.18.2 → 0.20.0

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/dist/index.cjs +294 -413
  2. package/dist/index.d.cts +85 -84
  3. package/dist/index.d.ts +85 -84
  4. package/dist/index.js +292 -390
  5. package/package.json +14 -9
package/dist/index.cjs CHANGED
@@ -1,423 +1,304 @@
1
- "use strict";
2
- var __defProp = Object.defineProperty;
3
- var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
4
- var __getOwnPropNames = Object.getOwnPropertyNames;
5
- var __hasOwnProp = Object.prototype.hasOwnProperty;
6
- var __export = (target, all) => {
7
- for (var name in all)
8
- __defProp(target, name, { get: all[name], enumerable: true });
9
- };
10
- var __copyProps = (to, from, except, desc) => {
11
- if (from && typeof from === "object" || typeof from === "function") {
12
- for (let key of __getOwnPropNames(from))
13
- if (!__hasOwnProp.call(to, key) && key !== except)
14
- __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
15
- }
16
- return to;
17
- };
18
- var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
19
-
20
- // src/index.ts
21
- var index_exports = {};
22
- __export(index_exports, {
23
- UWError: () => UWError,
24
- UnWallet: () => UnWallet
25
- });
26
- module.exports = __toCommonJS(index_exports);
27
-
28
- // src/error.ts
29
- var _UWError = class _UWError extends Error {
30
- constructor(code, message) {
31
- super(message !== void 0 ? `${code}: ${message}` : code);
32
- this.code = code;
33
- }
34
- };
35
- _UWError.prototype.name = "UWError";
36
- var UWError = _UWError;
37
-
38
- // src/unwallet.ts
39
- var import_viem = require("viem");
40
-
41
- // src/config.ts
42
- var UNWALLET_CONFIG_PROD = {
43
- frontend: {
44
- baseURL: "https://id.unwallet.world"
45
- },
46
- xapi: {
47
- url: "wss://xapi.id.unwallet.world",
48
- connectionTimeout: 1e4
49
- }
50
- };
51
- var UNWALLET_CONFIG_DEV = {
52
- frontend: {
53
- baseURL: "http://localhost:4200"
54
- },
55
- xapi: {
56
- url: "wss://xapi.id.test.unwallet.dev",
57
- connectionTimeout: 1e4
58
- }
1
+ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
2
+ let viem = require("viem");
3
+ let zod = require("zod");
4
+ //#region src/error.ts
5
+ var UWError = class extends Error {
6
+ constructor(code, message) {
7
+ super(message !== void 0 ? `${code}: ${message}` : code);
8
+ this.code = code;
9
+ }
10
+ static {
11
+ this.prototype.name = "UWError";
12
+ }
59
13
  };
14
+ //#endregion
15
+ //#region src/config.ts
60
16
  function getUnWalletConfigByEnv(env) {
61
- switch (env) {
62
- case "prod":
63
- return UNWALLET_CONFIG_PROD;
64
- case "dev":
65
- return UNWALLET_CONFIG_DEV;
66
- }
17
+ switch (env) {
18
+ case "prod": return {
19
+ frontend: { baseURL: "https://id.unwallet.world" },
20
+ xapi: {
21
+ url: "wss://xapi.id.unwallet.world",
22
+ connectionTimeout: 1e4
23
+ }
24
+ };
25
+ case "dev": return {
26
+ frontend: { baseURL: "http://localhost:4200" },
27
+ xapi: {
28
+ url: "wss://xapi.id.test.unwallet.dev",
29
+ connectionTimeout: 1e4
30
+ }
31
+ };
32
+ }
67
33
  }
68
-
69
- // src/x.ts
70
- var import_zod = require("zod");
71
- var VALID_X_RESPONSE_TYPES = [
72
- "connectionID",
73
- "signature",
74
- "transactionID",
75
- "error"
34
+ //#endregion
35
+ //#region src/x.ts
36
+ const X_RESPONSE_TYPES = [
37
+ "connectionID",
38
+ "signature",
39
+ "transactionID",
40
+ "error"
76
41
  ];
77
- var XConnection = class _XConnection {
78
- constructor(args) {
79
- this.responseHandler = null;
80
- this.socket = args.socket;
81
- this.id = args.id;
82
- this.initListeners();
83
- }
84
- initListeners() {
85
- this.socket.onopen = null;
86
- this.socket.onmessage = (event) => {
87
- if (this.responseHandler === null) {
88
- return;
89
- }
90
- let resp;
91
- {
92
- const result = safeParseMessageEventDataToXResponse(event.data);
93
- if (!result.success) {
94
- this.responseHandler.reject(result.error);
95
- return;
96
- }
97
- resp = result.data;
98
- }
99
- switch (resp.type) {
100
- case "error":
101
- switch (resp.value) {
102
- case "rejected":
103
- this.responseHandler.reject(new UWError("REQUEST_REJECTED"));
104
- break;
105
- default:
106
- this.responseHandler.reject(
107
- new UWError(
108
- "INVALID_RESPONSE",
109
- `unexpected error response value: ${resp.value}`
110
- )
111
- );
112
- }
113
- break;
114
- default:
115
- this.responseHandler.resolve(resp);
116
- }
117
- };
118
- this.socket.onerror = null;
119
- this.socket.onclose = (event) => {
120
- if (this.responseHandler === null) {
121
- return;
122
- }
123
- this.responseHandler.reject(
124
- new UWError("CONNECTION_CLOSED", event.reason)
125
- );
126
- };
127
- }
128
- get readyState() {
129
- return this.socket.readyState;
130
- }
131
- get hasResponseHandler() {
132
- return this.responseHandler !== null;
133
- }
134
- setResponseHandler(handler) {
135
- this.responseHandler = handler;
136
- }
137
- static async init(config) {
138
- const socket = new WebSocket(config.url);
139
- const id = await new Promise((resolve, reject) => {
140
- setInterval(
141
- () => reject(new UWError("CONNECTION_TIMEOUT")),
142
- config.connectionTimeout
143
- );
144
- socket.onopen = () => socket.send(JSON.stringify({ action: "getConnectionID" }));
145
- socket.onmessage = (event) => {
146
- let resp;
147
- {
148
- const result = safeParseMessageEventDataToXResponse(event.data);
149
- if (!result.success) {
150
- reject(result.error);
151
- return;
152
- }
153
- resp = result.data;
154
- }
155
- if (resp.type !== "connectionID") {
156
- reject(
157
- new UWError(
158
- "INVALID_RESPONSE",
159
- `unexpected response type: ${resp.type}`
160
- )
161
- );
162
- return;
163
- }
164
- resolve(resp.value);
165
- };
166
- socket.onerror = () => reject(new UWError("CONNECTION_FAILED"));
167
- socket.onclose = (event) => reject(new UWError("CONNECTION_CLOSED", event.reason));
168
- });
169
- return new _XConnection({ socket, id });
170
- }
42
+ var XConnection = class XConnection {
43
+ constructor(args) {
44
+ this.responseHandler = null;
45
+ this.socket = args.socket;
46
+ this.id = args.id;
47
+ this.initListeners();
48
+ }
49
+ static async init(config) {
50
+ const socket = new WebSocket(config.url);
51
+ const id = await new Promise((resolve, reject) => {
52
+ setInterval(() => reject(new UWError("CONNECTION_TIMEOUT")), config.connectionTimeout);
53
+ socket.onopen = () => socket.send(JSON.stringify({ action: "getConnectionID" }));
54
+ socket.onmessage = (event) => {
55
+ let resp;
56
+ {
57
+ const result = safeParseMessageEventDataToXResponse(event.data);
58
+ if (!result.success) {
59
+ reject(result.error);
60
+ return;
61
+ }
62
+ resp = result.data;
63
+ }
64
+ if (resp.type !== "connectionID") {
65
+ reject(new UWError("INVALID_RESPONSE", `unexpected response type: ${resp.type}`));
66
+ return;
67
+ }
68
+ resolve(resp.value);
69
+ };
70
+ socket.onerror = () => reject(new UWError("CONNECTION_FAILED"));
71
+ socket.onclose = (event) => reject(new UWError("CONNECTION_CLOSED", event.reason));
72
+ });
73
+ return new XConnection({
74
+ id,
75
+ socket
76
+ });
77
+ }
78
+ initListeners() {
79
+ this.socket.onopen = null;
80
+ this.socket.onmessage = (event) => {
81
+ if (this.responseHandler === null) return;
82
+ let resp;
83
+ {
84
+ const result = safeParseMessageEventDataToXResponse(event.data);
85
+ if (!result.success) {
86
+ this.responseHandler.reject(result.error);
87
+ return;
88
+ }
89
+ resp = result.data;
90
+ }
91
+ switch (resp.type) {
92
+ case "error":
93
+ switch (resp.value) {
94
+ case "rejected":
95
+ this.responseHandler.reject(new UWError("REQUEST_REJECTED"));
96
+ break;
97
+ default: this.responseHandler.reject(new UWError("INVALID_RESPONSE", `unexpected error response value: ${resp.value}`));
98
+ }
99
+ break;
100
+ default: this.responseHandler.resolve(resp);
101
+ }
102
+ };
103
+ this.socket.onerror = null;
104
+ this.socket.onclose = (event) => {
105
+ if (this.responseHandler === null) return;
106
+ this.responseHandler.reject(new UWError("CONNECTION_CLOSED", event.reason));
107
+ };
108
+ }
109
+ get readyState() {
110
+ return this.socket.readyState;
111
+ }
112
+ get hasResponseHandler() {
113
+ return this.responseHandler !== null;
114
+ }
115
+ setResponseHandler(handler) {
116
+ this.responseHandler = handler;
117
+ }
171
118
  };
172
119
  function safeParseMessageEventDataToXResponse(data) {
173
- const result = import_zod.z.string().refine(
174
- (val) => {
175
- try {
176
- JSON.parse(val);
177
- } catch (e) {
178
- return false;
179
- }
180
- return true;
181
- },
182
- {
183
- abort: true,
184
- message: "Invalid JSON string"
185
- }
186
- ).transform((val) => JSON.parse(val)).pipe(
187
- import_zod.z.object({
188
- type: import_zod.z.enum(VALID_X_RESPONSE_TYPES),
189
- value: import_zod.z.string()
190
- })
191
- ).safeParse(data);
192
- if (!result.success) {
193
- return {
194
- success: false,
195
- error: new UWError(
196
- "INVALID_RESPONSE",
197
- `invalid message event data: ${result.error.message}`
198
- )
199
- };
200
- }
201
- return {
202
- success: true,
203
- data: result.data
204
- };
120
+ const result = zod.z.string().refine((val) => {
121
+ try {
122
+ JSON.parse(val);
123
+ } catch (e) {
124
+ return false;
125
+ }
126
+ return true;
127
+ }, {
128
+ abort: true,
129
+ message: "Invalid JSON string"
130
+ }).transform((val) => JSON.parse(val)).pipe(zod.z.object({
131
+ type: zod.z.enum(X_RESPONSE_TYPES),
132
+ value: zod.z.string()
133
+ })).safeParse(data);
134
+ if (!result.success) return {
135
+ success: false,
136
+ error: new UWError("INVALID_RESPONSE", `invalid message event data: ${result.error.message}`)
137
+ };
138
+ return {
139
+ success: true,
140
+ data: result.data
141
+ };
205
142
  }
206
-
207
- // src/unwallet.ts
208
- var UnWallet = class _UnWallet {
209
- constructor(args) {
210
- this.env = args.env;
211
- this.clientID = args.clientID;
212
- this.xConnection = args.xConnection;
213
- }
214
- static async init(config) {
215
- const env = config.env !== void 0 ? config.env : "prod";
216
- return new _UnWallet({
217
- env,
218
- clientID: config.clientID,
219
- xConnection: await XConnection.init(getUnWalletConfigByEnv(env).xapi)
220
- });
221
- }
222
- get unWalletConfig() {
223
- return getUnWalletConfigByEnv(this.env);
224
- }
225
- authorize(args) {
226
- const url = new URL(
227
- `${this.unWalletConfig.frontend.baseURL}/${args.isVirtual !== void 0 ? args.isVirtual ? "v" : "" : "v"}authorize`
228
- );
229
- {
230
- url.searchParams.set("response_type", "id_token");
231
- url.searchParams.set(
232
- "response_mode",
233
- args.responseMode !== void 0 ? args.responseMode : "fragment"
234
- );
235
- url.searchParams.set("client_id", this.clientID);
236
- url.searchParams.set("scope", "openid");
237
- url.searchParams.set("redirect_uri", args.redirectURL);
238
- if (args.nonce !== void 0) {
239
- url.searchParams.set("nonce", args.nonce);
240
- }
241
- if (args.chainID !== void 0) {
242
- url.searchParams.set("chain_id", args.chainID.toString());
243
- }
244
- }
245
- location.assign(url);
246
- }
247
- sign(args) {
248
- return new Promise((resolve, reject) => {
249
- if (this.xConnection.readyState !== WebSocket.OPEN) {
250
- reject(new UWError("CONNECTION_NOT_OPENED"));
251
- return;
252
- }
253
- if (this.xConnection.hasResponseHandler) {
254
- reject(new UWError("REQUEST_IN_PROGRESS"));
255
- return;
256
- }
257
- const digest = (0, import_viem.sha256)((0, import_viem.toBytes)(args.message));
258
- this.xConnection.setResponseHandler({
259
- resolve: (resp) => {
260
- this.xConnection.setResponseHandler(null);
261
- if (resp.type !== "signature") {
262
- reject(
263
- new UWError(
264
- "INVALID_RESPONSE",
265
- `unexpected response type: ${resp.type}`
266
- )
267
- );
268
- return;
269
- }
270
- resolve({
271
- digest,
272
- signature: resp.value
273
- });
274
- },
275
- reject: (err) => {
276
- this.xConnection.setResponseHandler(null);
277
- reject(err);
278
- }
279
- });
280
- const url = new URL(`${this.unWalletConfig.frontend.baseURL}/x/sign`);
281
- {
282
- url.searchParams.set("connectionID", this.xConnection.id);
283
- url.searchParams.set("clientID", this.clientID);
284
- url.searchParams.set("message", args.message);
285
- url.searchParams.set("ticketToken", args.ticketToken);
286
- }
287
- openWindow(url);
288
- });
289
- }
290
- signEIP712TypedData(args) {
291
- return new Promise((resolve, reject) => {
292
- if (this.xConnection.readyState !== WebSocket.OPEN) {
293
- reject(new UWError("CONNECTION_NOT_OPENED"));
294
- return;
295
- }
296
- if (this.xConnection.hasResponseHandler) {
297
- reject(new UWError("REQUEST_IN_PROGRESS"));
298
- return;
299
- }
300
- const { EIP712Domain: _, ...typedDataTypes } = args.typedData.types;
301
- const typedData = {
302
- ...args.typedData,
303
- types: typedDataTypes
304
- };
305
- try {
306
- (0, import_viem.validateTypedData)(typedData);
307
- } catch (e) {
308
- reject(
309
- new UWError(
310
- "INVALID_REQUEST",
311
- `invalid typed data: ${e.message}`
312
- )
313
- );
314
- return;
315
- }
316
- const digest = (0, import_viem.hashTypedData)(typedData);
317
- this.xConnection.setResponseHandler({
318
- resolve: (resp) => {
319
- this.xConnection.setResponseHandler(null);
320
- if (resp.type !== "signature") {
321
- reject(
322
- new UWError(
323
- "INVALID_RESPONSE",
324
- `unexpected response type: ${resp.type}`
325
- )
326
- );
327
- return;
328
- }
329
- resolve({
330
- digest,
331
- signature: resp.value
332
- });
333
- },
334
- reject: (err) => {
335
- this.xConnection.setResponseHandler(null);
336
- reject(err);
337
- }
338
- });
339
- const url = new URL(
340
- `${this.unWalletConfig.frontend.baseURL}/x/signEIP712TypedData`
341
- );
342
- {
343
- url.searchParams.set("connectionID", this.xConnection.id);
344
- url.searchParams.set("clientID", this.clientID);
345
- url.searchParams.set("typedData", JSON.stringify(args.typedData));
346
- url.searchParams.set("ticketToken", args.ticketToken);
347
- }
348
- openWindow(url);
349
- });
350
- }
351
- sendTransaction(args) {
352
- return new Promise((resolve, reject) => {
353
- if (this.xConnection.readyState !== WebSocket.OPEN) {
354
- reject(new UWError("CONNECTION_NOT_OPENED"));
355
- return;
356
- }
357
- if (this.xConnection.hasResponseHandler) {
358
- reject(new UWError("REQUEST_IN_PROGRESS"));
359
- return;
360
- }
361
- if (args.value === void 0 && args.data === void 0) {
362
- reject(
363
- new UWError("INVALID_REQUEST", "either value or data is required")
364
- );
365
- return;
366
- }
367
- this.xConnection.setResponseHandler({
368
- resolve: (resp) => {
369
- this.xConnection.setResponseHandler(null);
370
- if (resp.type !== "transactionID") {
371
- reject(
372
- new UWError(
373
- "INVALID_RESPONSE",
374
- `unexpected response type: ${resp.type}`
375
- )
376
- );
377
- return;
378
- }
379
- resolve({ transactionID: resp.value });
380
- },
381
- reject: (err) => {
382
- this.xConnection.setResponseHandler(null);
383
- reject(err);
384
- }
385
- });
386
- const url = new URL(
387
- `${this.unWalletConfig.frontend.baseURL}/x/sendTransaction`
388
- );
389
- {
390
- url.searchParams.set("connectionID", this.xConnection.id);
391
- url.searchParams.set("clientID", this.clientID);
392
- url.searchParams.set("chainID", args.chainID.toString());
393
- url.searchParams.set("toAddress", args.toAddress);
394
- url.searchParams.set(
395
- "value",
396
- args.value !== void 0 ? args.value : "0x0"
397
- );
398
- url.searchParams.set(
399
- "data",
400
- args.data !== void 0 ? args.data : "0x"
401
- );
402
- url.searchParams.set("ticketToken", args.ticketToken);
403
- }
404
- openWindow(url);
405
- });
406
- }
143
+ //#endregion
144
+ //#region src/unwallet.ts
145
+ var UnWallet = class UnWallet {
146
+ constructor(args) {
147
+ this.env = args.env;
148
+ this.clientID = args.clientID;
149
+ this.xConnection = args.xConnection;
150
+ }
151
+ static async init(config) {
152
+ const env = config.env ?? "prod";
153
+ return new UnWallet({
154
+ env,
155
+ clientID: config.clientID,
156
+ xConnection: await XConnection.init(getUnWalletConfigByEnv(env).xapi)
157
+ });
158
+ }
159
+ get unWalletConfig() {
160
+ return getUnWalletConfigByEnv(this.env);
161
+ }
162
+ authorize(args) {
163
+ const url = new URL(`${this.unWalletConfig.frontend.baseURL}/${args.isVirtual !== void 0 ? args.isVirtual ? "v" : "" : "v"}authorize`);
164
+ url.searchParams.set("response_type", "id_token");
165
+ url.searchParams.set("response_mode", args.responseMode ?? "fragment");
166
+ url.searchParams.set("client_id", this.clientID);
167
+ url.searchParams.set("scope", "openid");
168
+ url.searchParams.set("redirect_uri", args.redirectURL);
169
+ if (args.nonce !== void 0) url.searchParams.set("nonce", args.nonce);
170
+ if (args.chainID !== void 0) url.searchParams.set("chain_id", args.chainID.toString());
171
+ location.assign(url);
172
+ }
173
+ sign(args) {
174
+ return new Promise((resolve, reject) => {
175
+ if (this.xConnection.readyState !== WebSocket.OPEN) {
176
+ reject(new UWError("CONNECTION_NOT_OPENED"));
177
+ return;
178
+ }
179
+ if (this.xConnection.hasResponseHandler) {
180
+ reject(new UWError("REQUEST_IN_PROGRESS"));
181
+ return;
182
+ }
183
+ const digest = (0, viem.sha256)((0, viem.toBytes)(args.message));
184
+ this.xConnection.setResponseHandler({
185
+ resolve: (resp) => {
186
+ this.xConnection.setResponseHandler(null);
187
+ if (resp.type !== "signature") {
188
+ reject(new UWError("INVALID_RESPONSE", `unexpected response type: ${resp.type}`));
189
+ return;
190
+ }
191
+ resolve({
192
+ digest,
193
+ signature: resp.value
194
+ });
195
+ },
196
+ reject: (err) => {
197
+ this.xConnection.setResponseHandler(null);
198
+ reject(err);
199
+ }
200
+ });
201
+ const url = new URL(`${this.unWalletConfig.frontend.baseURL}/x/sign`);
202
+ url.searchParams.set("connectionID", this.xConnection.id);
203
+ url.searchParams.set("clientID", this.clientID);
204
+ url.searchParams.set("message", args.message);
205
+ url.searchParams.set("ticketToken", args.ticketToken);
206
+ openWindow(url);
207
+ });
208
+ }
209
+ signEIP712TypedData(args) {
210
+ return new Promise((resolve, reject) => {
211
+ if (this.xConnection.readyState !== WebSocket.OPEN) {
212
+ reject(new UWError("CONNECTION_NOT_OPENED"));
213
+ return;
214
+ }
215
+ if (this.xConnection.hasResponseHandler) {
216
+ reject(new UWError("REQUEST_IN_PROGRESS"));
217
+ return;
218
+ }
219
+ const { EIP712Domain: _, ...typedDataTypes } = args.typedData.types;
220
+ const typedData = {
221
+ ...args.typedData,
222
+ types: typedDataTypes
223
+ };
224
+ try {
225
+ (0, viem.validateTypedData)(typedData);
226
+ } catch (e) {
227
+ reject(new UWError("INVALID_REQUEST", `invalid typed data: ${e.message}`));
228
+ return;
229
+ }
230
+ const digest = (0, viem.hashTypedData)(typedData);
231
+ this.xConnection.setResponseHandler({
232
+ resolve: (resp) => {
233
+ this.xConnection.setResponseHandler(null);
234
+ if (resp.type !== "signature") {
235
+ reject(new UWError("INVALID_RESPONSE", `unexpected response type: ${resp.type}`));
236
+ return;
237
+ }
238
+ resolve({
239
+ digest,
240
+ signature: resp.value
241
+ });
242
+ },
243
+ reject: (err) => {
244
+ this.xConnection.setResponseHandler(null);
245
+ reject(err);
246
+ }
247
+ });
248
+ const url = new URL(`${this.unWalletConfig.frontend.baseURL}/x/signEIP712TypedData`);
249
+ url.searchParams.set("connectionID", this.xConnection.id);
250
+ url.searchParams.set("clientID", this.clientID);
251
+ url.searchParams.set("typedData", JSON.stringify(args.typedData));
252
+ url.searchParams.set("ticketToken", args.ticketToken);
253
+ openWindow(url);
254
+ });
255
+ }
256
+ sendTransaction(args) {
257
+ return new Promise((resolve, reject) => {
258
+ if (this.xConnection.readyState !== WebSocket.OPEN) {
259
+ reject(new UWError("CONNECTION_NOT_OPENED"));
260
+ return;
261
+ }
262
+ if (this.xConnection.hasResponseHandler) {
263
+ reject(new UWError("REQUEST_IN_PROGRESS"));
264
+ return;
265
+ }
266
+ if (args.value === void 0 && args.data === void 0) {
267
+ reject(new UWError("INVALID_REQUEST", "either value or data is required"));
268
+ return;
269
+ }
270
+ this.xConnection.setResponseHandler({
271
+ resolve: (resp) => {
272
+ this.xConnection.setResponseHandler(null);
273
+ if (resp.type !== "transactionID") {
274
+ reject(new UWError("INVALID_RESPONSE", `unexpected response type: ${resp.type}`));
275
+ return;
276
+ }
277
+ resolve({ transactionID: resp.value });
278
+ },
279
+ reject: (err) => {
280
+ this.xConnection.setResponseHandler(null);
281
+ reject(err);
282
+ }
283
+ });
284
+ const url = new URL(`${this.unWalletConfig.frontend.baseURL}/x/sendTransaction`);
285
+ url.searchParams.set("connectionID", this.xConnection.id);
286
+ url.searchParams.set("clientID", this.clientID);
287
+ url.searchParams.set("chainID", args.chainID.toString());
288
+ url.searchParams.set("toAddress", args.toAddress);
289
+ url.searchParams.set("value", args.value ?? "0x0");
290
+ url.searchParams.set("data", args.data ?? "0x");
291
+ url.searchParams.set("ticketToken", args.ticketToken);
292
+ openWindow(url);
293
+ });
294
+ }
407
295
  };
408
296
  function openWindow(url) {
409
- const width = screen.width / 2;
410
- const height = screen.height;
411
- const left = screen.width / 4;
412
- const top = 0;
413
- window.open(
414
- url.toString(),
415
- "_blank",
416
- `width=${width},height=${height},left=${left},top=${top}`
417
- );
297
+ const width = screen.width / 2;
298
+ const height = screen.height;
299
+ const left = screen.width / 4;
300
+ window.open(url.toString(), "_blank", `width=${width},height=${height},left=${left},top=0`);
418
301
  }
419
- // Annotate the CommonJS export names for ESM import in node:
420
- 0 && (module.exports = {
421
- UWError,
422
- UnWallet
423
- });
302
+ //#endregion
303
+ exports.UWError = UWError;
304
+ exports.UnWallet = UnWallet;