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

package/dist/dapp-api/controller.js

@@ -4,7 +4,8 @@ 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';
+import { networkStatus, ledgerPrepareParams, logDynamically } from '../utils.js';
+import { rpcErrors } from '@canton-network/core-rpc-errors';
 export const dappController = (kernelInfo, dappUrl, userUrl, store, notificationService, _logger, origin, context) => {
     const logger = _logger.child({ component: 'dapp-controller' });
     return buildController({
@@ -127,6 +128,7 @@ export const dappController = (kernelInfo, dappUrl, userUrl, store, notification
         },
         prepareExecute: async (params) => {
             const wallet = await store.getPrimaryWallet();
+            const wallets = await store.getWallets();
             const network = await store.getCurrentNetwork();
             if (context === undefined) {
                 throw new Error('Unauthenticated context');
@@ -134,26 +136,54 @@ export const dappController = (kernelInfo, dappUrl, userUrl, store, notification
             if (wallet === undefined) {
                 throw new Error('No primary wallet found');
             }
+            let userId = context.userId;
+            const accessTokenProvider = AuthTokenProvider.fromToken(context.accessToken, logger);
+            if (context?.isApiKey) {
+                logger.info('Authenticated with API Key, fetching m2m token for ledger access');
+                userId = context.ledgerUserId;
+            }
             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 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);
+            let actAs = [wallet.partyId];
+            if (params.actAs && params.actAs.length > 0) {
+                actAs = params.actAs;
+                for (const actingParty of actAs) {
+                    if (wallets.find((w) => w.partyId === actingParty) ===
+                        undefined) {
+                        throw rpcErrors.invalidRequest(`Acting party ${actingParty} does not belong to user`);
+                    }
+                }
+            }
+            logDynamically(logger, 'prepareExecute: Submitting request to ledger', {
+                info: { transactionId },
+                debug: { commandId, userId, actAs },
+            });
+            const actAsParty = params.actAs || [wallet.partyId];
+            const prepared = await prepareSubmission(context.userId, actAsParty, synchronizerId, params, ledgerClient);
+            logDynamically(logger, 'prepareExecute: Received response from ledger', {
+                info: { transactionId },
+                debug: {
+                    commandId,
+                    userId,
+                    partyId: actAsParty,
+                    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(),
@@ -161,10 +191,10 @@ export const dappController = (kernelInfo, dappUrl, userUrl, store, notification
             logger.info({
                 actAs: params.actAs || [wallet.partyId],
                 readAs: params.readAs || [],
-                userId: context.userId,
+                userId,
                 commandId,
                 commands: params.commands?.[0],
-                confirmationRequestTrafficCostEstimation: response.costEstimation
+                confirmationRequestTrafficCostEstimation: prepared.costEstimation
                     ?.confirmationRequestTrafficCostEstimation,
             }, 'prepared transaction traffic estimation');
             await store.setTransaction(transaction);
@@ -221,21 +251,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 +302,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/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;AAuMvC,wBAAsB,UAAU,CAAC,IAAI,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,iBAoKhE"}

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,6 +23,7 @@ import { sessionHandler } from './middleware/sessionHandler.js';
 import { NotificationService } from './notification/NotificationService.js';
 import { sql } from 'kysely';
 import { Env } from './env.js';
+import { apiKeyAuth } from './middleware/apiKeyAuth.js';
 let isReady = false;
 async function initializeDatabase(config, logger) {
     logger.info('Checking for database migrations...');
@@ -227,11 +228,7 @@ 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;
     // register dapp API handlers

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

@@ -2,35 +2,38 @@ 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 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>;
     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,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAA;AAW9D,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;YA6DX,iCAAiC;IAW/C,OAAO,CAAC,mBAAmB;YASb,oBAAoB;YAyDpB,mBAAmB;YAiHnB,kBAAkB;IAqHhC;;;;;OAKG;YACW,YAAY;IA2G1B;;;;OAIG;YACW,eAAe;YAgCf,sBAAsB;YAoDtB,mBAAmB;CAiEpC"}

package/dist/ledger/transaction-service.js

@@ -1,7 +1,7 @@
 // Copyright (c) 2025-2026 Digital Asset (Switzerland) GmbH and/or its affiliates. All rights reserved.
 // SPDX-License-Identifier: Apache-2.0
 import { SigningProvider, } from '@canton-network/core-signing-lib';
-import { ledgerPrepareParams } from '../utils.js';
+import { ledgerPrepareParams, logDynamically, } from '../utils.js';
 function handleSigningError(result) {
     if ('error' in result) {
         throw new Error(`Error from signing driver: ${result.error_description}`);
@@ -15,6 +15,73 @@ export class TransactionService {
         this.signingDrivers = signingDrivers;
         this.notifier = notifier;
     }
+    async sign(authContext, wallet, signParams) {
+        const signingProvider = wallet.signingProviderId;
+        const driver = this.signingDrivers[signingProvider]?.controller(authContext.userId);
+        if (!driver) {
+            throw new Error(`No driver found for ${signingProvider}`);
+        }
+        switch (signingProvider) {
+            case SigningProvider.PARTICIPANT: {
+                return this.signWithParticipant(wallet);
+            }
+            case SigningProvider.WALLET_KERNEL: {
+                return this.signWithWalletKernel(authContext.userId, wallet, signParams);
+            }
+            case SigningProvider.BLOCKDAEMON: {
+                if (!authContext.email) {
+                    throw new Error('Email is required for Blockdaemon wallet allocation');
+                }
+                return this.signWithBlockdaemon(authContext.email, wallet, signParams);
+            }
+            case SigningProvider.FIREBLOCKS: {
+                return this.signWithFireblocks(authContext.userId, wallet, signParams);
+            }
+            case SigningProvider.DFNS: {
+                return this.signWithDfns(authContext.userId, wallet, signParams);
+            }
+            default:
+                throw new Error(`Unsupported signing provider: ${wallet.signingProviderId}`);
+        }
+    }
+    execute(userId, wallet, transaction, executeParams, ledgerClient, network) {
+        switch (wallet.signingProviderId) {
+            case SigningProvider.PARTICIPANT: {
+                try {
+                    if (!executeParams) {
+                        throw new Error('Execute params are required for participant signing');
+                    }
+                    if (!ledgerClient) {
+                        throw new Error('Ledger client is required for participant signing');
+                    }
+                    if (!network) {
+                        throw new Error('Network is required for participant signing');
+                    }
+                    return this.executeWithParticipant(userId, executeParams, transaction, ledgerClient, network);
+                }
+                catch (error) {
+                    this.logger.error(error, 'Failed to submit transaction');
+                    throw error;
+                }
+            }
+            case SigningProvider.WALLET_KERNEL:
+            case SigningProvider.BLOCKDAEMON:
+            case SigningProvider.FIREBLOCKS: {
+                if (!executeParams) {
+                    throw new Error('Execute params are required for external signing');
+                }
+                if (!ledgerClient) {
+                    throw new Error('Ledger client is required for external signing');
+                }
+                return this.executeWithExternal(userId, executeParams, transaction, ledgerClient);
+            }
+            case SigningProvider.DFNS: {
+                return this.executeWithDfns(transaction);
+            }
+            default:
+                throw new Error(`Unsupported signing provider: ${wallet.signingProviderId}`);
+        }
+    }
     async loadPreparedTransactionForSigning(transactionId) {
         const existingTx = await this.store.getTransaction(transactionId);
         if (!existingTx) {
@@ -79,7 +146,7 @@ export class TransactionService {
         const driver = signingProvider.controller(userId);
         const tx = await this.loadPreparedTransactionForSigning(signParams.transactionId);
         let signingResult;
-        if (tx && tx.externalTxId) {
+        if (tx.externalTxId) {
             signingResult = await driver
                 .getTransaction({
                 userId,
@@ -104,6 +171,10 @@ export class TransactionService {
                 .then(handleSigningError);
         }
         const now = new Date();
+        logDynamically(this.logger, 'Blockdaemon signing result', {
+            info: { transactionId: tx.id, status: signingResult.status },
+            debug: { signingResult, tx },
+        });
         if (signingResult.status === 'signed') {
             if (!signingResult.signature) {
                 throw new Error('No signature returned from signing driver');
@@ -164,7 +235,7 @@ export class TransactionService {
         const driver = signingProvider.controller(userId);
         const tx = await this.loadPreparedTransactionForSigning(signParams.transactionId);
         let signingResult;
-        if (tx && tx.externalTxId) {
+        if (tx.externalTxId) {
             signingResult = await driver
                 .getTransaction({
                 userId,
@@ -185,6 +256,10 @@ export class TransactionService {
                 .then(handleSigningError);
         }
         const now = new Date();
+        logDynamically(this.logger, 'Fireblocks signing result', {
+            info: { transactionId: tx.id, status: signingResult.status },
+            debug: { signingResult, tx },
+        });
         if (signingResult.status === 'signed') {
             if (!signingResult.signature) {
                 throw new Error('No signature returned from signing driver');
@@ -273,6 +348,10 @@ export class TransactionService {
                 .then(handleSigningError);
         }
         const now = new Date();
+        logDynamically(this.logger, 'Dfns signing result', {
+            info: { transactionId: tx.id, status: signingResult.status },
+            debug: { signingResult, tx },
+        });
         if (signingResult.status === 'signed') {
             if (!signingResult.signature) {
                 throw new Error('No updateId returned from Dfns');
@@ -359,15 +438,19 @@ export class TransactionService {
         const { partyId } = executeParams;
         const { commandId } = transaction;
         const synchronizerId = network.synchronizerId ?? (await ledgerClient.getSynchronizerId());
-        const prep = ledgerPrepareParams(userId, partyId, synchronizerId, transaction.payload);
-        const res = await ledgerClient.postWithRetry('/v2/commands/submit-and-wait', prep);
+        const prep = ledgerPrepareParams(userId, [partyId], synchronizerId, transaction.payload);
+        const result = await ledgerClient.postWithRetry('/v2/commands/submit-and-wait', prep);
+        logDynamically(this.logger, 'Participant execution result', {
+            info: { transactionId: transaction.id },
+            debug: { result, transaction, executeParams, userId },
+        });
         const executedTx = {
             id: transaction.id,
             commandId,
             status: 'executed',
             preparedTransaction: transaction.preparedTransaction,
             preparedTransactionHash: transaction.preparedTransactionHash,
-            payload: res,
+            payload: result,
             origin: transaction.origin ?? null,
             ...(transaction.createdAt && {
                 createdAt: transaction.createdAt,
@@ -377,10 +460,10 @@ export class TransactionService {
             }),
         };
         await this.store.setTransactionStatus(transaction.id, 'executed', {
-            payload: res,
+            payload: result,
         });
         this.notifier.emit('txChanged', executedTx);
-        return res;
+        return result;
     }
     async executeWithExternal(userId, executeParams, transaction, ledgerClient) {
         const { partyId, signature, signedBy } = executeParams;
@@ -409,6 +492,10 @@ export class TransactionService {
                 ],
             },
         });
+        logDynamically(this.logger, 'Externally signed execution result', {
+            info: { transactionId: transaction.id },
+            debug: { result, transaction, executeParams, userId },
+        });
         const executedTx = {
             id: transaction.id,
             commandId,

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=transaction-service.test.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"transaction-service.test.d.ts","sourceRoot":"","sources":["../../src/ledger/transaction-service.test.ts"],"names":[],"mappings":""}