@canton-network/wallet-gateway-remote 0.8.0 → 0.9.0

package/dist/config/Config.d.ts

@@ -2,15 +2,27 @@ import { z } from 'zod';
 export declare const kernelInfoSchema: z.ZodObject<{
     id: z.ZodString;
     clientType: z.ZodUnion<readonly [z.ZodLiteral<"browser">, z.ZodLiteral<"desktop">, z.ZodLiteral<"mobile">, z.ZodLiteral<"remote">]>;
-    url: z.ZodString;
-    userUrl: z.ZodString;
+}, z.core.$strip>;
+export declare const serverConfigSchema: z.ZodObject<{
+    host: z.ZodString;
+    port: z.ZodNumber;
+    tls: z.ZodBoolean;
+    dappPath: z.ZodDefault<z.ZodString>;
+    userPath: z.ZodDefault<z.ZodString>;
+    allowedOrigins: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<"*">, z.ZodArray<z.ZodString>]>>;
 }, z.core.$strip>;
 export declare const configSchema: z.ZodObject<{
     kernel: z.ZodObject<{
         id: z.ZodString;
         clientType: z.ZodUnion<readonly [z.ZodLiteral<"browser">, z.ZodLiteral<"desktop">, z.ZodLiteral<"mobile">, z.ZodLiteral<"remote">]>;
-        url: z.ZodString;
-        userUrl: z.ZodString;
+    }, z.core.$strip>;
+    server: z.ZodObject<{
+        host: z.ZodString;
+        port: z.ZodNumber;
+        tls: z.ZodBoolean;
+        dappPath: z.ZodDefault<z.ZodString>;
+        userPath: z.ZodDefault<z.ZodString>;
+        allowedOrigins: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<"*">, z.ZodArray<z.ZodString>]>>;
     }, z.core.$strip>;
     store: z.ZodObject<{
         connection: z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -102,5 +114,6 @@ export declare const configSchema: z.ZodObject<{
     }, z.core.$strip>;
 }, z.core.$strip>;
 export type KernelInfo = z.infer<typeof kernelInfoSchema>;
+export type ServerConfig = z.infer<typeof serverConfigSchema>;
 export type Config = z.infer<typeof configSchema>;
 //# sourceMappingURL=Config.d.ts.map

package/dist/config/Config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Config.d.ts","sourceRoot":"","sources":["../../src/config/Config.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,gBAAgB;;;;;iBAU3B,CAAA;AAEF,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAIvB,CAAA;AAEF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AACzD,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA"}
+{"version":3,"file":"Config.d.ts","sourceRoot":"","sources":["../../src/config/Config.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,gBAAgB;;;iBAQ3B,CAAA;AAEF,eAAO,MAAM,kBAAkB;;;;;;;iBAO7B,CAAA;AAEF,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAKvB,CAAA;AAEF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AACzD,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAC7D,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA"}

package/dist/config/Config.js

@@ -11,11 +11,18 @@ export const kernelInfoSchema = z.object({
         z.literal('mobile'),
         z.literal('remote'),
     ]),
-    url: z.string().url(),
-    userUrl: z.string().url(),
+});
+export const serverConfigSchema = z.object({
+    host: z.string(),
+    port: z.number(),
+    tls: z.boolean(),
+    dappPath: z.string().default('/api/v0/dapp'),
+    userPath: z.string().default('/api/v0/user'),
+    allowedOrigins: z.union([z.literal('*'), z.array(z.string())]).default('*'),
 });
 export const configSchema = z.object({
     kernel: kernelInfoSchema,
+    server: serverConfigSchema,
     store: storeConfigSchema,
     signingStore: signingStoreConfigSchema,
 });

package/dist/config/ConfigUtils.d.ts

@@ -1,5 +1,9 @@
-import { Config } from './Config.js';
+import { Config, ServerConfig } from './Config.js';
 export declare class ConfigUtils {
     static loadConfigFile(filePath: string): Config;
 }
+export declare const deriveKernelUrls: (serverConfig: ServerConfig) => {
+    dappUrl: string;
+    userUrl: string;
+};
 //# sourceMappingURL=ConfigUtils.d.ts.map

package/dist/config/ConfigUtils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ConfigUtils.d.ts","sourceRoot":"","sources":["../../src/config/ConfigUtils.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,MAAM,EAAgB,MAAM,aAAa,CAAA;AAElD,qBAAa,WAAW;IACpB,MAAM,CAAC,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM;CAoDlD"}
+{"version":3,"file":"ConfigUtils.d.ts","sourceRoot":"","sources":["../../src/config/ConfigUtils.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,MAAM,EAAgB,YAAY,EAAE,MAAM,aAAa,CAAA;AAEhE,qBAAa,WAAW;IACpB,MAAM,CAAC,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM;CAoDlD;AAgDD,eAAO,MAAM,gBAAgB,GACzB,cAAc,YAAY,KAC3B;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAOpC,CAAA"}

package/dist/config/ConfigUtils.js

@@ -70,3 +70,10 @@ function validateNetworkAuthMethods(config) {
         }
     }
 }
+export const deriveKernelUrls = (serverConfig) => {
+    const protocol = serverConfig.tls ? 'https' : 'http';
+    const dappUrl = `${protocol}://${serverConfig.host}:${serverConfig.port}${serverConfig.dappPath}`;
+    // userUrl is the base URL for the web frontend (no path)
+    const userUrl = `${protocol}://${serverConfig.host}:${serverConfig.port}`;
+    return { dappUrl, userUrl };
+};

package/dist/dapp-api/controller.d.ts

@@ -3,7 +3,7 @@ import { Store } from '@canton-network/core-wallet-store';
 import { NotificationService } from '../notification/NotificationService.js';
 import { KernelInfo as KernelInfoConfig } from '../config/Config.js';
 import { Logger } from 'pino';
-export declare const dappController: (kernelInfo: KernelInfoConfig, store: Store, notificationService: NotificationService, _logger: Logger, context?: AuthContext) => {
+export declare const dappController: (kernelInfo: KernelInfoConfig, dappUrl: string, userUrl: string, store: Store, notificationService: NotificationService, _logger: Logger, context?: AuthContext) => {
     status: import("./rpc-gen/typings.js").Status;
     connect: import("./rpc-gen/typings.js").Connect;
     disconnect: import("./rpc-gen/typings.js").Disconnect;

package/dist/dapp-api/controller.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"controller.d.ts","sourceRoot":"","sources":["../../src/dapp-api/controller.ts"],"names":[],"mappings":"AAIA,OAAO,EAAmB,WAAW,EAAE,MAAM,kCAAkC,CAAA;AAQ/E,OAAO,EAAE,KAAK,EAAE,MAAM,mCAAmC,CAAA;AAQzD,OAAO,EAAE,mBAAmB,EAAE,MAAM,wCAAwC,CAAA;AAC5E,OAAO,EAAE,UAAU,IAAI,gBAAgB,EAAE,MAAM,qBAAqB,CAAA;AACpE,OAAO,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAG7B,eAAO,MAAM,cAAc,GACvB,YAAY,gBAAgB,EAC5B,OAAO,KAAK,EACZ,qBAAqB,mBAAmB,EACxC,SAAS,MAAM,EACf,UAAU,WAAW;;;;;;;;;;;;;CAkNxB,CAAA"}
+{"version":3,"file":"controller.d.ts","sourceRoot":"","sources":["../../src/dapp-api/controller.ts"],"names":[],"mappings":"AAIA,OAAO,EAAmB,WAAW,EAAE,MAAM,kCAAkC,CAAA;AAQ/E,OAAO,EAAE,KAAK,EAAE,MAAM,mCAAmC,CAAA;AAQzD,OAAO,EAAE,mBAAmB,EAAE,MAAM,wCAAwC,CAAA;AAC5E,OAAO,EAAE,UAAU,IAAI,gBAAgB,EAAE,MAAM,qBAAqB,CAAA;AACpE,OAAO,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAG7B,eAAO,MAAM,cAAc,GACvB,YAAY,gBAAgB,EAC5B,SAAS,MAAM,EACf,SAAS,MAAM,EACf,OAAO,KAAK,EACZ,qBAAqB,mBAAmB,EACxC,SAAS,MAAM,EACf,UAAU,WAAW;;;;;;;;;;;;;CAkNxB,CAAA"}

package/dist/dapp-api/controller.js

@@ -5,12 +5,12 @@ import { assertConnected } from '@canton-network/core-wallet-auth';
 import buildController from './rpc-gen/index.js';
 import { LedgerClient, } from '@canton-network/core-ledger-client';
 import { v4 } from 'uuid';
-import { networkStatus } from '../utils.js';
-export const dappController = (kernelInfo, store, notificationService, _logger, context) => {
+import { networkStatus, ledgerPrepareParams } from '../utils.js';
+export const dappController = (kernelInfo, dappUrl, userUrl, store, notificationService, _logger, context) => {
     const logger = _logger.child({ component: 'dapp-controller' });
     return buildController({
         connect: async () => {
-            if (!context) {
+            if (!context || !(await store.getSession())) {
                 return {
                     sessionToken: '',
                     status: {
@@ -18,12 +18,17 @@ export const dappController = (kernelInfo, store, notificationService, _logger,
                         isConnected: false,
                         isNetworkConnected: false,
                         networkReason: 'Unauthenticated',
-                        userUrl: 'http://localhost:3030/login/', // TODO: pull user URL from config
+                        userUrl: `${userUrl}/login/`,
                     },
                 };
             }
             const network = await store.getCurrentNetwork();
-            const ledgerClient = new LedgerClient(new URL(network.ledgerApi.baseUrl), logger, false, context.accessToken);
+            const ledgerClient = new LedgerClient({
+                baseUrl: new URL(network.ledgerApi.baseUrl),
+                logger,
+                isAdmin: false,
+                accessToken: context.accessToken,
+            });
             const status = await networkStatus(ledgerClient);
             return {
                 sessionToken: context.accessToken,
@@ -32,7 +37,7 @@ export const dappController = (kernelInfo, store, notificationService, _logger,
                     isConnected: true,
                     isNetworkConnected: status.isConnected,
                     networkReason: status.reason ? status.reason : 'OK',
-                    userUrl: 'http://localhost:3030/login/', // TODO: pull user URL from config
+                    userUrl: `${userUrl}/login/`,
                 },
             };
         },
@@ -48,7 +53,7 @@ export const dappController = (kernelInfo, store, notificationService, _logger,
                     isConnected: false,
                     isNetworkConnected: false,
                     networkReason: 'Unauthenticated',
-                    userUrl: 'http://localhost:3030/login/', // TODO: pull user URL from config
+                    userUrl: `${userUrl}/login/`,
                 });
             }
             return null;
@@ -56,7 +61,12 @@ export const dappController = (kernelInfo, store, notificationService, _logger,
         darsAvailable: async () => ({ dars: ['default-dar'] }),
         ledgerApi: async (params) => {
             const network = await store.getCurrentNetwork();
-            const ledgerClient = new LedgerClient(new URL(network.ledgerApi.baseUrl), logger, false, assertConnected(context).accessToken);
+            const ledgerClient = new LedgerClient({
+                baseUrl: new URL(network.ledgerApi.baseUrl),
+                logger,
+                isAdmin: false,
+                accessToken: assertConnected(context).accessToken,
+            });
             let result;
             switch (params.requestMethod) {
                 case 'GET':
@@ -83,7 +93,12 @@ export const dappController = (kernelInfo, store, notificationService, _logger,
             if (wallet === undefined) {
                 throw new Error('No primary wallet found');
             }
-            const ledgerClient = new LedgerClient(new URL(network.ledgerApi.baseUrl), logger, false, context.accessToken);
+            const ledgerClient = new LedgerClient({
+                baseUrl: new URL(network.ledgerApi.baseUrl),
+                logger,
+                isAdmin: false,
+                accessToken: context.accessToken,
+            });
             const userId = context.userId;
             const notifier = notificationService.getNotifier(userId);
             params.commandId = params.commandId || v4();
@@ -97,11 +112,11 @@ export const dappController = (kernelInfo, store, notificationService, _logger,
                 status: 'pending',
                 preparedTransaction,
                 preparedTransactionHash,
-                payload: params.commands,
+                payload: params,
+                createdAt: new Date(),
             });
             return {
-                // TODO: pull user base URL / port from config
-                userUrl: `http://localhost:3030/approve/index.html?commandId=${commandId}`,
+                userUrl: `${userUrl}/approve/index.html?commandId=${commandId}`,
             };
         },
         prepareReturn: async (params) => {
@@ -113,11 +128,16 @@ export const dappController = (kernelInfo, store, notificationService, _logger,
             if (wallet === undefined) {
                 throw new Error('No primary wallet found');
             }
-            const ledgerClient = new LedgerClient(new URL(network.ledgerApi.baseUrl), logger, false, context.accessToken);
+            const ledgerClient = new LedgerClient({
+                baseUrl: new URL(network.ledgerApi.baseUrl),
+                logger,
+                isAdmin: false,
+                accessToken: context.accessToken,
+            });
             return prepareSubmission(context.userId, wallet.partyId, network.synchronizerId, params, ledgerClient);
         },
         status: async () => {
-            if (!context) {
+            if (!context || !(await store.getSession())) {
                 return {
                     kernel: kernelInfo,
                     isConnected: false,
@@ -126,7 +146,12 @@ export const dappController = (kernelInfo, store, notificationService, _logger,
                 };
             }
             const network = await store.getCurrentNetwork();
-            const ledgerClient = new LedgerClient(new URL(network.ledgerApi.baseUrl), logger, false, context.accessToken);
+            const ledgerClient = new LedgerClient({
+                baseUrl: new URL(network.ledgerApi.baseUrl),
+                logger,
+                isAdmin: false,
+                accessToken: context.accessToken,
+            });
             const status = await networkStatus(ledgerClient);
             return {
                 kernel: kernelInfo,
@@ -155,26 +180,5 @@ export const dappController = (kernelInfo, store, notificationService, _logger,
     });
 };
 async function prepareSubmission(userId, partyId, synchronizerId, params, ledgerClient) {
-    // Map disclosed contracts to ledger api format (which wrongly defines optional fields as mandatory)
-    const disclosedContracts = params.disclosedContracts?.map((d) => {
-        return {
-            templateId: d.templateId || '',
-            contractId: d.contractId || '',
-            createdEventBlob: d.createdEventBlob,
-            synchronizerId: d.synchronizerId || '',
-        };
-    }) || [];
-    const prepareParams = {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- because OpenRPC codegen type is incompatible with ledger codegen type
-        commands: params.commands,
-        commandId: params.commandId || v4(),
-        userId,
-        actAs: params.actAs || [partyId],
-        readAs: params.readAs || [],
-        disclosedContracts,
-        synchronizerId,
-        verboseHashing: false,
-        packageIdSelectionPreference: params.packageIdSelectionPreference || [],
-    };
-    return await ledgerClient.postWithRetry('/v2/interactive-submission/prepare', prepareParams);
+    return await ledgerClient.postWithRetry('/v2/interactive-submission/prepare', ledgerPrepareParams(userId, partyId, synchronizerId, params));
 }

package/dist/dapp-api/server.d.ts

@@ -4,6 +4,6 @@ import { Store } from '@canton-network/core-wallet-store';
 import { AuthService, AuthAware } from '@canton-network/core-wallet-auth';
 import { Server } from 'http';
 import { NotificationService } from '../notification/NotificationService.js';
-import { KernelInfo } from '../config/Config.js';
-export declare const dapp: (route: string, app: express.Express, logger: Logger, server: Server, kernelInfo: KernelInfo, notificationService: NotificationService, authService: AuthService, store: Store & AuthAware<Store>) => Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>;
+import { KernelInfo, ServerConfig } from '../config/Config.js';
+export declare const dapp: (route: string, app: express.Express, logger: Logger, server: Server, kernelInfo: KernelInfo, dappUrl: string, userUrl: string, serverConfig: ServerConfig, notificationService: NotificationService, authService: AuthService, store: Store & AuthAware<Store>) => Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>;
 //# sourceMappingURL=server.d.ts.map

package/dist/dapp-api/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/dapp-api/server.ts"],"names":[],"mappings":"AAGA,OAAO,OAAO,MAAM,SAAS,CAAA;AAG7B,OAAO,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAG7B,OAAO,EAAE,KAAK,EAAE,MAAM,mCAAmC,CAAA;AACzD,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAA;AACzE,OAAO,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAE7B,OAAO,EACH,mBAAmB,EAEtB,MAAM,wCAAwC,CAAA;AAC/C,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAA;AAEhD,eAAO,MAAM,IAAI,GACb,OAAO,MAAM,EACb,KAAK,OAAO,CAAC,OAAO,EACpB,QAAQ,MAAM,EACd,QAAQ,MAAM,EACd,YAAY,UAAU,EACtB,qBAAqB,mBAAmB,EACxC,aAAa,WAAW,EACxB,OAAO,KAAK,GAAG,SAAS,CAAC,KAAK,CAAC,wFAuElC,CAAA"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/dapp-api/server.ts"],"names":[],"mappings":"AAGA,OAAO,OAAO,MAAM,SAAS,CAAA;AAG7B,OAAO,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAG7B,OAAO,EAAE,KAAK,EAAE,MAAM,mCAAmC,CAAA;AACzD,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAA;AACzE,OAAO,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAE7B,OAAO,EACH,mBAAmB,EAEtB,MAAM,wCAAwC,CAAA;AAC/C,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAA;AAE9D,eAAO,MAAM,IAAI,GACb,OAAO,MAAM,EACb,KAAK,OAAO,CAAC,OAAO,EACpB,QAAQ,MAAM,EACd,QAAQ,MAAM,EACd,YAAY,UAAU,EACtB,SAAS,MAAM,EACf,SAAS,MAAM,EACf,cAAc,YAAY,EAC1B,qBAAqB,mBAAmB,EACxC,aAAa,WAAW,EACxB,OAAO,KAAK,GAAG,SAAS,CAAC,KAAK,CAAC,wFA6ElC,CAAA"}

package/dist/dapp-api/server.js

@@ -4,15 +4,17 @@ import cors from 'cors';
 import { dappController } from './controller.js';
 import { jsonRpcHandler } from '../middleware/jsonRpcHandler.js';
 import { Server as SocketIoServer } from 'socket.io';
-export const dapp = (route, app, logger, server, kernelInfo, notificationService, authService, store) => {
-    app.use(cors()); // TODO: read allowedOrigins from config
+export const dapp = (route, app, logger, server, kernelInfo, dappUrl, userUrl, serverConfig, notificationService, authService, store) => {
+    app.use(cors({
+        origin: serverConfig.allowedOrigins,
+    }));
     app.use(route, (req, res, next) => jsonRpcHandler({
-        controller: dappController(kernelInfo, store.withAuthContext(req.authContext), notificationService, logger, req.authContext),
+        controller: dappController(kernelInfo, dappUrl, userUrl, store.withAuthContext(req.authContext), notificationService, logger, req.authContext),
         logger,
     })(req, res, next));
     const io = new SocketIoServer(server, {
         cors: {
-            origin: '*', // TODO: read allowedOrigins from config
+            origin: serverConfig.allowedOrigins,
             methods: ['GET', 'POST'],
         },
     });

package/dist/dapp-api/server.test.js

@@ -6,7 +6,7 @@ import request from 'supertest';
 import express from 'express';
 import { dapp } from './server.js';
 import { StoreInternal } from '@canton-network/core-wallet-store-inmemory';
-import { ConfigUtils } from '../config/ConfigUtils.js';
+import { ConfigUtils, deriveKernelUrls } from '../config/ConfigUtils.js';
 import { pino } from 'pino';
 import { sink } from 'pino-test';
 import { createServer } from 'http';
@@ -30,7 +30,8 @@ test('call connect rpc', async () => {
     app.use(cors());
     app.use(express.json());
     const server = createServer(app);
-    const response = await request(dapp('/api/v0/dapp', app, pino(sink()), server, config.kernel, notificationService, authService, store))
+    const { dappUrl, userUrl } = deriveKernelUrls(config.server);
+    const response = await request(dapp('/api/v0/dapp', app, pino(sink()), server, config.kernel, dappUrl, userUrl, config.server, notificationService, authService, store))
         .post('/api/v0/dapp')
         .send({ jsonrpc: '2.0', id: 0, method: 'connect', params: [] })
         .set('Accept', 'application/json');
@@ -44,8 +45,6 @@ test('call connect rpc', async () => {
                 kernel: {
                     id: 'remote-da',
                     clientType: 'remote',
-                    url: 'http://localhost:3030/api/v0/dapp',
-                    userUrl: 'http://localhost:3030',
                 },
                 isConnected: false,
                 isNetworkConnected: false,

package/dist/example-config.d.ts

@@ -2,8 +2,14 @@ declare const _default: {
     kernel: {
         id: string;
         clientType: "remote";
-        url: string;
-        userUrl: string;
+    };
+    server: {
+        host: string;
+        port: number;
+        tls: false;
+        dappPath: string;
+        userPath: string;
+        allowedOrigins: string[];
     };
     signingStore: {
         connection: {

package/dist/example-config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"example-config.d.ts","sourceRoot":"","sources":["../src/example-config.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKA,wBAoFkB"}
+{"version":3,"file":"example-config.d.ts","sourceRoot":"","sources":["../src/example-config.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKA,wBA0FkB"}

package/dist/example-config.js

@@ -4,8 +4,14 @@ export default {
     kernel: {
         id: 'remote-da',
         clientType: 'remote',
-        url: 'http://localhost:3030/api/v0/dapp',
-        userUrl: 'http://localhost:3030',
+    },
+    server: {
+        host: 'localhost',
+        port: 3030,
+        tls: false,
+        dappPath: '/api/v0/dapp',
+        userPath: '/api/v0/user',
+        allowedOrigins: ['http://localhost:8080'],
     },
     signingStore: {
         connection: {

package/dist/init.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../src/init.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAsB7B,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AA0GvC,wBAAsB,UAAU,CAAC,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,iBAwFhE"}
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../src/init.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAsB7B,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AA2GvC,wBAAsB,UAAU,CAAC,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,iBAwGhE"}

package/dist/init.js

@@ -15,6 +15,7 @@ import { jwtAuthService } from './auth/jwt-auth-service.js';
 import express from 'express';
 import { jwtAuth } from './middleware/jwtAuth.js';
 import { rpcRateLimit } from './middleware/rateLimit.js';
+import { deriveKernelUrls } from './config/ConfigUtils.js';
 import { existsSync, readFileSync } from 'fs';
 import path from 'path';
 let isReady = false;
@@ -88,10 +89,14 @@ async function initializeSigningDatabase(config, logger) {
     return new SigningStoreSql(db, logger);
 }
 export async function initialize(opts, logger) {
-    const port = opts.port ? Number(opts.port) : 3030;
+    const config = ConfigUtils.loadConfigFile(opts.config);
+    // Use CLI port override or config port
+    const port = opts.port ? Number(opts.port) : config.server.port;
+    const host = config.server.host;
+    const protocol = config.server.tls ? 'https' : 'http';
     const app = express();
-    const server = app.listen(port, () => {
-        logger.info(`Remote Wallet Gateway starting on http://localhost:${port}`);
+    const server = app.listen(port, host, () => {
+        logger.info(`Remote Wallet Gateway starting on ${protocol}://${host}:${port}`);
     });
     app.use('/healthz', rpcRateLimit, (_req, res) => res.status(200).send('OK'));
     app.use('/readyz', rpcRateLimit, (_req, res) => {
@@ -103,7 +108,6 @@ export async function initialize(opts, logger) {
         }
     });
     const notificationService = new NotificationService(logger);
-    const config = ConfigUtils.loadConfigFile(opts.config);
     const store = await initializeDatabase(config, logger);
     const signingStore = await initializeSigningDatabase(config, logger);
     const authService = jwtAuthService(store, logger);
@@ -134,12 +138,19 @@ export async function initialize(opts, logger) {
     app.use('/api/*splat', express.json());
     app.use('/api/*splat', rpcRateLimit);
     app.use('/api/*splat', jwtAuth(authService, logger));
+    // Override config port with CLI parameter port if provided, then derive URLs
+    const serverConfigWithOverride = {
+        ...config.server,
+        port, // Use the actual port we're listening on
+    };
+    const { dappUrl, userUrl } = deriveKernelUrls(serverConfigWithOverride);
+    const kernelInfo = config.kernel;
     // register dapp API handlers
-    dapp('/api/v0/dapp', app, logger, server, config.kernel, notificationService, authService, store);
+    dapp(config.server.dappPath, app, logger, server, kernelInfo, dappUrl, userUrl, config.server, notificationService, authService, store);
     // register user API handlers
-    user('/api/v0/user', app, logger, config.kernel, notificationService, drivers, store);
+    user(config.server.userPath, app, logger, kernelInfo, userUrl, notificationService, drivers, store);
     // register web handler
-    web(app, server);
+    web(app, server, config.server.userPath);
     isReady = true;
     logger.info('Wallet Gateway initialization complete');
 }

package/dist/ledger/party-allocation-service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"party-allocation-service.d.ts","sourceRoot":"","sources":["../../src/ledger/party-allocation-service.ts"],"names":[],"mappings":"AAGA,OAAO,EACH,2BAA2B,EAG9B,MAAM,oCAAoC,CAAA;AAC3C,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAA;AACtE,OAAO,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAE7B,MAAM,MAAM,cAAc,GAAG;IACzB,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,EAAE,MAAM,CAAA;CACpB,CAAA;AAED,KAAK,WAAW,GAAG,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAA;AAEpD;;GAEG;AACH,qBAAa,sBAAsB;IAC/B,OAAO,CAAC,MAAM,CAAQ;IACtB,OAAO,CAAC,YAAY,CAAc;IAClC,OAAO,CAAC,cAAc,CAAoB;gBAE9B,EACR,cAAc,EACd,mBAAmB,EACnB,aAAa,EACb,MAAM,EACN,WAAW,GACd,EAAE;QACC,cAAc,CAAC,EAAE,MAAM,CAAA;QACvB,mBAAmB,EAAE,mBAAmB,CAAA;QACxC,aAAa,EAAE,MAAM,CAAA;QACrB,MAAM,EAAE,MAAM,CAAA;QACd,WAAW,CAAC,EAAE,MAAM,CAAA;KACvB;IAYD;;;;OAIG;IACG,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC;IAE1E;;;;;;OAMG;IACG,aAAa,CACf,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,EACjB,eAAe,EAAE,WAAW,GAC7B,OAAO,CAAC,cAAc,CAAC;IAoB1B;;;OAGG;IACH,wBAAwB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;IAMnD;;;;OAIG;IACG,4BAA4B,CAC9B,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,GAClB,OAAO,CAAC,2BAA2B,CAAC;IAevC;;;;;;OAMG;IACG,+BAA+B,CACjC,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,EAAE,EACtB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,GACf,OAAO,CAAC,MAAM,CAAC;YAgCJ,qBAAqB;YAuBrB,qBAAqB;CAsCtC"}
+{"version":3,"file":"party-allocation-service.d.ts","sourceRoot":"","sources":["../../src/ledger/party-allocation-service.ts"],"names":[],"mappings":"AAGA,OAAO,EACH,2BAA2B,EAE9B,MAAM,oCAAoC,CAAA;AAE3C,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAA;AACtE,OAAO,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAE7B,MAAM,MAAM,cAAc,GAAG;IACzB,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,EAAE,MAAM,CAAA;CACpB,CAAA;AAED,KAAK,WAAW,GAAG,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAA;AAEpD;;GAEG;AACH,qBAAa,sBAAsB;IAC/B,OAAO,CAAC,MAAM,CAAQ;IACtB,OAAO,CAAC,YAAY,CAAc;IAClC,OAAO,CAAC,cAAc,CAAoB;gBAE9B,EACR,cAAc,EACd,mBAAmB,EACnB,aAAa,EACb,MAAM,EACN,WAAW,GACd,EAAE;QACC,cAAc,CAAC,EAAE,MAAM,CAAA;QACvB,mBAAmB,EAAE,mBAAmB,CAAA;QACxC,aAAa,EAAE,MAAM,CAAA;QACrB,MAAM,EAAE,MAAM,CAAA;QACd,WAAW,CAAC,EAAE,MAAM,CAAA;KACvB;IAYD;;;;OAIG;IACG,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC;IAE1E;;;;;;OAMG;IACG,aAAa,CACf,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,EACjB,eAAe,EAAE,WAAW,GAC7B,OAAO,CAAC,cAAc,CAAC;IAoB1B;;;OAGG;IACH,wBAAwB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;IAenD;;;;OAIG;IACG,4BAA4B,CAC9B,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,GAClB,OAAO,CAAC,2BAA2B,CAAC;IAevC;;;;;;OAMG;IACG,+BAA+B,CACjC,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,MAAM,EAAE,EACtB,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,GACf,OAAO,CAAC,MAAM,CAAC;YAgCJ,qBAAqB;YAuBrB,qBAAqB;CAsCtC"}

package/dist/ledger/party-allocation-service.js

@@ -1,6 +1,7 @@
 // Copyright (c) 2025 Digital Asset (Switzerland) GmbH and/or its affiliates. All rights reserved.
 // SPDX-License-Identifier: Apache-2.0
-import { LedgerClient, TopologyWriteService, } from '@canton-network/core-ledger-client';
+import { LedgerClient, } from '@canton-network/core-ledger-client';
+import { createHash } from 'node:crypto';
 /**
  * This service provides an abstraction for Canton party allocation that seamlessly handles both internal and external parties.
  */
@@ -8,7 +9,13 @@ export class PartyAllocationService {
     constructor({ synchronizerId, accessTokenProvider, httpLedgerUrl, logger, accessToken, }) {
         this.logger = logger;
         this.synchronizerId = synchronizerId;
-        this.ledgerClient = new LedgerClient(new URL(httpLedgerUrl), this.logger, true, accessToken ?? '', accessTokenProvider);
+        this.ledgerClient = new LedgerClient({
+            baseUrl: new URL(httpLedgerUrl),
+            logger: this.logger,
+            isAdmin: true,
+            accessToken: accessToken ?? '',
+            accessTokenProvider: accessTokenProvider,
+        });
     }
     async allocateParty(userId, hint, publicKey, signingCallback) {
         if (publicKey !== undefined && signingCallback !== undefined) {
@@ -19,7 +26,16 @@ export class PartyAllocationService {
         }
     }
     createFingerprintFromKey(publicKey) {
-        return TopologyWriteService.createFingerprintFromKey(publicKey);
+        // Hash purpose codes can be looked up in the Canton codebase:
+        //  https://github.com/DACH-NY/canton/blob/62e9ccd3f1743d2c9422d863cfc2ca800405c71b/community/base/src/main/scala/com/digitalasset/canton/crypto/HashPurpose.scala#L52
+        const hashPurpose = 12; // For `PublicKeyFingerprint`
+        const keyBytes = Buffer.from(publicKey, 'base64');
+        const hashInput = Buffer.alloc(4 + keyBytes.length);
+        hashInput.writeUInt32BE(hashPurpose, 0);
+        Buffer.from(keyBytes).copy(hashInput, 4);
+        const hash = createHash('sha256').update(hashInput).digest();
+        const multiprefix = Buffer.from([0x12, 0x20]);
+        return Buffer.concat([multiprefix, hash]).toString('hex');
     }
     async generateTopologyTransactions(hint, publicKey) {
         const synchronizerId = this.synchronizerId ?? (await this.ledgerClient.getSynchronizerId());

package/dist/ledger/party-allocation-service.test.js

@@ -6,12 +6,6 @@ import { sink } from 'pino-test';
 const mockLedgerGet = jest.fn();
 const mockLedgerPost = jest.fn();
 const mockLedgerGrantUserRights = jest.fn();
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-const MockTopologyWriteService = jest.fn();
-// Add static method to the mock class
-MockTopologyWriteService.createFingerprintFromKey = jest
-    .fn()
-    .mockReturnValue('mypublickey');
 jest.unstable_mockModule('@canton-network/core-ledger-client', () => ({
     Signature: jest.fn(),
     SignatureFormat: jest.fn(),
@@ -34,7 +28,6 @@ jest.unstable_mockModule('@canton-network/core-ledger-client', () => ({
                 .mockResolvedValue({ partyId: 'party2::mypublickey' }),
         };
     }),
-    TopologyWriteService: MockTopologyWriteService,
 }));
 describe('PartyAllocationService', () => {
     const network = {
@@ -80,7 +73,9 @@ describe('PartyAllocationService', () => {
             httpLedgerUrl: network.ledgerApi.baseUrl,
             logger: mockLogger,
         });
+        jest.spyOn(service, 'createFingerprintFromKey').mockReturnValue('mypublickey');
     });
+    afterEach(() => jest.restoreAllMocks());
     it('allocates an internal party', async () => {
         mockLedgerGet.mockResolvedValueOnce({ participantId: 'participantid' });
         mockLedgerPost.mockResolvedValueOnce({

package/dist/user-api/controller.d.ts

@@ -5,7 +5,7 @@ import { AuthContext } from '@canton-network/core-wallet-auth';
 import { KernelInfo } from '../config/Config.js';
 import { SigningDriverInterface, SigningProvider } from '@canton-network/core-signing-lib';
 type AvailableSigningDrivers = Partial<Record<SigningProvider, SigningDriverInterface>>;
-export declare const userController: (kernelInfo: KernelInfo, store: Store, notificationService: NotificationService, authContext: AuthContext | undefined, drivers: AvailableSigningDrivers, _logger: Logger) => {
+export declare const userController: (kernelInfo: KernelInfo, userUrl: string, store: Store, notificationService: NotificationService, authContext: AuthContext | undefined, drivers: AvailableSigningDrivers, _logger: Logger) => {
     addNetwork: import("./rpc-gen/typings.js").AddNetwork;
     removeNetwork: import("./rpc-gen/typings.js").RemoveNetwork;
     listNetworks: import("./rpc-gen/typings.js").ListNetworks;
@@ -23,6 +23,7 @@ export declare const userController: (kernelInfo: KernelInfo, store: Store, noti
     removeSession: import("./rpc-gen/typings.js").RemoveSession;
     listSessions: import("./rpc-gen/typings.js").ListSessions;
     getTransaction: import("./rpc-gen/typings.js").GetTransaction;
+    listTransactions: import("./rpc-gen/typings.js").ListTransactions;
 };
 export {};
 //# sourceMappingURL=controller.d.ts.map

package/dist/user-api/controller.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"controller.d.ts","sourceRoot":"","sources":["../../src/user-api/controller.ts"],"names":[],"mappings":"AAwBA,OAAO,EACH,KAAK,EAIR,MAAM,mCAAmC,CAAA;AAC1C,OAAO,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAC7B,OAAO,EAAE,mBAAmB,EAAE,MAAM,wCAAwC,CAAA;AAC5E,OAAO,EAGH,WAAW,EAId,MAAM,kCAAkC,CAAA;AACzC,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAA;AAChD,OAAO,EACH,sBAAsB,EACtB,eAAe,EAClB,MAAM,kCAAkC,CAAA;AASzC,KAAK,uBAAuB,GAAG,OAAO,CAClC,MAAM,CAAC,eAAe,EAAE,sBAAsB,CAAC,CAClD,CAAA;AAED,eAAO,MAAM,cAAc,GACvB,YAAY,UAAU,EACtB,OAAO,KAAK,EACZ,qBAAqB,mBAAmB,EACxC,aAAa,WAAW,GAAG,SAAS,EACpC,SAAS,uBAAuB,EAChC,SAAS,MAAM;;;;;;;;;;;;;;;;;;CAinBlB,CAAA"}
+{"version":3,"file":"controller.d.ts","sourceRoot":"","sources":["../../src/user-api/controller.ts"],"names":[],"mappings":"AAyBA,OAAO,EACH,KAAK,EAIR,MAAM,mCAAmC,CAAA;AAC1C,OAAO,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAC7B,OAAO,EAAE,mBAAmB,EAAE,MAAM,wCAAwC,CAAA;AAC5E,OAAO,EAGH,WAAW,EAId,MAAM,kCAAkC,CAAA;AACzC,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAA;AAChD,OAAO,EACH,sBAAsB,EACtB,eAAe,EAClB,MAAM,kCAAkC,CAAA;AAazC,KAAK,uBAAuB,GAAG,OAAO,CAClC,MAAM,CAAC,eAAe,EAAE,sBAAsB,CAAC,CAClD,CAAA;AAED,eAAO,MAAM,cAAc,GACvB,YAAY,UAAU,EACtB,SAAS,MAAM,EACf,OAAO,KAAK,EACZ,qBAAqB,mBAAmB,EACxC,aAAa,WAAW,GAAG,SAAS,EACpC,SAAS,uBAAuB,EAChC,SAAS,MAAM;;;;;;;;;;;;;;;;;;;CA6oBlB,CAAA"}