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