@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.
- package/README.md +224 -10
- package/dist/adapter/errors.d.ts +3 -0
- package/dist/adapter/errors.d.ts.map +1 -0
- package/dist/adapter/events.d.ts +3 -0
- package/dist/adapter/events.d.ts.map +1 -0
- package/dist/adapter/extension-adapter.d.ts +22 -0
- package/dist/adapter/extension-adapter.d.ts.map +1 -0
- package/dist/adapter/index.d.ts +7 -0
- package/dist/adapter/index.d.ts.map +1 -0
- package/dist/adapter/remote-adapter.d.ts +35 -0
- package/dist/adapter/remote-adapter.d.ts.map +1 -0
- package/dist/adapter/types.d.ts +3 -0
- package/dist/adapter/types.d.ts.map +1 -0
- package/dist/client.d.ts +40 -0
- package/dist/client.d.ts.map +1 -0
- package/dist/dapp-api/rpc-gen/typings.d.ts +37 -45
- package/dist/dapp-api/rpc-gen/typings.d.ts.map +1 -1
- package/dist/error.d.ts +0 -7
- package/dist/error.d.ts.map +1 -1
- package/dist/index.cjs +586 -284
- package/dist/index.cjs.map +1 -1
- package/dist/index.d.ts +9 -6
- package/dist/index.d.ts.map +1 -1
- package/dist/index.js +547 -281
- package/dist/index.js.map +1 -1
- package/dist/sdk-controller.d.ts +16 -0
- package/dist/sdk-controller.d.ts.map +1 -0
- package/dist/sdk.d.ts +62 -0
- package/dist/sdk.d.ts.map +1 -0
- package/package.json +8 -6
- package/dist/listener.d.ts +0 -2
- package/dist/listener.d.ts.map +0 -1
- package/dist/provider/events.d.ts +0 -9
- package/dist/provider/events.d.ts.map +0 -1
- package/dist/provider/index.d.ts +0 -3
- package/dist/provider/index.d.ts.map +0 -1
- package/dist/provider/open.d.ts +0 -2
- package/dist/provider/open.d.ts.map +0 -1
- package/dist/provider/request.d.ts +0 -15
- package/dist/provider/request.d.ts.map +0 -1
- package/dist/provider.d.ts +0 -31
- 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
|
|
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/
|
|
33
|
-
var
|
|
34
|
-
|
|
35
|
-
|
|
36
|
-
|
|
37
|
-
|
|
38
|
-
|
|
39
|
-
|
|
40
|
-
|
|
41
|
-
|
|
42
|
-
|
|
43
|
-
|
|
44
|
-
|
|
45
|
-
|
|
46
|
-
|
|
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
|
-
|
|
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
|
-
|
|
71
|
-
|
|
72
|
-
|
|
73
|
-
|
|
74
|
-
|
|
75
|
-
|
|
76
|
-
|
|
77
|
-
|
|
78
|
-
|
|
79
|
-
|
|
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
|
|
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
|
-
|
|
140
|
-
|
|
141
|
-
|
|
142
|
-
|
|
143
|
-
|
|
144
|
-
|
|
145
|
-
|
|
146
|
-
|
|
147
|
-
|
|
148
|
-
|
|
149
|
-
)
|
|
150
|
-
|
|
151
|
-
|
|
152
|
-
|
|
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
|
-
|
|
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
|
-
|
|
244
|
-
|
|
245
|
-
|
|
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
|
-
|
|
248
|
-
|
|
249
|
-
|
|
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
|
|
264
|
-
|
|
265
|
-
|
|
266
|
-
|
|
267
|
-
|
|
268
|
-
|
|
269
|
-
|
|
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
|
-
|
|
273
|
-
|
|
274
|
-
|
|
275
|
-
|
|
276
|
-
|
|
277
|
-
|
|
278
|
-
|
|
279
|
-
|
|
280
|
-
|
|
281
|
-
|
|
282
|
-
|
|
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/
|
|
308
|
-
|
|
309
|
-
|
|
310
|
-
|
|
311
|
-
|
|
312
|
-
|
|
313
|
-
|
|
314
|
-
|
|
315
|
-
|
|
316
|
-
|
|
317
|
-
|
|
318
|
-
|
|
319
|
-
|
|
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
|
-
|
|
322
|
-
|
|
323
|
-
|
|
324
|
-
|
|
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
|
|
327
|
-
}
|
|
328
|
-
|
|
329
|
-
|
|
330
|
-
|
|
331
|
-
|
|
332
|
-
|
|
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
|
-
|
|
337
|
-
|
|
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
|
-
|
|
341
|
-
|
|
342
|
-
|
|
343
|
-
|
|
344
|
-
}
|
|
345
|
-
|
|
346
|
-
|
|
347
|
-
|
|
348
|
-
|
|
349
|
-
|
|
350
|
-
|
|
351
|
-
|
|
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
|
-
|
|
354
|
-
|
|
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 (
|
|
442
|
-
|
|
443
|
-
|
|
444
|
-
clearAllLocalState({ closePopup: true });
|
|
635
|
+
async disconnect() {
|
|
636
|
+
if (this.client) {
|
|
637
|
+
await this.client.disconnect();
|
|
638
|
+
this.client = null;
|
|
445
639
|
}
|
|
446
|
-
|
|
447
|
-
|
|
448
|
-
|
|
449
|
-
|
|
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.
|
|
457
|
-
exports.
|
|
759
|
+
exports.ExtensionAdapter = ExtensionAdapter;
|
|
760
|
+
exports.RemoteAdapter = RemoteAdapter;
|
|
458
761
|
exports.connect = connect;
|
|
459
|
-
exports.
|
|
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;
|