@canton-network/dapp-sdk 0.21.2 → 0.22.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 (42) hide show
  1. package/README.md +224 -10
  2. package/dist/adapter/errors.d.ts +3 -0
  3. package/dist/adapter/errors.d.ts.map +1 -0
  4. package/dist/adapter/events.d.ts +3 -0
  5. package/dist/adapter/events.d.ts.map +1 -0
  6. package/dist/adapter/extension-adapter.d.ts +22 -0
  7. package/dist/adapter/extension-adapter.d.ts.map +1 -0
  8. package/dist/adapter/index.d.ts +7 -0
  9. package/dist/adapter/index.d.ts.map +1 -0
  10. package/dist/adapter/remote-adapter.d.ts +35 -0
  11. package/dist/adapter/remote-adapter.d.ts.map +1 -0
  12. package/dist/adapter/types.d.ts +3 -0
  13. package/dist/adapter/types.d.ts.map +1 -0
  14. package/dist/client.d.ts +40 -0
  15. package/dist/client.d.ts.map +1 -0
  16. package/dist/dapp-api/rpc-gen/typings.d.ts +37 -45
  17. package/dist/dapp-api/rpc-gen/typings.d.ts.map +1 -1
  18. package/dist/error.d.ts +0 -7
  19. package/dist/error.d.ts.map +1 -1
  20. package/dist/index.cjs +586 -284
  21. package/dist/index.cjs.map +1 -1
  22. package/dist/index.d.ts +9 -6
  23. package/dist/index.d.ts.map +1 -1
  24. package/dist/index.js +547 -281
  25. package/dist/index.js.map +1 -1
  26. package/dist/sdk-controller.d.ts +16 -0
  27. package/dist/sdk-controller.d.ts.map +1 -0
  28. package/dist/sdk.d.ts +62 -0
  29. package/dist/sdk.d.ts.map +1 -0
  30. package/package.json +8 -6
  31. package/dist/listener.d.ts +0 -2
  32. package/dist/listener.d.ts.map +0 -1
  33. package/dist/provider/events.d.ts +0 -9
  34. package/dist/provider/events.d.ts.map +0 -1
  35. package/dist/provider/index.d.ts +0 -3
  36. package/dist/provider/index.d.ts.map +0 -1
  37. package/dist/provider/open.d.ts +0 -2
  38. package/dist/provider/open.d.ts.map +0 -1
  39. package/dist/provider/request.d.ts +0 -15
  40. package/dist/provider/request.d.ts.map +0 -1
  41. package/dist/provider.d.ts +0 -31
  42. package/dist/provider.d.ts.map +0 -1
package/dist/index.js CHANGED
@@ -1,31 +1,204 @@
1
- import { injectSpliceProvider, ProviderType, SpliceProviderWindow, SpliceProviderHttp } from '@canton-network/core-splice-provider';
2
- import { popup, discover } from '@canton-network/core-wallet-ui-components';
1
+ import { injectProvider, DappAsyncProvider, DappSyncProvider } from '@canton-network/core-provider-dapp';
3
2
  import { WalletEvent, DiscoverResult } from '@canton-network/core-types';
3
+ import { pickWallet, popup } from '@canton-network/core-wallet-ui-components';
4
+ import { DiscoveryClient } from '@canton-network/core-wallet-discovery';
5
+ export { DiscoveryClient, DiscoveryError, EventEmitter, NotConnectedError, SessionExpiredError, TimeoutError, UserRejectedError, WalletNotFoundError, WalletNotInstalledError } from '@canton-network/core-wallet-discovery';
4
6
  import * as coreWalletDappRpcClient from '@canton-network/core-wallet-dapp-rpc-client';
5
7
  export { coreWalletDappRpcClient as dappAPI };
6
8
 
7
9
  var __defProp = Object.defineProperty;
8
10
  var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
9
11
  var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
12
+ var getKernelDiscovery = () => {
13
+ const discovery = localStorage.getItem("splice_wallet_kernel_discovery" /* KERNEL_DISCOVERY */);
14
+ if (discovery) {
15
+ try {
16
+ return DiscoverResult.parse(JSON.parse(discovery));
17
+ } catch (e) {
18
+ console.error("Failed to parse stored kernel discovery:", e);
19
+ }
20
+ }
21
+ return void 0;
22
+ };
23
+ var setKernelDiscovery = (discovery) => {
24
+ localStorage.setItem(
25
+ "splice_wallet_kernel_discovery" /* KERNEL_DISCOVERY */,
26
+ JSON.stringify(discovery)
27
+ );
28
+ };
29
+ var removeKernelDiscovery = () => {
30
+ localStorage.removeItem("splice_wallet_kernel_discovery" /* KERNEL_DISCOVERY */);
31
+ };
32
+ var getKernelSession = () => {
33
+ const session = localStorage.getItem("splice_wallet_kernel_session" /* KERNEL_SESSION */);
34
+ if (session) {
35
+ try {
36
+ return JSON.parse(session);
37
+ } catch (e) {
38
+ console.error("Failed to parse stored kernel session:", e);
39
+ }
40
+ }
41
+ return void 0;
42
+ };
43
+ var setKernelSession = (session) => {
44
+ localStorage.setItem("splice_wallet_kernel_session" /* KERNEL_SESSION */, JSON.stringify(session));
45
+ };
46
+ var removeKernelSession = () => {
47
+ localStorage.removeItem("splice_wallet_kernel_session" /* KERNEL_SESSION */);
48
+ };
10
49
 
11
- // src/error.ts
12
- var ErrorCode = /* @__PURE__ */ ((ErrorCode2) => {
13
- ErrorCode2[ErrorCode2["ProviderNotFound"] = 0] = "ProviderNotFound";
14
- ErrorCode2[ErrorCode2["UserCancelled"] = 1] = "UserCancelled";
15
- ErrorCode2[ErrorCode2["Timeout"] = 2] = "Timeout";
16
- ErrorCode2[ErrorCode2["TransactionFailed"] = 3] = "TransactionFailed";
17
- ErrorCode2[ErrorCode2["Other"] = 4] = "Other";
18
- return ErrorCode2;
19
- })(ErrorCode || {});
20
- var assertProvider = () => {
21
- if (!window.canton) {
22
- throw {
23
- status: "error",
24
- error: 0 /* ProviderNotFound */,
25
- details: "Canton provider not found. Please install the Splice Wallet."
50
+ // src/util.ts
51
+ var clearAllLocalState = ({
52
+ closePopup
53
+ } = {}) => {
54
+ window.canton = void 0;
55
+ removeKernelSession();
56
+ removeKernelDiscovery();
57
+ if (closePopup) {
58
+ popup.close();
59
+ }
60
+ };
61
+
62
+ // src/client.ts
63
+ var DappClient = class {
64
+ constructor(provider, options = {}) {
65
+ __publicField(this, "provider");
66
+ __publicField(this, "options");
67
+ this.provider = provider;
68
+ this.options = options;
69
+ if (options.injectGlobal !== false) {
70
+ injectProvider(provider);
71
+ }
72
+ }
73
+ // ── Provider access ───────────────────────────────────
74
+ getProvider() {
75
+ return this.provider;
76
+ }
77
+ // ── RPC convenience methods ────────────────────────────
78
+ async connect() {
79
+ return this.provider.request({ method: "connect" });
80
+ }
81
+ async status() {
82
+ return this.provider.request({ method: "status" });
83
+ }
84
+ async listAccounts() {
85
+ return this.provider.request({ method: "listAccounts" });
86
+ }
87
+ async prepareExecute(params) {
88
+ return this.provider.request({ method: "prepareExecute", params });
89
+ }
90
+ async prepareExecuteAndWait(params) {
91
+ return this.provider.request({
92
+ method: "prepareExecuteAndWait",
93
+ params
94
+ });
95
+ }
96
+ async ledgerApi(params) {
97
+ return this.provider.request({ method: "ledgerApi", params });
98
+ }
99
+ // ── Event convenience methods ──────────────────────────
100
+ onStatusChanged(listener) {
101
+ this.provider.on("statusChanged", listener);
102
+ }
103
+ onAccountsChanged(listener) {
104
+ this.provider.on("accountsChanged", listener);
105
+ }
106
+ onTxChanged(listener) {
107
+ this.provider.on("txChanged", listener);
108
+ }
109
+ removeOnStatusChanged(listener) {
110
+ this.provider.removeListener("statusChanged", listener);
111
+ }
112
+ removeOnAccountsChanged(listener) {
113
+ this.provider.removeListener(
114
+ "accountsChanged",
115
+ listener
116
+ );
117
+ }
118
+ removeOnTxChanged(listener) {
119
+ this.provider.removeListener("txChanged", listener);
120
+ }
121
+ // ── Open wallet UI ─────────────────────────────────────
122
+ async open() {
123
+ const statusResult = await this.status();
124
+ const userUrl = statusResult.provider.userUrl;
125
+ if (!userUrl) throw new Error("User URL not found in status");
126
+ if (this.options.providerType === "browser") {
127
+ window.postMessage(
128
+ {
129
+ type: WalletEvent.SPLICE_WALLET_EXT_OPEN,
130
+ url: userUrl
131
+ },
132
+ "*"
133
+ );
134
+ } else {
135
+ popup.open(userUrl);
136
+ }
137
+ }
138
+ // ── Disconnect ────────────────────────────────────────
139
+ async disconnect() {
140
+ try {
141
+ await this.provider.request({ method: "disconnect" });
142
+ } finally {
143
+ clearAllLocalState({ closePopup: true });
144
+ }
145
+ }
146
+ };
147
+ var BROWSER_PROVIDER_ID = "browser";
148
+ var EXTENSION_DETECT_TIMEOUT_MS = 2e3;
149
+ var ExtensionAdapter = class {
150
+ constructor() {
151
+ __publicField(this, "providerId", BROWSER_PROVIDER_ID);
152
+ __publicField(this, "name", "Browser Extension");
153
+ __publicField(this, "type", "browser");
154
+ __publicField(this, "icon");
155
+ }
156
+ getInfo() {
157
+ return {
158
+ providerId: this.providerId,
159
+ name: this.name,
160
+ type: this.type,
161
+ description: "Connect via the Splice Wallet browser extension"
26
162
  };
27
163
  }
28
- return window.canton;
164
+ async detect() {
165
+ if (window.canton) return true;
166
+ return new Promise((resolve) => {
167
+ const timeout = setTimeout(() => {
168
+ window.removeEventListener("message", handler);
169
+ resolve(false);
170
+ }, EXTENSION_DETECT_TIMEOUT_MS);
171
+ const handler = (event) => {
172
+ if (event.data?.type === WalletEvent.SPLICE_WALLET_EXT_ACK) {
173
+ clearTimeout(timeout);
174
+ window.removeEventListener("message", handler);
175
+ resolve(true);
176
+ }
177
+ };
178
+ window.addEventListener("message", handler);
179
+ window.postMessage(
180
+ { type: WalletEvent.SPLICE_WALLET_EXT_READY },
181
+ "*"
182
+ );
183
+ });
184
+ }
185
+ provider() {
186
+ return new DappSyncProvider();
187
+ }
188
+ teardown() {
189
+ }
190
+ async restore() {
191
+ if (!window.canton) return null;
192
+ try {
193
+ const provider = new DappSyncProvider();
194
+ const status2 = await provider.request({ method: "status" });
195
+ if (status2.connection.isConnected) {
196
+ return provider;
197
+ }
198
+ } catch {
199
+ }
200
+ return null;
201
+ }
29
202
  };
30
203
 
31
204
  // src/dapp-api/rpc-gen/index.ts
@@ -46,62 +219,16 @@ function buildController(methods) {
46
219
  };
47
220
  }
48
221
  var rpc_gen_default = buildController;
49
- var Provider = class {
50
- constructor({ walletType, url }, session) {
51
- __publicField(this, "providerType");
52
- __publicField(this, "provider");
53
- if (walletType == "extension") {
54
- this.providerType = ProviderType.WINDOW;
55
- this.provider = new SpliceProviderWindow();
56
- } else if (walletType == "remote") {
57
- this.providerType = ProviderType.HTTP;
58
- this.provider = new SpliceProviderHttp(
59
- new URL(url),
60
- session?.accessToken
61
- );
62
- } else {
63
- throw new Error(`Unsupported wallet type ${walletType}`);
64
- }
65
- }
66
- request(args) {
67
- if (this.providerType === ProviderType.WINDOW)
68
- return this.provider.request(args);
69
- const controller = dappController(this.provider);
70
- switch (args.method) {
71
- case "status":
72
- return controller.status();
73
- case "connect":
74
- return controller.connect();
75
- case "disconnect":
76
- return controller.disconnect();
77
- case "ledgerApi":
78
- return controller.ledgerApi(
79
- args.params
80
- );
81
- case "prepareExecute":
82
- return controller.prepareExecute(
83
- args.params
84
- );
85
- case "listAccounts":
86
- return controller.listAccounts();
87
- case "prepareExecuteAndWait":
88
- return controller.prepareExecuteAndWait(
89
- args.params
90
- );
91
- default:
92
- throw new Error("Unsupported method");
93
- }
94
- }
95
- on(event, listener) {
96
- return this.provider.on(event, listener);
97
- }
98
- emit(event, ...args) {
99
- return this.provider.emit(event, args);
100
- }
101
- removeListener(event, listenerToRemove) {
102
- return this.provider.removeListener(event, listenerToRemove);
103
- }
104
- };
222
+
223
+ // src/error.ts
224
+ var ErrorCode = /* @__PURE__ */ ((ErrorCode2) => {
225
+ ErrorCode2[ErrorCode2["ProviderNotFound"] = 0] = "ProviderNotFound";
226
+ ErrorCode2[ErrorCode2["UserCancelled"] = 1] = "UserCancelled";
227
+ ErrorCode2[ErrorCode2["Timeout"] = 2] = "Timeout";
228
+ ErrorCode2[ErrorCode2["TransactionFailed"] = 3] = "TransactionFailed";
229
+ ErrorCode2[ErrorCode2["Other"] = 4] = "Other";
230
+ return ErrorCode2;
231
+ })(ErrorCode || {});
105
232
  var withTimeout = (reject, details, timeoutMs = 10 * 1e3) => setTimeout(() => {
106
233
  console.warn(`SDK: ${details}`);
107
234
  reject({
@@ -110,35 +237,29 @@ var withTimeout = (reject, details, timeoutMs = 10 * 1e3) => setTimeout(() => {
110
237
  details
111
238
  });
112
239
  }, timeoutMs);
113
- var dappController = (provider) => rpc_gen_default({
240
+ var dappSDKController = (provider) => rpc_gen_default({
114
241
  connect: async () => {
115
242
  const response = await provider.request({
116
243
  method: "connect"
117
244
  });
118
- if (response.session) {
119
- return response;
120
- } else {
121
- popup.open(response.userUrl ?? "");
122
- const promise = new Promise(
123
- (resolve, reject) => {
124
- const timeout = withTimeout(
125
- reject,
126
- "Timeout waiting for connection",
127
- 5 * 60 * 1e3
128
- );
129
- provider.on(
130
- "statusChanged",
131
- (event) => {
132
- if (event.isConnected) {
133
- clearTimeout(timeout);
134
- resolve(event);
135
- }
136
- }
137
- );
245
+ popup.open(response.userUrl ?? "");
246
+ const promise = new Promise((resolve, reject) => {
247
+ const timeout = withTimeout(
248
+ reject,
249
+ "Timeout waiting for connection",
250
+ 5 * 60 * 1e3
251
+ );
252
+ provider.on(
253
+ "statusChanged",
254
+ (event) => {
255
+ if (event.connection.isConnected) {
256
+ clearTimeout(timeout);
257
+ resolve(event.connection);
258
+ }
138
259
  }
139
260
  );
140
- return promise;
141
- }
261
+ });
262
+ return promise;
142
263
  },
143
264
  disconnect: async () => {
144
265
  return await provider.request({
@@ -219,52 +340,135 @@ var dappController = (provider) => rpc_gen_default({
219
340
  });
220
341
  }
221
342
  });
222
- var getKernelDiscovery = () => {
223
- const discovery2 = localStorage.getItem("splice_wallet_kernel_discovery" /* KERNEL_DISCOVERY */);
224
- if (discovery2) {
343
+
344
+ // src/adapter/remote-adapter.ts
345
+ var RemoteAdapter = class {
346
+ constructor(config) {
347
+ __publicField(this, "providerId");
348
+ __publicField(this, "name");
349
+ __publicField(this, "type", "remote");
350
+ __publicField(this, "icon");
351
+ __publicField(this, "rpcUrl");
352
+ __publicField(this, "_provider");
353
+ __publicField(this, "description");
354
+ this.providerId = config.providerId ?? `remote:${config.rpcUrl}`;
355
+ this.name = config.name;
356
+ this.rpcUrl = config.rpcUrl;
357
+ this.icon = config.icon;
358
+ this.description = config.description;
359
+ }
360
+ getInfo() {
361
+ return {
362
+ providerId: this.providerId,
363
+ name: this.name,
364
+ type: this.type,
365
+ description: this.description,
366
+ icon: this.icon,
367
+ url: this.rpcUrl
368
+ };
369
+ }
370
+ async detect() {
371
+ return true;
372
+ }
373
+ provider() {
374
+ const remoteProvider = new DappAsyncProvider(
375
+ new URL(this.rpcUrl),
376
+ getKernelSession()?.session?.accessToken
377
+ );
378
+ this._provider = new RemoteMappedProvider(remoteProvider);
379
+ this.setupSessionListeners(this._provider);
380
+ return this._provider;
381
+ }
382
+ teardown() {
383
+ popup.close();
384
+ }
385
+ async restore() {
386
+ const discovery = getKernelDiscovery();
387
+ if (!discovery || discovery.walletType !== "remote") return null;
388
+ if (discovery.url !== this.rpcUrl) return null;
389
+ const session = getKernelSession();
390
+ if (!session?.session) return null;
225
391
  try {
226
- return DiscoverResult.parse(JSON.parse(discovery2));
227
- } catch (e) {
228
- console.error("Failed to parse stored kernel discovery:", e);
392
+ const provider = this.provider();
393
+ const statusResult = await provider.request({ method: "status" });
394
+ if (statusResult.connection.isConnected) {
395
+ return provider;
396
+ }
397
+ } catch {
229
398
  }
399
+ return null;
400
+ }
401
+ setupSessionListeners(provider) {
402
+ provider.on("statusChanged", (event) => {
403
+ console.log("statusChanged", event);
404
+ if (event.connection.isConnected && event.session) {
405
+ console.log("setting kernel session", event);
406
+ setKernelSession(event);
407
+ }
408
+ });
409
+ provider.on("statusChanged", (event) => {
410
+ if (!event.connection.isConnected) {
411
+ clearAllLocalState({ closePopup: true });
412
+ }
413
+ });
414
+ window.addEventListener("message", (event) => {
415
+ if (event.data?.type === WalletEvent.SPLICE_WALLET_LOGOUT) {
416
+ clearAllLocalState({ closePopup: true });
417
+ provider.emit("statusChanged", {
418
+ provider: {
419
+ id: this.providerId,
420
+ providerType: this.type,
421
+ url: this.rpcUrl
422
+ },
423
+ connection: {
424
+ isConnected: false,
425
+ isNetworkConnected: false,
426
+ reason: "Logged out from wallet gateway"
427
+ }
428
+ });
429
+ }
430
+ });
230
431
  }
231
- return void 0;
232
- };
233
- var setKernelDiscovery = (discovery2) => {
234
- localStorage.setItem(
235
- "splice_wallet_kernel_discovery" /* KERNEL_DISCOVERY */,
236
- JSON.stringify(discovery2)
237
- );
238
- };
239
- var removeKernelDiscovery = () => {
240
- localStorage.removeItem("splice_wallet_kernel_discovery" /* KERNEL_DISCOVERY */);
241
432
  };
242
- var getKernelSession = () => {
243
- const session = localStorage.getItem("splice_wallet_kernel_session" /* KERNEL_SESSION */);
244
- if (session) {
245
- try {
246
- return JSON.parse(session);
247
- } catch (e) {
248
- console.error("Failed to parse stored kernel session:", e);
433
+ var RemoteMappedProvider = class {
434
+ constructor(remoteProvider) {
435
+ this.remoteProvider = remoteProvider;
436
+ }
437
+ request(args) {
438
+ const controller = dappSDKController(this.remoteProvider);
439
+ switch (args.method) {
440
+ case "status":
441
+ return controller.status();
442
+ case "connect":
443
+ return controller.connect();
444
+ case "disconnect":
445
+ return controller.disconnect();
446
+ case "ledgerApi":
447
+ return controller.ledgerApi(args.params);
448
+ case "prepareExecute":
449
+ return controller.prepareExecute(args.params);
450
+ case "listAccounts":
451
+ return controller.listAccounts();
452
+ case "prepareExecuteAndWait":
453
+ return controller.prepareExecuteAndWait(args.params);
454
+ case "getPrimaryAccount":
455
+ return controller.getPrimaryAccount();
456
+ default:
457
+ throw new Error("Unsupported method");
249
458
  }
250
459
  }
251
- return void 0;
252
- };
253
- var setKernelSession = (session) => {
254
- localStorage.setItem("splice_wallet_kernel_session" /* KERNEL_SESSION */, JSON.stringify(session));
255
- };
256
- var removeKernelSession = () => {
257
- localStorage.removeItem("splice_wallet_kernel_session" /* KERNEL_SESSION */);
258
- };
259
-
260
- // src/provider/index.ts
261
- var injectProvider = (discovery2) => {
262
- return injectSpliceProvider(
263
- new Provider(discovery2, getKernelSession()?.session)
264
- );
460
+ on(event, listener) {
461
+ this.remoteProvider.on(event, listener);
462
+ return this;
463
+ }
464
+ emit(event, ...args) {
465
+ return this.remoteProvider.emit(event, ...args);
466
+ }
467
+ removeListener(event, listenerToRemove) {
468
+ this.remoteProvider.removeListener(event, listenerToRemove);
469
+ return this;
470
+ }
265
471
  };
266
- var discovery = getKernelDiscovery();
267
- if (discovery) injectProvider(discovery);
268
472
 
269
473
  // src/gateways.json
270
474
  var gateways_default = [
@@ -273,163 +477,225 @@ var gateways_default = [
273
477
  rpcUrl: "http://localhost:3030/api/v0/dapp"
274
478
  }
275
479
  ];
276
- var clearAllLocalState = ({
277
- closePopup
278
- } = {}) => {
279
- removeKernelSession();
280
- removeKernelDiscovery();
281
- if (closePopup) {
282
- popup.close();
283
- }
284
- };
285
480
 
286
- // src/provider/request.ts
287
- async function connect(options) {
288
- const { defaultGateways = gateways_default, additionalGateways = [] } = options || {};
289
- const verifiedGateways = [
290
- ...defaultGateways,
291
- ...additionalGateways
292
- ];
293
- return discover(verifiedGateways).then(async (result) => {
294
- clearAllLocalState();
295
- setKernelDiscovery(result);
296
- const provider = injectProvider(result);
297
- const response = await provider.request({
298
- method: "connect"
481
+ // src/sdk.ts
482
+ var DappSDK = class {
483
+ constructor(options) {
484
+ __publicField(this, "RECENT_GATEWAYS_KEY", "splice_wallet_picker_recent");
485
+ __publicField(this, "walletPicker");
486
+ __publicField(this, "discovery", null);
487
+ __publicField(this, "client", null);
488
+ __publicField(this, "initPromise", null);
489
+ __publicField(this, "dynamicAdapterIds", /* @__PURE__ */ new Set());
490
+ this.walletPicker = options?.walletPicker ?? pickWallet;
491
+ }
492
+ async registerAdapters(discovery, adapters) {
493
+ if (!adapters?.length) return;
494
+ const existingIds = new Set(
495
+ discovery.listAdapters().map((a) => a.providerId)
496
+ );
497
+ for (const adapter of adapters) {
498
+ const id = adapter.providerId;
499
+ if (existingIds.has(id)) continue;
500
+ if (await adapter.detect()) {
501
+ discovery.registerAdapter(adapter);
502
+ existingIds.add(id);
503
+ }
504
+ }
505
+ }
506
+ async ensureDiscovery(config) {
507
+ const defaultAdapters = config?.defaultAdapters ?? createDefaultAdapters(gateways_default);
508
+ if (this.discovery) {
509
+ await this.registerAdapters(this.discovery, defaultAdapters);
510
+ await this.registerAdapters(
511
+ this.discovery,
512
+ config?.additionalAdapters
513
+ );
514
+ return this.discovery;
515
+ }
516
+ const initialAdapters = await this.collectDetectedAdapters([
517
+ ...defaultAdapters,
518
+ ...config?.additionalAdapters ?? []
519
+ ]);
520
+ this.discovery = await DiscoveryClient.create({
521
+ walletPicker: this.walletPicker,
522
+ adapters: initialAdapters
299
523
  });
300
- if (response.session) {
301
- setKernelSession(response);
302
- } else {
303
- console.warn("SDK: Connected without session", response);
524
+ const session = this.discovery.getActiveSession();
525
+ if (session) {
526
+ const providerType = session.adapter.getInfo().type;
527
+ this.client = new DappClient(session.provider, { providerType });
304
528
  }
305
- return response;
306
- }).catch((err) => {
307
- let details = "";
308
- if (typeof err === "string") {
309
- details = err;
310
- } else {
311
- details = JSON.stringify(err);
312
- if (err instanceof Error) {
313
- details = err.message;
529
+ return this.discovery;
530
+ }
531
+ async collectDetectedAdapters(adapters) {
532
+ const detected = [];
533
+ for (const adapter of adapters) {
534
+ if (await adapter.detect()) {
535
+ detected.push(adapter);
314
536
  }
315
- if ("message" in err) {
316
- details = err.message;
537
+ }
538
+ return detected;
539
+ }
540
+ async ensureInit(config) {
541
+ if (!this.initPromise) {
542
+ this.initPromise = this.ensureDiscovery(config).then(
543
+ () => void 0
544
+ );
545
+ }
546
+ await this.initPromise;
547
+ }
548
+ saveRecentGateway(name, rpcUrl) {
549
+ try {
550
+ const raw = localStorage.getItem(this.RECENT_GATEWAYS_KEY);
551
+ const recent = raw ? JSON.parse(raw) : [];
552
+ const filtered = recent.filter((r) => r.rpcUrl !== rpcUrl);
553
+ filtered.unshift({ name, rpcUrl });
554
+ localStorage.setItem(
555
+ this.RECENT_GATEWAYS_KEY,
556
+ JSON.stringify(filtered.slice(0, 5))
557
+ );
558
+ } catch {
559
+ }
560
+ }
561
+ requireClient() {
562
+ if (!this.client)
563
+ throw new Error("Not connected \u2014 call connect() first");
564
+ return this.client;
565
+ }
566
+ async connect(options) {
567
+ await this.ensureInit(options);
568
+ const discovery = this.discovery;
569
+ await this.registerAdapters(discovery, options?.defaultAdapters);
570
+ await this.registerAdapters(discovery, options?.additionalAdapters);
571
+ clearAllLocalState();
572
+ const entries = discovery.listAdapters().filter((a) => !this.dynamicAdapterIds.has(a.providerId)).map((a) => {
573
+ const info2 = a.getInfo();
574
+ return {
575
+ providerId: info2.providerId,
576
+ name: info2.name,
577
+ type: info2.type,
578
+ description: info2.description,
579
+ icon: info2.icon,
580
+ url: info2.url
581
+ };
582
+ });
583
+ const picked = await this.walletPicker(entries);
584
+ let targetId = picked.providerId;
585
+ if (picked.type === "remote" && picked.url) {
586
+ const existing = discovery.listAdapters().find((a) => a.providerId === targetId);
587
+ if (!existing) {
588
+ const adapter = new RemoteAdapter({
589
+ name: picked.name,
590
+ rpcUrl: picked.url
591
+ });
592
+ discovery.registerAdapter(adapter);
593
+ this.dynamicAdapterIds.add(adapter.providerId);
594
+ targetId = adapter.providerId;
317
595
  }
318
596
  }
319
- throw {
320
- status: "error",
321
- error: 4 /* Other */,
322
- details
323
- };
324
- });
325
- }
326
- async function disconnect() {
327
- try {
328
- const provider = assertProvider();
329
- await provider.request({
330
- method: "disconnect"
597
+ await discovery.connect(targetId);
598
+ const session = discovery.getActiveSession();
599
+ if (!session) {
600
+ throw new Error("Connection succeeded but no active session");
601
+ }
602
+ const info = session.adapter.getInfo();
603
+ if (info.type === "remote" && info.url) {
604
+ setKernelDiscovery({ walletType: "remote", url: info.url });
605
+ this.saveRecentGateway(info.name, info.url);
606
+ } else if (info.type === "browser") {
607
+ setKernelDiscovery({ walletType: "extension" });
608
+ }
609
+ this.client = new DappClient(session.provider, {
610
+ providerType: info.type
331
611
  });
332
- } finally {
333
- clearAllLocalState({ closePopup: true });
612
+ const s = await this.client.status();
613
+ return s.connection;
334
614
  }
335
- return null;
336
- }
337
- async function status() {
338
- return await assertProvider().request({
339
- method: "status"
340
- });
341
- }
342
- async function listAccounts() {
343
- return await assertProvider().request({
344
- method: "listAccounts"
345
- });
346
- }
347
- async function prepareExecute(params) {
348
- return await assertProvider().request({
349
- method: "prepareExecute",
350
- params
351
- });
352
- }
353
- async function prepareExecuteAndWait(params) {
354
- return await assertProvider().request({
355
- method: "prepareExecuteAndWait",
356
- params
357
- });
358
- }
359
- async function ledgerApi(params) {
360
- return await assertProvider().request({
361
- method: "ledgerApi",
362
- params
363
- });
364
- }
365
-
366
- // src/provider/events.ts
367
- async function onAccountsChanged(listener) {
368
- assertProvider().on(
369
- "accountsChanged",
370
- listener
371
- );
372
- }
373
- async function onTxChanged(listener) {
374
- assertProvider().on("txChanged", listener);
375
- }
376
- async function onStatusChanged(listener) {
377
- assertProvider().on("statusChanged", listener);
378
- }
379
- async function removeOnAccountsChanged(listener) {
380
- assertProvider().removeListener(
381
- "accountsChanged",
382
- listener
383
- );
384
- }
385
- async function removeOnTxChanged(listener) {
386
- assertProvider().removeListener(
387
- "txChanged",
388
- listener
389
- );
390
- }
391
- async function removeOnStatusChanged(listener) {
392
- assertProvider().removeListener(
393
- "statusChanged",
394
- listener
395
- );
396
- }
397
- async function open() {
398
- const discovery2 = getKernelDiscovery();
399
- if (!discovery2) {
400
- throw new Error("No previous discovery found");
401
- }
402
- const session = getKernelSession();
403
- if (!session) {
404
- throw new Error("No previous session found");
405
- }
406
- const userUrl = session.userUrl ?? session.kernel.userUrl;
407
- if (!userUrl) {
408
- throw new Error("User URL not found in session");
409
- }
410
- if (discovery2.walletType === "remote") {
411
- popup.open(userUrl);
412
- } else if (discovery2.walletType === "extension") {
413
- const msg = {
414
- type: WalletEvent.SPLICE_WALLET_EXT_OPEN,
415
- url: userUrl
416
- };
417
- window.postMessage(msg, "*");
418
- }
419
- }
420
- if (window.canton) {
421
- onStatusChanged(async (event) => {
422
- if (!event.isConnected) {
423
- clearAllLocalState({ closePopup: true });
615
+ async disconnect() {
616
+ if (this.client) {
617
+ await this.client.disconnect();
618
+ this.client = null;
424
619
  }
425
- });
426
- window.addEventListener("message", (event) => {
427
- if (event.data?.type === WalletEvent.SPLICE_WALLET_LOGOUT) {
428
- clearAllLocalState({ closePopup: true });
620
+ if (this.discovery) {
621
+ try {
622
+ await this.discovery.disconnect();
623
+ } catch {
624
+ }
429
625
  }
626
+ return null;
627
+ }
628
+ async status() {
629
+ await this.ensureInit();
630
+ return this.requireClient().status();
631
+ }
632
+ async listAccounts() {
633
+ return this.requireClient().listAccounts();
634
+ }
635
+ async prepareExecute(params) {
636
+ return this.requireClient().prepareExecute(params);
637
+ }
638
+ async prepareExecuteAndWait(params) {
639
+ return this.requireClient().prepareExecuteAndWait(params);
640
+ }
641
+ async ledgerApi(params) {
642
+ return this.requireClient().ledgerApi(params);
643
+ }
644
+ async open() {
645
+ return this.requireClient().open();
646
+ }
647
+ async onStatusChanged(listener) {
648
+ this.requireClient().onStatusChanged(listener);
649
+ }
650
+ async onAccountsChanged(listener) {
651
+ this.requireClient().onAccountsChanged(listener);
652
+ }
653
+ async onTxChanged(listener) {
654
+ this.requireClient().onTxChanged(listener);
655
+ }
656
+ async removeOnStatusChanged(listener) {
657
+ if (!this.client) return;
658
+ this.client.removeOnStatusChanged(listener);
659
+ }
660
+ async removeOnAccountsChanged(listener) {
661
+ if (!this.client) return;
662
+ this.client.removeOnAccountsChanged(listener);
663
+ }
664
+ async removeOnTxChanged(listener) {
665
+ if (!this.client) return;
666
+ this.client.removeOnTxChanged(listener);
667
+ }
668
+ };
669
+ var sdk = new DappSDK();
670
+ var connect = (options) => {
671
+ const defaultAdapters = options?.defaultAdapters ?? createDefaultAdapters(gateways_default);
672
+ return sdk.connect({
673
+ ...options,
674
+ defaultAdapters
430
675
  });
676
+ };
677
+ var disconnect = () => sdk.disconnect();
678
+ var status = () => sdk.status();
679
+ var listAccounts = () => sdk.listAccounts();
680
+ var prepareExecute = (params) => sdk.prepareExecute(params);
681
+ var prepareExecuteAndWait = (params) => sdk.prepareExecuteAndWait(params);
682
+ var ledgerApi = (params) => sdk.ledgerApi(params);
683
+ var open = () => sdk.open();
684
+ var onStatusChanged = (listener) => sdk.onStatusChanged(listener);
685
+ var onAccountsChanged = (listener) => sdk.onAccountsChanged(listener);
686
+ var onTxChanged = (listener) => sdk.onTxChanged(listener);
687
+ var removeOnStatusChanged = (listener) => sdk.removeOnStatusChanged(listener);
688
+ var removeOnAccountsChanged = (listener) => sdk.removeOnAccountsChanged(listener);
689
+ var removeOnTxChanged = (listener) => sdk.removeOnTxChanged(listener);
690
+ function createDefaultAdapters(defaultGatewayConfigs) {
691
+ return [
692
+ new ExtensionAdapter(),
693
+ ...defaultGatewayConfigs.map(
694
+ (config) => new RemoteAdapter(config)
695
+ )
696
+ ];
431
697
  }
432
698
 
433
- export { ErrorCode, Provider, assertProvider, connect, dappController, disconnect, injectProvider, ledgerApi, listAccounts, onAccountsChanged, onStatusChanged, onTxChanged, open, prepareExecute, prepareExecuteAndWait, removeOnAccountsChanged, removeOnStatusChanged, removeOnTxChanged, status };
699
+ export { DappClient, DappSDK, ErrorCode, ExtensionAdapter, RemoteAdapter, connect, sdk as dappSDK, disconnect, ledgerApi, listAccounts, onAccountsChanged, onStatusChanged, onTxChanged, open, prepareExecute, prepareExecuteAndWait, removeOnAccountsChanged, removeOnStatusChanged, removeOnTxChanged, status };
434
700
  //# sourceMappingURL=index.js.map
435
701
  //# sourceMappingURL=index.js.map