@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.
- 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.js
CHANGED
|
@@ -1,31 +1,204 @@
|
|
|
1
|
-
import {
|
|
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/
|
|
12
|
-
var
|
|
13
|
-
|
|
14
|
-
|
|
15
|
-
|
|
16
|
-
|
|
17
|
-
|
|
18
|
-
|
|
19
|
-
|
|
20
|
-
|
|
21
|
-
|
|
22
|
-
|
|
23
|
-
|
|
24
|
-
|
|
25
|
-
|
|
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
|
-
|
|
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
|
-
|
|
50
|
-
|
|
51
|
-
|
|
52
|
-
|
|
53
|
-
|
|
54
|
-
|
|
55
|
-
|
|
56
|
-
|
|
57
|
-
|
|
58
|
-
|
|
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
|
|
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
|
-
|
|
119
|
-
|
|
120
|
-
|
|
121
|
-
|
|
122
|
-
|
|
123
|
-
|
|
124
|
-
|
|
125
|
-
|
|
126
|
-
|
|
127
|
-
|
|
128
|
-
)
|
|
129
|
-
|
|
130
|
-
|
|
131
|
-
|
|
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
|
-
|
|
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
|
-
|
|
223
|
-
|
|
224
|
-
|
|
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
|
-
|
|
227
|
-
|
|
228
|
-
|
|
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
|
|
243
|
-
|
|
244
|
-
|
|
245
|
-
|
|
246
|
-
|
|
247
|
-
|
|
248
|
-
|
|
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
|
-
|
|
252
|
-
|
|
253
|
-
|
|
254
|
-
|
|
255
|
-
|
|
256
|
-
|
|
257
|
-
|
|
258
|
-
|
|
259
|
-
|
|
260
|
-
|
|
261
|
-
|
|
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/
|
|
287
|
-
|
|
288
|
-
|
|
289
|
-
|
|
290
|
-
|
|
291
|
-
|
|
292
|
-
|
|
293
|
-
|
|
294
|
-
|
|
295
|
-
|
|
296
|
-
|
|
297
|
-
|
|
298
|
-
|
|
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
|
-
|
|
301
|
-
|
|
302
|
-
|
|
303
|
-
|
|
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
|
|
306
|
-
}
|
|
307
|
-
|
|
308
|
-
|
|
309
|
-
|
|
310
|
-
|
|
311
|
-
|
|
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
|
-
|
|
316
|
-
|
|
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
|
-
|
|
320
|
-
|
|
321
|
-
|
|
322
|
-
|
|
323
|
-
}
|
|
324
|
-
|
|
325
|
-
|
|
326
|
-
|
|
327
|
-
|
|
328
|
-
|
|
329
|
-
|
|
330
|
-
|
|
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
|
-
|
|
333
|
-
|
|
612
|
+
const s = await this.client.status();
|
|
613
|
+
return s.connection;
|
|
334
614
|
}
|
|
335
|
-
|
|
336
|
-
|
|
337
|
-
|
|
338
|
-
|
|
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
|
-
|
|
427
|
-
|
|
428
|
-
|
|
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,
|
|
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
|