unwallet-client-sdk 0.18.2 → 0.19.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 +293 -411
  2. package/dist/index.d.cts +80 -75
  3. package/dist/index.d.ts +80 -75
  4. package/dist/index.js +291 -388
  5. package/package.json +14 -9
package/dist/index.cjs CHANGED
@@ -1,423 +1,305 @@
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 });
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
+ }
9
13
  };
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;
14
+ //#endregion
15
+ //#region src/config.ts
16
+ const UNWALLET_CONFIG_PROD = {
17
+ frontend: { baseURL: "https://id.unwallet.world" },
18
+ xapi: {
19
+ url: "wss://xapi.id.unwallet.world",
20
+ connectionTimeout: 1e4
21
+ }
17
22
  };
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
- }
23
+ const UNWALLET_CONFIG_DEV = {
24
+ frontend: { baseURL: "http://localhost:4200" },
25
+ xapi: {
26
+ url: "wss://xapi.id.test.unwallet.dev",
27
+ connectionTimeout: 1e4
28
+ }
59
29
  };
60
30
  function getUnWalletConfigByEnv(env) {
61
- switch (env) {
62
- case "prod":
63
- return UNWALLET_CONFIG_PROD;
64
- case "dev":
65
- return UNWALLET_CONFIG_DEV;
66
- }
31
+ switch (env) {
32
+ case "prod": return UNWALLET_CONFIG_PROD;
33
+ case "dev": return UNWALLET_CONFIG_DEV;
34
+ }
67
35
  }
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"
36
+ //#endregion
37
+ //#region src/x.ts
38
+ const VALID_X_RESPONSE_TYPES = [
39
+ "connectionID",
40
+ "signature",
41
+ "transactionID",
42
+ "error"
76
43
  ];
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
- }
44
+ var XConnection = class XConnection {
45
+ constructor(args) {
46
+ this.responseHandler = null;
47
+ this.socket = args.socket;
48
+ this.id = args.id;
49
+ this.initListeners();
50
+ }
51
+ initListeners() {
52
+ this.socket.onopen = null;
53
+ this.socket.onmessage = (event) => {
54
+ if (this.responseHandler === null) return;
55
+ let resp;
56
+ {
57
+ const result = safeParseMessageEventDataToXResponse(event.data);
58
+ if (!result.success) {
59
+ this.responseHandler.reject(result.error);
60
+ return;
61
+ }
62
+ resp = result.data;
63
+ }
64
+ switch (resp.type) {
65
+ case "error":
66
+ switch (resp.value) {
67
+ case "rejected":
68
+ this.responseHandler.reject(new UWError("REQUEST_REJECTED"));
69
+ break;
70
+ default: this.responseHandler.reject(new UWError("INVALID_RESPONSE", `unexpected error response value: ${resp.value}`));
71
+ }
72
+ break;
73
+ default: this.responseHandler.resolve(resp);
74
+ }
75
+ };
76
+ this.socket.onerror = null;
77
+ this.socket.onclose = (event) => {
78
+ if (this.responseHandler === null) return;
79
+ this.responseHandler.reject(new UWError("CONNECTION_CLOSED", event.reason));
80
+ };
81
+ }
82
+ get readyState() {
83
+ return this.socket.readyState;
84
+ }
85
+ get hasResponseHandler() {
86
+ return this.responseHandler !== null;
87
+ }
88
+ setResponseHandler(handler) {
89
+ this.responseHandler = handler;
90
+ }
91
+ static async init(config) {
92
+ const socket = new WebSocket(config.url);
93
+ return new XConnection({
94
+ socket,
95
+ id: await new Promise((resolve, reject) => {
96
+ setInterval(() => reject(new UWError("CONNECTION_TIMEOUT")), config.connectionTimeout);
97
+ socket.onopen = () => socket.send(JSON.stringify({ action: "getConnectionID" }));
98
+ socket.onmessage = (event) => {
99
+ let resp;
100
+ {
101
+ const result = safeParseMessageEventDataToXResponse(event.data);
102
+ if (!result.success) {
103
+ reject(result.error);
104
+ return;
105
+ }
106
+ resp = result.data;
107
+ }
108
+ if (resp.type !== "connectionID") {
109
+ reject(new UWError("INVALID_RESPONSE", `unexpected response type: ${resp.type}`));
110
+ return;
111
+ }
112
+ resolve(resp.value);
113
+ };
114
+ socket.onerror = () => reject(new UWError("CONNECTION_FAILED"));
115
+ socket.onclose = (event) => reject(new UWError("CONNECTION_CLOSED", event.reason));
116
+ })
117
+ });
118
+ }
171
119
  };
172
120
  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
- };
121
+ const result = zod.z.string().refine((val) => {
122
+ try {
123
+ JSON.parse(val);
124
+ } catch (e) {
125
+ return false;
126
+ }
127
+ return true;
128
+ }, {
129
+ abort: true,
130
+ message: "Invalid JSON string"
131
+ }).transform((val) => JSON.parse(val)).pipe(zod.z.object({
132
+ type: zod.z.enum(VALID_X_RESPONSE_TYPES),
133
+ value: zod.z.string()
134
+ })).safeParse(data);
135
+ if (!result.success) return {
136
+ success: false,
137
+ error: new UWError("INVALID_RESPONSE", `invalid message event data: ${result.error.message}`)
138
+ };
139
+ return {
140
+ success: true,
141
+ data: result.data
142
+ };
205
143
  }
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
- }
144
+ //#endregion
145
+ //#region src/unwallet.ts
146
+ var UnWallet = class UnWallet {
147
+ constructor(args) {
148
+ this.env = args.env;
149
+ this.clientID = args.clientID;
150
+ this.xConnection = args.xConnection;
151
+ }
152
+ static async init(config) {
153
+ const env = config.env !== void 0 ? config.env : "prod";
154
+ return new UnWallet({
155
+ env,
156
+ clientID: config.clientID,
157
+ xConnection: await XConnection.init(getUnWalletConfigByEnv(env).xapi)
158
+ });
159
+ }
160
+ get unWalletConfig() {
161
+ return getUnWalletConfigByEnv(this.env);
162
+ }
163
+ authorize(args) {
164
+ const url = new URL(`${this.unWalletConfig.frontend.baseURL}/${args.isVirtual !== void 0 ? args.isVirtual ? "v" : "" : "v"}authorize`);
165
+ url.searchParams.set("response_type", "id_token");
166
+ url.searchParams.set("response_mode", args.responseMode !== void 0 ? args.responseMode : "fragment");
167
+ url.searchParams.set("client_id", this.clientID);
168
+ url.searchParams.set("scope", "openid");
169
+ url.searchParams.set("redirect_uri", args.redirectURL);
170
+ if (args.nonce !== void 0) url.searchParams.set("nonce", args.nonce);
171
+ if (args.chainID !== void 0) url.searchParams.set("chain_id", args.chainID.toString());
172
+ location.assign(url);
173
+ }
174
+ sign(args) {
175
+ return new Promise((resolve, reject) => {
176
+ if (this.xConnection.readyState !== WebSocket.OPEN) {
177
+ reject(new UWError("CONNECTION_NOT_OPENED"));
178
+ return;
179
+ }
180
+ if (this.xConnection.hasResponseHandler) {
181
+ reject(new UWError("REQUEST_IN_PROGRESS"));
182
+ return;
183
+ }
184
+ const digest = (0, viem.sha256)((0, viem.toBytes)(args.message));
185
+ this.xConnection.setResponseHandler({
186
+ resolve: (resp) => {
187
+ this.xConnection.setResponseHandler(null);
188
+ if (resp.type !== "signature") {
189
+ reject(new UWError("INVALID_RESPONSE", `unexpected response type: ${resp.type}`));
190
+ return;
191
+ }
192
+ resolve({
193
+ digest,
194
+ signature: resp.value
195
+ });
196
+ },
197
+ reject: (err) => {
198
+ this.xConnection.setResponseHandler(null);
199
+ reject(err);
200
+ }
201
+ });
202
+ const url = new URL(`${this.unWalletConfig.frontend.baseURL}/x/sign`);
203
+ url.searchParams.set("connectionID", this.xConnection.id);
204
+ url.searchParams.set("clientID", this.clientID);
205
+ url.searchParams.set("message", args.message);
206
+ url.searchParams.set("ticketToken", args.ticketToken);
207
+ openWindow(url);
208
+ });
209
+ }
210
+ signEIP712TypedData(args) {
211
+ return new Promise((resolve, reject) => {
212
+ if (this.xConnection.readyState !== WebSocket.OPEN) {
213
+ reject(new UWError("CONNECTION_NOT_OPENED"));
214
+ return;
215
+ }
216
+ if (this.xConnection.hasResponseHandler) {
217
+ reject(new UWError("REQUEST_IN_PROGRESS"));
218
+ return;
219
+ }
220
+ const { EIP712Domain: _, ...typedDataTypes } = args.typedData.types;
221
+ const typedData = {
222
+ ...args.typedData,
223
+ types: typedDataTypes
224
+ };
225
+ try {
226
+ (0, viem.validateTypedData)(typedData);
227
+ } catch (e) {
228
+ reject(new UWError("INVALID_REQUEST", `invalid typed data: ${e.message}`));
229
+ return;
230
+ }
231
+ const digest = (0, viem.hashTypedData)(typedData);
232
+ this.xConnection.setResponseHandler({
233
+ resolve: (resp) => {
234
+ this.xConnection.setResponseHandler(null);
235
+ if (resp.type !== "signature") {
236
+ reject(new UWError("INVALID_RESPONSE", `unexpected response type: ${resp.type}`));
237
+ return;
238
+ }
239
+ resolve({
240
+ digest,
241
+ signature: resp.value
242
+ });
243
+ },
244
+ reject: (err) => {
245
+ this.xConnection.setResponseHandler(null);
246
+ reject(err);
247
+ }
248
+ });
249
+ const url = new URL(`${this.unWalletConfig.frontend.baseURL}/x/signEIP712TypedData`);
250
+ url.searchParams.set("connectionID", this.xConnection.id);
251
+ url.searchParams.set("clientID", this.clientID);
252
+ url.searchParams.set("typedData", JSON.stringify(args.typedData));
253
+ url.searchParams.set("ticketToken", args.ticketToken);
254
+ openWindow(url);
255
+ });
256
+ }
257
+ sendTransaction(args) {
258
+ return new Promise((resolve, reject) => {
259
+ if (this.xConnection.readyState !== WebSocket.OPEN) {
260
+ reject(new UWError("CONNECTION_NOT_OPENED"));
261
+ return;
262
+ }
263
+ if (this.xConnection.hasResponseHandler) {
264
+ reject(new UWError("REQUEST_IN_PROGRESS"));
265
+ return;
266
+ }
267
+ if (args.value === void 0 && args.data === void 0) {
268
+ reject(new UWError("INVALID_REQUEST", "either value or data is required"));
269
+ return;
270
+ }
271
+ this.xConnection.setResponseHandler({
272
+ resolve: (resp) => {
273
+ this.xConnection.setResponseHandler(null);
274
+ if (resp.type !== "transactionID") {
275
+ reject(new UWError("INVALID_RESPONSE", `unexpected response type: ${resp.type}`));
276
+ return;
277
+ }
278
+ resolve({ transactionID: resp.value });
279
+ },
280
+ reject: (err) => {
281
+ this.xConnection.setResponseHandler(null);
282
+ reject(err);
283
+ }
284
+ });
285
+ const url = new URL(`${this.unWalletConfig.frontend.baseURL}/x/sendTransaction`);
286
+ url.searchParams.set("connectionID", this.xConnection.id);
287
+ url.searchParams.set("clientID", this.clientID);
288
+ url.searchParams.set("chainID", args.chainID.toString());
289
+ url.searchParams.set("toAddress", args.toAddress);
290
+ url.searchParams.set("value", args.value !== void 0 ? args.value : "0x0");
291
+ url.searchParams.set("data", args.data !== void 0 ? args.data : "0x");
292
+ url.searchParams.set("ticketToken", args.ticketToken);
293
+ openWindow(url);
294
+ });
295
+ }
407
296
  };
408
297
  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
- );
298
+ const width = screen.width / 2;
299
+ const height = screen.height;
300
+ const left = screen.width / 4;
301
+ window.open(url.toString(), "_blank", `width=${width},height=${height},left=${left},top=0`);
418
302
  }
419
- // Annotate the CommonJS export names for ESM import in node:
420
- 0 && (module.exports = {
421
- UWError,
422
- UnWallet
423
- });
303
+ //#endregion
304
+ exports.UWError = UWError;
305
+ exports.UnWallet = UnWallet;