@canton-network/dapp-sdk 0.9.0 → 0.11.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.
@@ -1,9 +0,0 @@
1
- // Copyright (c) 2025 Digital Asset (Switzerland) GmbH and/or its affiliates. All rights reserved.
2
- // SPDX-License-Identifier: Apache-2.0
3
- import { assertProvider } from '../error.js';
4
- export async function onAccountsChanged(listener) {
5
- assertProvider().on('accountsChanged', listener);
6
- }
7
- export async function onTxChanged(listener) {
8
- assertProvider().on('txChanged', listener);
9
- }
@@ -1,12 +0,0 @@
1
- // Copyright (c) 2025 Digital Asset (Switzerland) GmbH and/or its affiliates. All rights reserved.
2
- // SPDX-License-Identifier: Apache-2.0
3
- import { Provider } from '../provider';
4
- import { injectSpliceProvider } from '@canton-network/core-splice-provider';
5
- import * as storage from '../storage';
6
- export const injectProvider = (discovery) => {
7
- return injectSpliceProvider(new Provider(discovery, storage.getKernelSession()?.sessionToken));
8
- };
9
- // On page load, restore and re-register the listener if needed
10
- const discovery = storage.getKernelDiscovery();
11
- if (discovery)
12
- injectProvider(discovery);
@@ -1,15 +0,0 @@
1
- // Copyright (c) 2025 Digital Asset (Switzerland) GmbH and/or its affiliates. All rights reserved.
2
- // SPDX-License-Identifier: Apache-2.0
3
- import { openKernelUserUI } from '../provider';
4
- import * as storage from '../storage';
5
- export async function open() {
6
- const discovery = storage.getKernelDiscovery();
7
- if (!discovery) {
8
- throw new Error('No previous discovery found');
9
- }
10
- const session = storage.getKernelSession();
11
- if (!session) {
12
- throw new Error('No previous session found');
13
- }
14
- openKernelUserUI(discovery.walletType, session.kernel.userUrl ?? '');
15
- }
@@ -1,64 +0,0 @@
1
- // Copyright (c) 2025 Digital Asset (Switzerland) GmbH and/or its affiliates. All rights reserved.
2
- // SPDX-License-Identifier: Apache-2.0
3
- import { discover } from '@canton-network/core-wallet-ui-components';
4
- import { assertProvider, ErrorCode } from '../error.js';
5
- import * as storage from '../storage';
6
- import { injectProvider } from './index';
7
- import gateways from '../gateways.json';
8
- export async function connect() {
9
- const config = gateways;
10
- return discover(config)
11
- .then(async (result) => {
12
- // Store discovery result and remove previous session
13
- storage.setKernelDiscovery(result);
14
- storage.removeKernelSession();
15
- const provider = injectProvider(result);
16
- const response = await provider.request({
17
- method: 'connect',
18
- });
19
- if (!response.isConnected) {
20
- // TODO: error dialog
21
- console.error('SDK: Not connected', response);
22
- // openKernelUserUI(result.walletType, response.userUrl)
23
- }
24
- else {
25
- console.log('SDK: Store connection', response);
26
- storage.setKernelSession(response);
27
- }
28
- return response;
29
- })
30
- .catch((err) => {
31
- throw {
32
- status: 'error',
33
- error: ErrorCode.Other,
34
- details: err instanceof Error ? err.message : String(err),
35
- };
36
- });
37
- }
38
- export async function status() {
39
- return await assertProvider().request({
40
- method: 'status',
41
- });
42
- }
43
- export async function darsAvailable() {
44
- return await assertProvider().request({
45
- method: 'darsAvailable',
46
- });
47
- }
48
- export async function requestAccounts() {
49
- return await assertProvider().request({
50
- method: 'requestAccounts',
51
- });
52
- }
53
- export async function prepareExecute(params) {
54
- return await assertProvider().request({
55
- method: 'prepareExecute',
56
- params,
57
- });
58
- }
59
- export async function ledgerApi(params) {
60
- return await assertProvider().request({
61
- method: 'ledgerApi',
62
- params,
63
- });
64
- }
package/dist/provider.js DELETED
@@ -1,165 +0,0 @@
1
- // Copyright (c) 2025 Digital Asset (Switzerland) GmbH and/or its affiliates. All rights reserved.
2
- // SPDX-License-Identifier: Apache-2.0
3
- import { ProviderType, } from '@canton-network/core-splice-provider';
4
- import { WalletEvent, } from '@canton-network/core-types';
5
- import { popupHref } from '@canton-network/core-wallet-ui-components';
6
- import { SpliceProviderHttp, SpliceProviderWindow, } from '@canton-network/core-splice-provider';
7
- import buildController from './dapp-api/rpc-gen';
8
- import { ErrorCode } from './error.js';
9
- /**
10
- * The Provider class abstracts over the different types of SpliceProviders (Window and HTTP).
11
- * It selects the appropriate provider based on the wallet type discovered during the connection process.
12
- */
13
- export class Provider {
14
- providerType;
15
- httpProvider;
16
- windowProvider;
17
- constructor({ walletType, url }, sessionToken) {
18
- if (walletType == 'extension') {
19
- this.providerType = ProviderType.WINDOW;
20
- this.windowProvider = new SpliceProviderWindow();
21
- }
22
- else if (walletType == 'remote') {
23
- this.providerType = ProviderType.HTTP;
24
- this.httpProvider = new SpliceProviderHttp(new URL(url), sessionToken);
25
- }
26
- else {
27
- throw new Error(`Unsupported wallet type ${walletType}`);
28
- }
29
- }
30
- getProvider() {
31
- if (this.providerType === ProviderType.WINDOW)
32
- return this.windowProvider;
33
- return this.httpProvider;
34
- }
35
- request(args) {
36
- if (this.providerType === ProviderType.WINDOW)
37
- return this.getProvider().request(args);
38
- const controller = dappController(this.getProvider());
39
- switch (args.method) {
40
- case 'status':
41
- return controller.status();
42
- case 'connect':
43
- return controller.connect();
44
- case 'darsAvailable':
45
- return controller.darsAvailable();
46
- case 'ledgerApi':
47
- return controller.ledgerApi(args.params);
48
- case 'prepareExecute':
49
- return controller.prepareExecute(args.params);
50
- case 'prepareReturn':
51
- return controller.prepareReturn(args.params);
52
- case 'requestAccounts':
53
- return controller.requestAccounts();
54
- case 'onAccountsChanged':
55
- throw new Error('Only for events.');
56
- case 'onTxChanged':
57
- throw new Error('Only for events.');
58
- default:
59
- throw new Error('Unsupported method');
60
- }
61
- }
62
- on(event, listener) {
63
- return this.getProvider().on(event, listener);
64
- }
65
- emit(event, ...args) {
66
- return this.getProvider().emit(event, args);
67
- }
68
- removeListener(event, listenerToRemove) {
69
- return this.getProvider().removeListener(event, listenerToRemove);
70
- }
71
- }
72
- export const openKernelUserUI = (walletType, userUrl) => {
73
- switch (walletType) {
74
- case 'remote':
75
- popupHref(new URL(userUrl));
76
- break;
77
- case 'extension': {
78
- const msg = {
79
- type: WalletEvent.SPLICE_WALLET_EXT_OPEN,
80
- url: userUrl,
81
- };
82
- window.postMessage(msg, '*');
83
- break;
84
- }
85
- }
86
- };
87
- const withTimeout = (reject) => setTimeout(() => {
88
- console.warn('SDK: Timeout waiting for connection');
89
- reject({
90
- status: 'error',
91
- error: ErrorCode.Timeout,
92
- details: 'Timeout waiting for connection',
93
- });
94
- }, 10 * 1000); // 10 seconds
95
- // Remote dApp API Server which wraps the Remote-dApp API Server with promises
96
- export const dappController = (provider) => buildController({
97
- connect: async () => {
98
- const response = await provider.request({
99
- method: 'connect',
100
- });
101
- if (!response.isConnected)
102
- openKernelUserUI('remote', response.userUrl);
103
- const promise = new Promise((resolve, reject) => {
104
- const timeout = withTimeout(reject);
105
- provider.on('onConnected', (event) => {
106
- clearTimeout(timeout);
107
- const result = {
108
- kernel: event.kernel,
109
- isConnected: true,
110
- chainId: event.chainId,
111
- sessionToken: event.sessionToken ?? '',
112
- userUrl: event.userUrl,
113
- };
114
- resolve(result);
115
- });
116
- });
117
- return promise;
118
- },
119
- darsAvailable: async () => {
120
- return provider.request({
121
- method: 'darsAvailable',
122
- });
123
- },
124
- ledgerApi: async (params) => provider.request({
125
- method: 'ledgerApi',
126
- params,
127
- }),
128
- prepareExecute: async (params) => {
129
- const response = await provider.request({
130
- method: 'prepareExecute',
131
- params,
132
- });
133
- if (!response.isConnected)
134
- openKernelUserUI('remote', response.userUrl);
135
- const promise = new Promise((resolve, reject) => {
136
- const timeout = withTimeout(reject);
137
- provider.on('onTxChanged', (event) => {
138
- console.log('SDK: TxChangedEvent', event);
139
- clearTimeout(timeout);
140
- if (event.status === 'executed') {
141
- resolve({
142
- tx: event,
143
- });
144
- }
145
- });
146
- });
147
- return promise;
148
- },
149
- prepareReturn: async (params) => provider.request({
150
- method: 'prepareReturn',
151
- params,
152
- }),
153
- status: async () => {
154
- return provider.request({ method: 'status' });
155
- },
156
- requestAccounts: async () => provider.request({
157
- method: 'requestAccounts',
158
- }),
159
- onAccountsChanged: async () => {
160
- throw new Error('Only for events.');
161
- },
162
- onTxChanged: async () => {
163
- throw new Error('Only for events.');
164
- },
165
- });
package/dist/storage.js DELETED
@@ -1,41 +0,0 @@
1
- // Copyright (c) 2025 Digital Asset (Switzerland) GmbH and/or its affiliates. All rights reserved.
2
- // SPDX-License-Identifier: Apache-2.0
3
- import { DiscoverResult } from '@canton-network/core-types';
4
- var LOCAL_STORAGE;
5
- (function (LOCAL_STORAGE) {
6
- LOCAL_STORAGE["KERNEL_DISCOVERY"] = "splice_wallet_kernel_discovery";
7
- LOCAL_STORAGE["KERNEL_SESSION"] = "splice_wallet_kernel_session";
8
- })(LOCAL_STORAGE || (LOCAL_STORAGE = {}));
9
- export const getKernelDiscovery = () => {
10
- const discovery = localStorage.getItem(LOCAL_STORAGE.KERNEL_DISCOVERY);
11
- if (discovery) {
12
- try {
13
- return DiscoverResult.parse(JSON.parse(discovery));
14
- }
15
- catch (e) {
16
- console.error('Failed to parse stored kernel discovery:', e);
17
- }
18
- }
19
- return undefined;
20
- };
21
- export const setKernelDiscovery = (discovery) => {
22
- localStorage.setItem(LOCAL_STORAGE.KERNEL_DISCOVERY, JSON.stringify(discovery));
23
- };
24
- export const getKernelSession = () => {
25
- const session = localStorage.getItem(LOCAL_STORAGE.KERNEL_SESSION);
26
- if (session) {
27
- try {
28
- return JSON.parse(session);
29
- }
30
- catch (e) {
31
- console.error('Failed to parse stored kernel session:', e);
32
- }
33
- }
34
- return undefined;
35
- };
36
- export const setKernelSession = (session) => {
37
- localStorage.setItem(LOCAL_STORAGE.KERNEL_SESSION, JSON.stringify(session));
38
- };
39
- export const removeKernelSession = () => {
40
- localStorage.removeItem(LOCAL_STORAGE.KERNEL_SESSION);
41
- };