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