@canton-network/wallet-gateway-remote 1.4.0 → 1.6.0

package/dist/dapp-api/controller.js

@@ -4,9 +4,18 @@ import { assertConnected, AuthTokenProvider, } from '@canton-network/core-wallet
 import buildController from './rpc-gen/index.js';
 import { LedgerClient, } from '@canton-network/core-ledger-client';
 import { v4 } from 'uuid';
-import { networkStatus, ledgerPrepareParams } from '../utils.js';
-export const dappController = (kernelInfo, dappUrl, userUrl, store, notificationService, _logger, origin, context) => {
+import { networkStatus, ledgerPrepareParams, logDynamically } from '../utils.js';
+import { TransactionService } from '../ledger/transaction-service.js';
+import { rpcErrors } from '@canton-network/core-rpc-errors';
+export const dappController = (kernelInfo, dappUrl, userUrl, store, notificationService, _logger, origin, deps, context) => {
     const logger = _logger.child({ component: 'dapp-controller' });
+    function assertActAsPartiesBelongToUser(actAs, wallets) {
+        for (const party of actAs) {
+            if (wallets.find((w) => w.partyId === party) === undefined) {
+                throw rpcErrors.invalidRequest(`Acting party ${party} does not belong to user`);
+            }
+        }
+    }
     return buildController({
         connect: async () => {
             if (!context || !(await store.getSession())) {
@@ -126,51 +135,116 @@ export const dappController = (kernelInfo, dappUrl, userUrl, store, notification
             return result;
         },
         prepareExecute: async (params) => {
-            const wallet = await store.getPrimaryWallet();
+            const primaryWallet = await store.getPrimaryWallet();
+            const wallets = await store.getWallets();
             const network = await store.getCurrentNetwork();
             if (context === undefined) {
                 throw new Error('Unauthenticated context');
             }
+            // determine user ID
+            const gatewayUserId = context.userId;
+            let ledgerUserId = context.userId;
+            const accessTokenProvider = AuthTokenProvider.fromToken(context.accessToken, logger);
+            if (context?.isApiKey) {
+                logger.info('Authenticated with API Key, fetching m2m token for ledger access');
+                ledgerUserId = context.ledgerUserId;
+            }
+            // determine party ID
+            let actAs = params.actAs || [];
+            if (actAs.length === 0) {
+                if (!primaryWallet) {
+                    throw new Error('No primary wallet found. Create or sync a wallet and set it as primary before prepareExecute.');
+                }
+                actAs = [primaryWallet.partyId];
+            }
+            assertActAsPartiesBelongToUser(actAs, wallets);
+            // determine wallet
+            const wallet = wallets.find((w) => w.partyId === actAs[0]);
             if (wallet === undefined) {
-                throw new Error('No primary wallet found');
+                throw new Error('No wallet found for the first acting party. Create or sync a wallet and set it as primary before prepareExecute.');
             }
             const ledgerClient = new LedgerClient({
                 baseUrl: new URL(network.ledgerApi.baseUrl),
                 logger,
-                accessTokenProvider: AuthTokenProvider.fromToken(context.accessToken, logger),
+                accessTokenProvider,
             });
-            const userId = context.userId;
-            const notifier = notificationService.getNotifier(userId);
-            params.commandId = params.commandId || v4();
-            const commandId = params.commandId;
+            const notifier = notificationService.getNotifier(gatewayUserId);
+            const commandId = params.commandId || v4();
             const transactionId = v4();
             notifier.emit('txChanged', { status: 'pending', commandId });
             const synchronizerId = network.synchronizerId ??
                 (await ledgerClient.getSynchronizerId());
-            const response = await prepareSubmission(context.userId, wallet.partyId, synchronizerId, params, ledgerClient);
+            logDynamically(logger, 'prepareExecute: Submitting request to ledger', {
+                info: { transactionId },
+                debug: {
+                    commandId,
+                    gatewayUserId,
+                    ledgerUserId,
+                    actAs,
+                    params,
+                },
+            });
+            const prepared = await prepareSubmission(ledgerUserId, actAs, synchronizerId, params, ledgerClient);
+            logDynamically(logger, 'prepareExecute: Received response from ledger', {
+                info: { transactionId },
+                debug: {
+                    commandId,
+                    gatewayUserId,
+                    ledgerUserId,
+                    actAs,
+                    prepared,
+                },
+            });
             const transaction = {
                 id: transactionId,
                 commandId,
                 status: 'pending',
-                preparedTransaction: response.preparedTransaction,
-                preparedTransactionHash: response.preparedTransactionHash,
+                preparedTransaction: prepared.preparedTransaction,
+                preparedTransactionHash: prepared.preparedTransactionHash,
                 payload: params,
                 origin: origin || null,
                 createdAt: new Date(),
             };
             logger.info({
-                actAs: params.actAs || [wallet.partyId],
+                actAs,
                 readAs: params.readAs || [],
-                userId: context.userId,
+                gatewayUserId,
+                ledgerUserId,
                 commandId,
                 commands: params.commands?.[0],
-                confirmationRequestTrafficCostEstimation: response.costEstimation
+                confirmationRequestTrafficCostEstimation: prepared.costEstimation
                     ?.confirmationRequestTrafficCostEstimation,
             }, 'prepared transaction traffic estimation');
             await store.setTransaction(transaction);
+            const approveUrl = `${userUrl}/approve/index.html?transactionId=${transactionId}&commandId=${commandId}&closeafteraction`;
+            if (context.isApiKey) {
+                logger.info({
+                    gatewayUserId,
+                    ledgerUserId,
+                    commandId,
+                    transactionId,
+                    signingProviderId: wallet.signingProviderId,
+                }, 'Service account straight-through prepare/sign/execute');
+                const transactionService = new TransactionService(store, logger, deps.signingDrivers, notifier);
+                try {
+                    await transactionService.signAndExecute(context, network, wallet, transaction);
+                }
+                catch (error) {
+                    logger.error({
+                        err: error,
+                        gatewayUserId,
+                        ledgerUserId,
+                        commandId,
+                        transactionId,
+                        actAs,
+                        signingProviderId: wallet.signingProviderId,
+                    }, 'Service account sign/execute failed after prepare');
+                    throw error;
+                }
+            }
             return {
                 // closeafteraction query param flag makes approving or deleting tx close the popup
-                userUrl: `${userUrl}/approve/index.html?transactionId=${transactionId}&commandId=${commandId}&closeafteraction`,
+                userUrl: approveUrl,
             };
         },
         status: async () => {
@@ -221,21 +295,9 @@ export const dappController = (kernelInfo, dappUrl, userUrl, store, notification
                 userUrl: `${userUrl}/login/`,
             };
         },
-        connected: async () => {
-            throw new Error('Only for events.');
-        },
-        onStatusChanged: async () => {
-            throw new Error('Only for events.');
-        },
-        accountsChanged: async () => {
-            throw new Error('Only for events.');
-        },
         listAccounts: async () => {
             return await store.getWallets();
         },
-        txChanged: async () => {
-            throw new Error('Only for events.');
-        },
         getActiveNetwork: async () => {
             const network = await store.getCurrentNetwork();
             return {
@@ -284,11 +346,23 @@ export const dappController = (kernelInfo, dappUrl, userUrl, store, notification
             }
             return wallet;
         },
+        connected: async () => {
+            throw new Error('Only for events.');
+        },
+        onStatusChanged: async () => {
+            throw new Error('Only for events.');
+        },
+        accountsChanged: async () => {
+            throw new Error('Only for events.');
+        },
+        txChanged: async () => {
+            throw new Error('Only for events.');
+        },
         messageSignature: function () {
             throw new Error('Only for events.');
         },
     });
 };
-async function prepareSubmission(userId, partyId, synchronizerId, params, ledgerClient) {
-    return await ledgerClient.postWithRetry('/v2/interactive-submission/prepare', ledgerPrepareParams(userId, partyId, synchronizerId, params));
+async function prepareSubmission(userId, partyIds, synchronizerId, params, ledgerClient) {
+    return await ledgerClient.postWithRetry('/v2/interactive-submission/prepare', ledgerPrepareParams(userId, partyIds, synchronizerId, params));
 }

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

@@ -107,8 +107,8 @@ async function createStore(logger, context, options = {}) {
     }
     return store;
 }
-function createController(store, notificationService, logger, context, requestOrigin = origin) {
-    return dappController(kernelInfo, dappUrl, userUrl, store, notificationService, logger, requestOrigin, context);
+function createController(store, notificationService, logger, context, requestOrigin = origin, deps) {
+    return dappController(kernelInfo, dappUrl, userUrl, store, notificationService, logger, requestOrigin, deps || { signingDrivers: {} }, context);
 }
 describe('dappController', () => {
     let logger;

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

@@ -1,9 +1,10 @@
 import express from 'express';
 import { Logger } from 'pino';
 import { Store } from '@canton-network/core-wallet-store';
-import { AuthService, AuthAware } from '@canton-network/core-wallet-auth';
+import { AuthAware } from '@canton-network/core-wallet-auth';
 import { Server } from 'http';
 import { NotificationService } from '../notification/NotificationService.js';
 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("node:http").IncomingMessage, typeof import("node:http").ServerResponse>;
+import { DappControllerDeps } from './controller.js';
+export declare const dapp: (route: string, app: express.Express, logger: Logger, server: Server, kernelInfo: KernelInfo, dappUrl: string, userUrl: string, serverConfig: ServerConfig, notificationService: NotificationService, store: Store & AuthAware<Store>, controllerDeps: DappControllerDeps) => Server<typeof import("node:http").IncomingMessage, typeof import("node: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;AAC7B,OAAO,EAAE,mBAAmB,EAAE,MAAM,wCAAwC,CAAA;AAC5E,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAA;AAO9D,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,kGA4FlC,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,SAAS,EAAE,MAAM,kCAAkC,CAAA;AAC5D,OAAO,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAC7B,OAAO,EAAE,mBAAmB,EAAE,MAAM,wCAAwC,CAAA;AAC5E,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAA;AAC9D,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAA;AAOpD,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,OAAO,KAAK,GAAG,SAAS,CAAC,KAAK,CAAC,EAC/B,gBAAgB,kBAAkB,kGA6FrC,CAAA"}

package/dist/dapp-api/server.js

@@ -7,7 +7,7 @@ function writeSSE(res, event, data) {
     res.write(`event: ${event}\n`);
     res.write(`data: ${JSON.stringify(data)}\n\n`);
 }
-export const dapp = (route, app, logger, server, kernelInfo, dappUrl, userUrl, serverConfig, notificationService, authService, store) => {
+export const dapp = (route, app, logger, server, kernelInfo, dappUrl, userUrl, serverConfig, notificationService, store, controllerDeps) => {
     app.use(cors({
         origin: serverConfig.allowedOrigins,
     }));
@@ -67,7 +67,7 @@ export const dapp = (route, app, logger, server, kernelInfo, dappUrl, userUrl, s
     app.use(route, (req, res, next) => {
         const origin = req.headers.origin ?? null;
         jsonRpcHandler({
-            controller: dappController(kernelInfo, dappUrl, userUrl, store.withAuthContext(req.authContext), notificationService, logger, origin, req.authContext),
+            controller: dappController(kernelInfo, dappUrl, userUrl, store.withAuthContext(req.authContext), notificationService, logger, origin, controllerDeps, req.authContext),
             logger,
         })(req, res, next);
     });

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

@@ -11,11 +11,6 @@ import { NotificationService } from '../notification/NotificationService.js';
 import { pino } from 'pino';
 import { sink } from 'pino-test';
 import { createServer } from 'http';
-const authService = {
-    verifyToken: async () => {
-        return new Promise((resolve) => resolve({ userId: 'user123', accessToken: 'token123' }));
-    },
-};
 const configPath = '../test/config.json';
 const config = ConfigUtils.loadConfigFile(configPath);
 const store = new StoreInternal(config.bootstrap, pino(sink()));
@@ -26,7 +21,7 @@ test('call connect rpc', async () => {
     app.use(express.json());
     const server = createServer(app);
     const { dappApiUrl, publicUrl } = deriveUrls(config);
-    const response = await request(dapp('/api/v0/dapp', app, pino(sink()), server, config.kernel, dappApiUrl, publicUrl, config.server, notificationService, authService, store))
+    const response = await request(dapp('/api/v0/dapp', app, pino(sink()), server, config.kernel, dappApiUrl, publicUrl, config.server, notificationService, store, { signingDrivers: {} }))
         .post('/api/v0/dapp')
         .send({ jsonrpc: '2.0', id: 0, method: 'connect', params: [] })
         .set('Accept', 'application/json');

package/dist/example-config.d.ts

@@ -16,6 +16,9 @@ declare const _default: {
         requestRateLimit: number;
         trustProxy: false;
         admin: string;
+        signingWorker: {
+            pollInterval: number;
+        };
     };
     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,wBAkGqB"}
+{"version":3,"file":"example-config.d.ts","sourceRoot":"","sources":["../src/example-config.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKA,wBAqGqB"}

package/dist/example-config.js

@@ -18,6 +18,9 @@ export default {
         requestRateLimit: 10000,
         trustProxy: false,
         admin: 'sub',
+        signingWorker: {
+            pollInterval: 5000,
+        },
     },
     signingStore: {
         connection: {

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAkFA,QAAA,MAAM,OAAO;;;;;;;CAAiB,CAAA;AAE9B,MAAM,MAAM,UAAU,GAAG,OAAO,OAAO,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AA4FA,QAAA,MAAM,OAAO;;;;;;;CAAiB,CAAA;AAE9B,MAAM,MAAM,UAAU,GAAG,OAAO,OAAO,CAAA"}

package/dist/index.js

@@ -13,6 +13,7 @@ import z from 'zod';
 import { rawConfigSchema } from './config/Config.js';
 import exampleConfig from './example-config.js';
 import { GATEWAY_VERSION } from './version.js';
+import { nestedRedact } from './utils.js';
 const program = new Command()
     .name('wallet-gateway')
     .version(GATEWAY_VERSION)
@@ -49,6 +50,15 @@ const program = new Command()
     // Define project-global logger
     const logger = pino({
         name: 'main',
+        redact: {
+            paths: nestedRedact([
+                'accessToken',
+                'access_token',
+                'clientSecret',
+                'jwt',
+            ]),
+            censor: '*****',
+        },
         level: logLevel,
         ...(logFormat === 'pretty'
             ? {

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;AA2B7B,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAsMvC,wBAAsB,UAAU,CAAC,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,iBAkKhE"}
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../src/init.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAyB7B,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAyMvC,wBAAsB,UAAU,CAAC,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,iBAmLhE"}

package/dist/init.js

@@ -6,7 +6,7 @@ import { web } from './web/server.js';
 import { StoreSql, bootstrap, connection, migrator, } from '@canton-network/core-wallet-store-sql';
 import { StoreSql as SigningStoreSql, bootstrap as signingBootstrap, connection as signingConnection, migrator as signingMigrator, } from '@canton-network/core-signing-store-sql';
 import { ConfigUtils } from './config/ConfigUtils.js';
-import { SigningProvider, } from '@canton-network/core-signing-lib';
+import { SigningProvider } from '@canton-network/core-signing-lib';
 import { ParticipantSigningDriver } from '@canton-network/core-signing-participant';
 import { InternalSigningDriver } from '@canton-network/core-signing-internal';
 import DfnsSigningProvider from '@canton-network/core-signing-dfns';
@@ -23,7 +23,10 @@ import { sessionHandler } from './middleware/sessionHandler.js';
 import { NotificationService } from './notification/NotificationService.js';
 import { sql } from 'kysely';
 import { Env } from './env.js';
+import { SigningWorker } from './signing/signing-worker.js';
+import { apiKeyAuth } from './middleware/apiKeyAuth.js';
 let isReady = false;
+let signingWorker;
 async function initializeDatabase(config, logger) {
     logger.info('Checking for database migrations...');
     let exists = true;
@@ -227,15 +230,24 @@ export async function initialize(opts, logger) {
             'selfSignedAccessToken',
         ],
     };
-    app.use('/api/*splat', express.json());
-    app.use('/api/*splat', preAuthRateLimit);
-    app.use('/api/*splat', jwtAuth(authService, logger.child({ component: 'JwtHandler' })));
-    app.use('/api/*splat', postAuthRateLimit);
-    app.use('/api/*splat', sessionHandler(store, allowedPaths, logger.child({ component: 'SessionHandler' })));
+    app.use('/api/*splat', express.json(), preAuthRateLimit, apiKeyAuth(store, config.server.dappPath, logger.child({ component: 'ApiKeyHandler' })), jwtAuth(authService, logger.child({ component: 'JwtHandler' })), postAuthRateLimit, sessionHandler(store, allowedPaths, logger.child({ component: 'SessionHandler' })));
     logger.info({ ...config.server, port }, 'Server configuration');
     const kernelInfo = config.kernel;
+    const signingWorkerLogger = logger.child({
+        component: 'SigningWorker',
+    });
+    signingWorker = new SigningWorker({
+        intervalMs: config.server.signingWorker.pollInterval,
+        signingDrivers: drivers,
+        store,
+        notificationService,
+        logger: signingWorkerLogger,
+    });
+    signingWorker.start();
     // register dapp API handlers
-    dapp(config.server.dappPath, app, logger, server, kernelInfo, dappApiUrl, publicUrl, config.server, notificationService, authService, store);
+    dapp(config.server.dappPath, app, logger, server, kernelInfo, dappApiUrl, publicUrl, config.server, notificationService, store, {
+        signingDrivers: drivers,
+    });
     // register user API handlers
     user(config.server.userPath, app, logger, kernelInfo, publicUrl, notificationService, drivers, store, config.server.admin);
     // register web handler

package/dist/ledger/transaction-service.d.ts

@@ -2,35 +2,40 @@ import { Logger } from 'pino';
 import { LedgerClient } from '@canton-network/core-ledger-client';
 import { Store, Transaction, Wallet, Network } from '@canton-network/core-wallet-store';
 import type { SignResult } from '../user-api/rpc-gen/typings.js';
-import { SigningDriverInterface, SigningProvider } from '@canton-network/core-signing-lib';
-import { ExecuteParams, ExecuteResult, SignParams, SignResultSigned } from '../user-api/rpc-gen/typings.js';
+import type { SigningDrivers } from '../signing/signing-drivers.js';
+import { ExecuteParams, ExecuteResult, SignParams } from '../user-api/rpc-gen/typings.js';
 import { UserId } from '../dapp-api/rpc-gen/typings.js';
 import { Notifier } from '../notification/NotificationService.js';
+import { AuthContext } from '@canton-network/core-wallet-auth';
+export type SignAndExecuteResult = SignResult | ExecuteResult;
 export declare class TransactionService {
     private store;
     private logger;
     private signingDrivers;
     private notifier;
-    constructor(store: Store, logger: Logger, signingDrivers: Partial<Record<SigningProvider, SigningDriverInterface>> | undefined, notifier: Notifier);
+    constructor(store: Store, logger: Logger, signingDrivers: SigningDrivers | undefined, notifier: Notifier);
+    sign(authContext: AuthContext, wallet: Wallet, signParams: SignParams): Promise<SignResult>;
+    execute(userId: UserId, wallet: Wallet, transaction: Transaction, executeParams?: ExecuteParams, ledgerClient?: LedgerClient, network?: Network): Promise<ExecuteResult>;
+    signAndExecute(authContext: AuthContext, network: Network, wallet: Wallet, transaction: Transaction): Promise<SignAndExecuteResult>;
     private loadPreparedTransactionForSigning;
-    signWithParticipant(wallet: Wallet): SignResultSigned;
-    signWithWalletKernel(userId: UserId, wallet: Wallet, signParams: SignParams): Promise<SignResultSigned>;
-    signWithBlockdaemon(userId: UserId, wallet: Wallet, signParams: SignParams): Promise<SignResult>;
-    signWithFireblocks(userId: UserId, wallet: Wallet, signParams: SignParams): Promise<SignResult>;
+    private signWithParticipant;
+    private signWithWalletKernel;
+    private signWithBlockdaemon;
+    private signWithFireblocks;
     /**
      * Dfns broadcasts the prepared transaction to Canton itself, so we get back
      * an updateId rather than a raw signature. We persist the updateId as the
      * signature payload (the controller short-circuits Dfns execute) and surface
      * the same SignResult shape the other external providers use.
      */
-    signWithDfns(userId: UserId, wallet: Wallet, signParams: SignParams): Promise<SignResult>;
+    private signWithDfns;
     /**
      * Dfns has already broadcast the transaction at sign-time, so execute is a
      * state reconciliation: mark the stored transaction as executed and return
      * the updateId Dfns gave us. We deliberately don't post to the ledger here.
      */
-    executeWithDfns(transaction: Transaction): Promise<ExecuteResult>;
-    executeWithParticipant(userId: UserId, executeParams: ExecuteParams, transaction: Transaction, ledgerClient: LedgerClient, network: Network): Promise<ExecuteResult>;
-    executeWithExternal(userId: UserId, executeParams: ExecuteParams, transaction: Transaction, ledgerClient: LedgerClient): Promise<ExecuteResult>;
+    private executeWithDfns;
+    private executeWithParticipant;
+    private executeWithExternal;
 }
 //# sourceMappingURL=transaction-service.d.ts.map

package/dist/ledger/transaction-service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transaction-service.d.ts","sourceRoot":"","sources":["../../src/ledger/transaction-service.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAC7B,OAAO,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAA;AACjE,OAAO,EACH,KAAK,EACL,WAAW,EACX,MAAM,EACN,OAAO,EACV,MAAM,mCAAmC,CAAA;AAC1C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAA;AAChE,OAAO,EAGH,sBAAsB,EACtB,eAAe,EAElB,MAAM,kCAAkC,CAAA;AACzC,OAAO,EACH,aAAa,EACb,aAAa,EACb,UAAU,EACV,gBAAgB,EACnB,MAAM,gCAAgC,CAAA;AACvC,OAAO,EAAE,MAAM,EAAE,MAAM,gCAAgC,CAAA;AACvD,OAAO,EAAE,QAAQ,EAAE,MAAM,wCAAwC,CAAA;AAYjE,qBAAa,kBAAkB;IAEvB,OAAO,CAAC,KAAK;IACb,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,cAAc;IAGtB,OAAO,CAAC,QAAQ;gBALR,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,MAAM,EACd,cAAc,EAAE,OAAO,CAC3B,MAAM,CAAC,eAAe,EAAE,sBAAsB,CAAC,CAClD,YAAK,EACE,QAAQ,EAAE,QAAQ;YAGhB,iCAAiC;IAWxC,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,gBAAgB;IAS/C,oBAAoB,CAC7B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,UAAU,GACvB,OAAO,CAAC,gBAAgB,CAAC;IAqDf,mBAAmB,CAC5B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,UAAU,GACvB,OAAO,CAAC,UAAU,CAAC;IAwGT,kBAAkB,CAC3B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,UAAU,GACvB,OAAO,CAAC,UAAU,CAAC;IA4GtB;;;;;OAKG;IACU,YAAY,CACrB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,UAAU,GACvB,OAAO,CAAC,UAAU,CAAC;IAkGtB;;;;OAIG;IACU,eAAe,CACxB,WAAW,EAAE,WAAW,GACzB,OAAO,CAAC,aAAa,CAAC;IA8BZ,sBAAsB,CAC/B,MAAM,EAAE,MAAM,EACd,aAAa,EAAE,aAAa,EAC5B,WAAW,EAAE,WAAW,EACxB,YAAY,EAAE,YAAY,EAC1B,OAAO,EAAE,OAAO,GACjB,OAAO,CAAC,aAAa,CAAC;IAyCZ,mBAAmB,CAC5B,MAAM,EAAE,MAAM,EACd,aAAa,EAAE,aAAa,EAC5B,WAAW,EAAE,WAAW,EACxB,YAAY,EAAE,YAAY,GAC3B,OAAO,CAAC,aAAa,CAAC;CAuD5B"}
+{"version":3,"file":"transaction-service.d.ts","sourceRoot":"","sources":["../../src/ledger/transaction-service.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAC7B,OAAO,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAA;AACjE,OAAO,EACH,KAAK,EACL,WAAW,EACX,MAAM,EACN,OAAO,EACV,MAAM,mCAAmC,CAAA;AAC1C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAA;AAOhE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AACnE,OAAO,EACH,aAAa,EACb,aAAa,EACb,UAAU,EAEb,MAAM,gCAAgC,CAAA;AACvC,OAAO,EAAE,MAAM,EAAE,MAAM,gCAAgC,CAAA;AACvD,OAAO,EAAE,QAAQ,EAAE,MAAM,wCAAwC,CAAA;AAMjE,OAAO,EACH,WAAW,EAEd,MAAM,kCAAkC,CAAA;AAEzC,MAAM,MAAM,oBAAoB,GAAG,UAAU,GAAG,aAAa,CAAA;AAW7D,qBAAa,kBAAkB;IAEvB,OAAO,CAAC,KAAK;IACb,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,cAAc;IACtB,OAAO,CAAC,QAAQ;gBAHR,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,MAAM,EACd,cAAc,EAAE,cAAc,YAAK,EACnC,QAAQ,EAAE,QAAQ;IAGjB,IAAI,CACb,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,UAAU,GACvB,OAAO,CAAC,UAAU,CAAC;IAiDf,OAAO,CACV,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,WAAW,EACxB,aAAa,CAAC,EAAE,aAAa,EAC7B,YAAY,CAAC,EAAE,YAAY,EAC3B,OAAO,CAAC,EAAE,OAAO,GAClB,OAAO,CAAC,aAAa,CAAC;IAiEZ,cAAc,CACvB,WAAW,EAAE,WAAW,EACxB,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,WAAW,GACzB,OAAO,CAAC,oBAAoB,CAAC;YAyDlB,iCAAiC;IAkB/C,OAAO,CAAC,mBAAmB;YASb,oBAAoB;YAyDpB,mBAAmB;YAiHnB,kBAAkB;IAqHhC;;;;;OAKG;YACW,YAAY;IA2G1B;;;;OAIG;YACW,eAAe;YAgCf,sBAAsB;YAoDtB,mBAAmB;CAiEpC"}