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

package/dist/ledger/transaction-service.js

@@ -1,7 +1,9 @@
 // Copyright (c) 2025-2026 Digital Asset (Switzerland) GmbH and/or its affiliates. All rights reserved.
 // SPDX-License-Identifier: Apache-2.0
+import { LedgerClient } from '@canton-network/core-ledger-client';
 import { SigningProvider, } from '@canton-network/core-signing-lib';
-import { ledgerPrepareParams } from '../utils.js';
+import { ledgerPrepareParams, logDynamically, } from '../utils.js';
+import { AuthTokenProvider, } from '@canton-network/core-wallet-auth';
 function handleSigningError(result) {
     if ('error' in result) {
         throw new Error(`Error from signing driver: ${result.error_description}`);
@@ -15,11 +17,116 @@ 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) {
+        if (transaction.status === 'executed') {
+            throw new Error('Transaction is already executed.');
+        }
+        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 signAndExecute(authContext, network, wallet, transaction) {
+        const signParams = {
+            transactionId: transaction.id,
+            partyId: wallet.partyId,
+        };
+        const signResult = await this.sign(authContext, wallet, signParams);
+        if (signResult.status === 'pending') {
+            return signResult;
+        }
+        if (signResult.status !== 'signed') {
+            throw new Error(`Service account signing failed with status: ${signResult.status}`);
+        }
+        if (!('signature' in signResult) ||
+            signResult.signature === undefined) {
+            throw new Error('Service account signing did not return a signature');
+        }
+        const ledgerClient = new LedgerClient({
+            baseUrl: new URL(network.ledgerApi.baseUrl),
+            logger: this.logger,
+            accessTokenProvider: AuthTokenProvider.fromToken(authContext.accessToken, this.logger),
+        });
+        const executeParams = {
+            transactionId: transaction.id,
+            partyId: wallet.partyId,
+            signature: signResult.signature,
+            signedBy: signResult.signedBy,
+        };
+        const userId = authContext.isApiKey
+            ? authContext.ledgerUserId
+            : authContext.userId;
+        return this.execute(userId, wallet, transaction, executeParams, ledgerClient, network);
+    }
     async loadPreparedTransactionForSigning(transactionId) {
         const existingTx = await this.store.getTransaction(transactionId);
         if (!existingTx) {
             throw new Error(`Transaction not found with id: ${transactionId}`);
         }
+        if (existingTx.status !== 'pending') {
+            throw new Error(`Cannot sign an already ${existingTx.status} transaction`);
+        }
         return existingTx;
     }
     signWithParticipant(wallet) {
@@ -79,7 +186,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 +211,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 +275,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 +296,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 +388,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 +478,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 +500,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 +532,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":""}

package/dist/ledger/transaction-service.test.js

@@ -0,0 +1,390 @@
+// Copyright (c) 2025-2026 Digital Asset (Switzerland) GmbH and/or its affiliates. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { pino } from 'pino';
+import { sink } from 'pino-test';
+import { SigningProvider, } from '@canton-network/core-signing-lib';
+import { TransactionService } from './transaction-service.js';
+const authContext = {
+    userId: 'user-1',
+    accessToken: 'access-token-1',
+};
+const authContextWithEmail = {
+    ...authContext,
+    email: 'user@example.com',
+};
+const wallet = {
+    primary: true,
+    partyId: 'party::namespace',
+    status: 'allocated',
+    hint: 'party',
+    signingProviderId: SigningProvider.WALLET_KERNEL,
+    publicKey: 'wallet-public-key',
+    namespace: 'namespace',
+    networkId: 'network1',
+    rights: [],
+};
+const pendingTransaction = {
+    id: 'tx-1',
+    commandId: 'cmd-1',
+    status: 'pending',
+    preparedTransaction: 'prepared-tx',
+    preparedTransactionHash: 'tx-hash',
+    origin: 'https://dapp.example',
+    createdAt: new Date('2026-01-01T00:00:00.000Z'),
+};
+const signParams = {
+    transactionId: pendingTransaction.id,
+    partyId: wallet.partyId,
+};
+const executeParams = {
+    transactionId: pendingTransaction.id,
+    partyId: wallet.partyId,
+    signature: 'signature',
+    signedBy: wallet.namespace,
+};
+const network = {
+    id: 'network1',
+    name: 'testnet',
+    synchronizerId: 'sync::fingerprint',
+    description: 'Test',
+    identityProviderId: 'idp1',
+    ledgerApi: { baseUrl: 'http://ledger.test' },
+    auth: {
+        method: 'authorization_code',
+        clientId: 'cid',
+        scope: 'scope',
+        audience: 'aud',
+    },
+};
+function walletWithProvider(signingProviderId) {
+    return { ...wallet, signingProviderId };
+}
+function createDriver(options) {
+    return {
+        controller: vi.fn().mockReturnValue({
+            signTransaction: options.signTransaction ??
+                vi.fn().mockResolvedValue({ signature: 'driver-signature' }),
+            getTransaction: options.getTransaction ?? vi.fn().mockResolvedValue({}),
+        }),
+    };
+}
+function createStore(transaction = pendingTransaction) {
+    return {
+        getTransaction: vi.fn().mockResolvedValue(transaction),
+        setTransactionSigned: vi.fn().mockResolvedValue(undefined),
+        setTransactionStatus: vi.fn().mockResolvedValue(undefined),
+    };
+}
+function createService(store, drivers, notifier, logger) {
+    return new TransactionService(store, logger, drivers, notifier);
+}
+describe('TransactionService', () => {
+    let logger;
+    let notifier;
+    let emit;
+    beforeEach(() => {
+        logger = pino({ level: 'silent' }, sink());
+        emit = vi.fn();
+        notifier = { emit };
+    });
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('sign', () => {
+        describe('participant', () => {
+            it('returns a signed result without calling external drivers', async () => {
+                const store = createStore();
+                const service = createService(store, {
+                    [SigningProvider.PARTICIPANT]: createDriver({}),
+                }, notifier, logger);
+                const participantWallet = walletWithProvider(SigningProvider.PARTICIPANT);
+                const result = await service.sign(authContext, participantWallet, signParams);
+                expect(result).toEqual({
+                    status: 'signed',
+                    signature: 'none',
+                    signedBy: wallet.namespace,
+                    partyId: wallet.partyId,
+                });
+                expect(store.getTransaction).not.toHaveBeenCalled();
+            });
+        });
+        describe('wallet-kernel', () => {
+            it('signs the transaction and persists the signed state', async () => {
+                const signTransaction = vi
+                    .fn()
+                    .mockResolvedValue({ signature: 'kernel-signature' });
+                const store = createStore();
+                const service = createService(store, {
+                    [SigningProvider.WALLET_KERNEL]: createDriver({
+                        signTransaction,
+                    }),
+                }, notifier, logger);
+                const result = await service.sign(authContext, wallet, signParams);
+                expect(signTransaction).toHaveBeenCalledWith({
+                    tx: pendingTransaction.preparedTransaction,
+                    txHash: pendingTransaction.preparedTransactionHash,
+                    keyIdentifier: { publicKey: wallet.publicKey },
+                });
+                expect(store.setTransactionSigned).toHaveBeenCalledWith(pendingTransaction.id, expect.any(Date));
+                expect(emit).toHaveBeenCalledWith('txChanged', expect.objectContaining({
+                    id: pendingTransaction.id,
+                    status: 'signed',
+                }));
+                expect(result).toEqual({
+                    status: 'signed',
+                    signature: 'kernel-signature',
+                    signedBy: wallet.namespace,
+                    partyId: wallet.partyId,
+                });
+            });
+            it('throws when the wallet-kernel driver is missing', async () => {
+                const service = createService(createStore(), {}, notifier, logger);
+                await expect(service.sign(authContext, wallet, signParams)).rejects.toThrow('No driver found for wallet-kernel');
+            });
+            it('throws when the transaction does not exist', async () => {
+                const store = createStore();
+                store.getTransaction.mockResolvedValue(undefined);
+                const service = createService(store, {
+                    [SigningProvider.WALLET_KERNEL]: createDriver({}),
+                }, notifier, logger);
+                await expect(service.sign(authContext, wallet, signParams)).rejects.toThrow('Transaction not found with id: tx-1');
+            });
+            it('throws when the driver returns an RPC error', async () => {
+                const signTransaction = vi.fn().mockResolvedValue({
+                    error: 'access_denied',
+                    error_description: 'Signing rejected',
+                });
+                const service = createService(createStore(), {
+                    [SigningProvider.WALLET_KERNEL]: createDriver({
+                        signTransaction,
+                    }),
+                }, notifier, logger);
+                await expect(service.sign(authContext, wallet, signParams)).rejects.toThrow('Error from signing driver: Signing rejected');
+            });
+        });
+        describe('blockdaemon', () => {
+            const blockdaemonWallet = walletWithProvider(SigningProvider.BLOCKDAEMON);
+            it('throws when email is missing from auth context', async () => {
+                const service = createService(createStore(), {
+                    [SigningProvider.BLOCKDAEMON]: createDriver({}),
+                }, notifier, logger);
+                await expect(service.sign(authContext, blockdaemonWallet, signParams)).rejects.toThrow('Email is required for Blockdaemon wallet allocation');
+            });
+            it('starts signing when there is no external transaction id yet', async () => {
+                const signTransaction = vi.fn().mockResolvedValue({
+                    status: 'pending',
+                    txId: 'external-tx-1',
+                });
+                const store = createStore();
+                const service = createService(store, {
+                    [SigningProvider.BLOCKDAEMON]: createDriver({
+                        signTransaction,
+                    }),
+                }, notifier, logger);
+                const result = await service.sign(authContextWithEmail, blockdaemonWallet, signParams);
+                expect(signTransaction).toHaveBeenCalledWith(expect.objectContaining({
+                    tx: pendingTransaction.preparedTransaction,
+                    internalTxId: expect.any(String),
+                }));
+                expect(store.setTransactionStatus).toHaveBeenCalledWith(pendingTransaction.id, 'pending', { externalTxId: 'external-tx-1' });
+                expect(result).toEqual({
+                    status: 'pending',
+                    externalTxId: 'external-tx-1',
+                    partyId: wallet.partyId,
+                });
+            });
+            it('fetches transaction when an external transaction id already exists', async () => {
+                const getTransaction = vi.fn().mockResolvedValue({
+                    status: 'signed',
+                    txId: 'external-tx-1',
+                    signature: 'bd-signature',
+                });
+                const store = createStore({
+                    ...pendingTransaction,
+                    externalTxId: 'external-tx-1',
+                });
+                const service = createService(store, {
+                    [SigningProvider.BLOCKDAEMON]: createDriver({
+                        getTransaction,
+                    }),
+                }, notifier, logger);
+                const result = await service.sign(authContextWithEmail, blockdaemonWallet, signParams);
+                expect(getTransaction).toHaveBeenCalledWith({
+                    userId: authContextWithEmail.email,
+                    txId: 'external-tx-1',
+                });
+                expect(store.setTransactionSigned).toHaveBeenCalledWith(pendingTransaction.id, expect.any(Date), 'external-tx-1');
+                expect(result).toMatchObject({
+                    status: 'signed',
+                    signature: 'bd-signature',
+                    externalTxId: 'external-tx-1',
+                });
+            });
+        });
+        describe('fireblocks', () => {
+            it('returns a base64 signature when signing completes', async () => {
+                const hexSignature = Buffer.from('fireblocks-signature').toString('hex');
+                const signTransaction = vi.fn().mockResolvedValue({
+                    status: 'signed',
+                    txId: 'fb-tx-1',
+                    signature: hexSignature,
+                });
+                const store = createStore();
+                const service = createService(store, {
+                    [SigningProvider.FIREBLOCKS]: createDriver({
+                        signTransaction,
+                    }),
+                }, notifier, logger);
+                const result = await service.sign(authContext, walletWithProvider(SigningProvider.FIREBLOCKS), signParams);
+                expect(signTransaction).toHaveBeenCalledWith(expect.objectContaining({
+                    userId: authContext.userId,
+                    txHash: Buffer.from(pendingTransaction.preparedTransactionHash, 'base64').toString('hex'),
+                }));
+                expect(result).toMatchObject({
+                    status: 'signed',
+                    signature: Buffer.from(hexSignature, 'hex').toString('base64'),
+                    externalTxId: 'fb-tx-1',
+                });
+            });
+        });
+        describe('dfns', () => {
+            it('persists the update id as the signature when signing completes', async () => {
+                const signTransaction = vi.fn().mockResolvedValue({
+                    status: 'signed',
+                    txId: 'dfns-tx-1',
+                    signature: 'update-id-123',
+                });
+                const store = createStore();
+                const service = createService(store, {
+                    [SigningProvider.DFNS]: createDriver({
+                        signTransaction,
+                    }),
+                }, notifier, logger);
+                const result = await service.sign(authContext, walletWithProvider(SigningProvider.DFNS), signParams);
+                expect(result).toEqual({
+                    status: 'signed',
+                    signature: 'update-id-123',
+                    signedBy: wallet.namespace,
+                    partyId: wallet.partyId,
+                    externalTxId: 'dfns-tx-1',
+                });
+            });
+        });
+    });
+    describe('execute', () => {
+        describe('dfns', () => {
+            it('marks the transaction executed using the external tx id', async () => {
+                const signedTransaction = {
+                    ...pendingTransaction,
+                    status: 'signed',
+                    externalTxId: 'dfns-update-id',
+                };
+                const store = createStore(signedTransaction);
+                const service = createService(store, {}, notifier, logger);
+                const result = await service.execute(authContext.userId, walletWithProvider(SigningProvider.DFNS), signedTransaction);
+                expect(store.setTransactionStatus).toHaveBeenCalledWith(signedTransaction.id, 'executed', { externalTxId: 'dfns-update-id' });
+                expect(emit).toHaveBeenCalledWith('txChanged', expect.objectContaining({ status: 'executed' }));
+                expect(result).toEqual({ updateId: 'dfns-update-id' });
+            });
+            it('throws when the transaction has no external tx id', async () => {
+                const service = createService(createStore(), {}, notifier, logger);
+                await expect(service.execute(authContext.userId, walletWithProvider(SigningProvider.DFNS), pendingTransaction)).rejects.toThrow('Cannot execute Dfns transaction without externalTxId from Dfns');
+            });
+        });
+        describe('participant', () => {
+            it('submits the prepared transaction to the ledger', async () => {
+                const participantWallet = walletWithProvider(SigningProvider.PARTICIPANT);
+                const transaction = {
+                    ...pendingTransaction,
+                    payload: {
+                        commandId: pendingTransaction.commandId,
+                        commands: [],
+                    },
+                };
+                const store = createStore(transaction);
+                const postWithRetry = vi
+                    .fn()
+                    .mockResolvedValue({ updateId: 'ledger-update-1' });
+                const ledgerClient = {
+                    postWithRetry,
+                    getSynchronizerId: vi.fn(),
+                };
+                const service = createService(store, {}, notifier, logger);
+                const result = await service.execute(authContext.userId, participantWallet, transaction, executeParams, ledgerClient, network);
+                expect(postWithRetry).toHaveBeenCalledWith('/v2/commands/submit-and-wait', expect.objectContaining({
+                    commandId: pendingTransaction.commandId,
+                    userId: authContext.userId,
+                    synchronizerId: network.synchronizerId,
+                }));
+                expect(store.setTransactionStatus).toHaveBeenCalledWith(pendingTransaction.id, 'executed', { payload: { updateId: 'ledger-update-1' } });
+                expect(result).toEqual({ updateId: 'ledger-update-1' });
+            });
+        });
+        describe('external signing providers', () => {
+            it('executes the prepared transaction with the provided signature', async () => {
+                const signedTransaction = {
+                    ...pendingTransaction,
+                    status: 'signed',
+                };
+                const store = createStore(signedTransaction);
+                const postWithRetry = vi
+                    .fn()
+                    .mockResolvedValue({ updateId: 'external-update-1' });
+                const ledgerClient = {
+                    postWithRetry,
+                };
+                const service = createService(store, {}, notifier, logger);
+                const result = await service.execute(authContext.userId, wallet, signedTransaction, executeParams, ledgerClient, network);
+                expect(postWithRetry).toHaveBeenCalledWith('/v2/interactive-submission/executeAndWait', expect.objectContaining({
+                    userId: authContext.userId,
+                    preparedTransaction: pendingTransaction.preparedTransaction,
+                    submissionId: pendingTransaction.commandId,
+                    partySignatures: expect.objectContaining({
+                        signatures: [
+                            expect.objectContaining({
+                                party: wallet.partyId,
+                            }),
+                        ],
+                    }),
+                }));
+                expect(store.setTransactionStatus).toHaveBeenCalledWith(pendingTransaction.id, 'executed', { payload: { updateId: 'external-update-1' } });
+                expect(result).toEqual({ updateId: 'external-update-1' });
+            });
+        });
+    });
+    describe('signAndExecute', () => {
+        const participantWallet = walletWithProvider(SigningProvider.PARTICIPANT);
+        it('signs and executes when signing completes synchronously', async () => {
+            const service = createService(createStore(), {}, notifier, logger);
+            const executeSpy = vi
+                .spyOn(service, 'execute')
+                .mockResolvedValue({ commandId: 'cmd-1' });
+            vi.spyOn(service, 'sign').mockResolvedValue({
+                status: 'signed',
+                signature: 'sig',
+                signedBy: 'namespace',
+                partyId: participantWallet.partyId,
+            });
+            const result = await service.signAndExecute(authContext, network, participantWallet, pendingTransaction);
+            expect(result).toEqual({ commandId: 'cmd-1' });
+            expect(executeSpy).toHaveBeenCalled();
+        });
+        it('returns pending sign result without executing', async () => {
+            const service = createService(createStore(), {}, notifier, logger);
+            const executeSpy = vi.spyOn(service, 'execute');
+            vi.spyOn(service, 'sign').mockResolvedValue({
+                status: 'pending',
+                externalTxId: 'ext-1',
+                partyId: participantWallet.partyId,
+            });
+            const result = await service.signAndExecute(authContext, network, participantWallet, pendingTransaction);
+            expect(result).toEqual({
+                status: 'pending',
+                externalTxId: 'ext-1',
+                partyId: participantWallet.partyId,
+            });
+            expect(executeSpy).not.toHaveBeenCalled();
+        });
+    });
+});

package/dist/ledger/wallet-allocation/signing-providers/fireblocks-wallet-allocator.d.ts

@@ -3,7 +3,7 @@ import { Store, Wallet } from '@canton-network/core-wallet-store';
 import { SigningDriverInterface } from '@canton-network/core-signing-lib';
 import { Logger } from 'pino';
 import { PartyAllocationService } from '../../party-allocation-service.js';
-import { PartyHint, Primary } from '../../../user-api/rpc-gen/typings.js';
+import { PartyHint, Primary, VaultName } from '../../../user-api/rpc-gen/typings.js';
 import type { WalletAllocator } from '../wallet-allocation-service.js';
 export declare class FireblocksWalletAllocator implements WalletAllocator {
     private store;
@@ -11,7 +11,10 @@ export declare class FireblocksWalletAllocator implements WalletAllocator {
     private partyAllocator;
     private signingDriver;
     constructor(store: Store, logger: Logger, partyAllocator: PartyAllocationService, signingDriver: SigningDriverInterface);
-    createWallet(userId: UserId, email: string | undefined, partyHint: PartyHint, primary?: Primary): Promise<Wallet>;
+    createWallet(userId: UserId, email: string | undefined, partyHint: PartyHint, primary: Primary | undefined, vaultName: VaultName): Promise<Wallet>;
     allocateParty(userId: UserId, email: string | undefined, existingWallet: Wallet): Promise<void>;
+    getVaults(userId: UserId): Promise<{
+        vaults: string[];
+    }>;
 }
 //# sourceMappingURL=fireblocks-wallet-allocator.d.ts.map

package/dist/ledger/wallet-allocation/signing-providers/fireblocks-wallet-allocator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fireblocks-wallet-allocator.d.ts","sourceRoot":"","sources":["../../../../src/ledger/wallet-allocation/signing-providers/fireblocks-wallet-allocator.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,MAAM,EAAE,MAAM,kCAAkC,CAAA;AACzD,OAAO,EAAE,KAAK,EAAgB,MAAM,EAAE,MAAM,mCAAmC,CAAA;AAC/E,OAAO,EAEH,sBAAsB,EAEzB,MAAM,kCAAkC,CAAA;AACzC,OAAO,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAC7B,OAAO,EAAE,sBAAsB,EAAE,MAAM,mCAAmC,CAAA;AAC1E,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,sCAAsC,CAAA;AACzE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAA;AAYtE,qBAAa,yBAA0B,YAAW,eAAe;IAEzD,OAAO,CAAC,KAAK;IACb,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,cAAc;IACtB,OAAO,CAAC,aAAa;gBAHb,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,MAAM,EACd,cAAc,EAAE,sBAAsB,EACtC,aAAa,EAAE,sBAAsB;IAG3C,YAAY,CACd,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,SAAS,EAAE,SAAS,EACpB,OAAO,GAAE,OAAe,GACzB,OAAO,CAAC,MAAM,CAAC;IA6FZ,aAAa,CACf,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,cAAc,EAAE,MAAM,GACvB,OAAO,CAAC,IAAI,CAAC;CAkEnB"}
+{"version":3,"file":"fireblocks-wallet-allocator.d.ts","sourceRoot":"","sources":["../../../../src/ledger/wallet-allocation/signing-providers/fireblocks-wallet-allocator.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,MAAM,EAAE,MAAM,kCAAkC,CAAA;AACzD,OAAO,EAAE,KAAK,EAAgB,MAAM,EAAE,MAAM,mCAAmC,CAAA;AAC/E,OAAO,EAEH,sBAAsB,EAEzB,MAAM,kCAAkC,CAAA;AACzC,OAAO,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAC7B,OAAO,EAAE,sBAAsB,EAAE,MAAM,mCAAmC,CAAA;AAC1E,OAAO,EACH,SAAS,EACT,OAAO,EACP,SAAS,EACZ,MAAM,sCAAsC,CAAA;AAC7C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAA;AAYtE,qBAAa,yBAA0B,YAAW,eAAe;IAEzD,OAAO,CAAC,KAAK;IACb,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,cAAc;IACtB,OAAO,CAAC,aAAa;gBAHb,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,MAAM,EACd,cAAc,EAAE,sBAAsB,EACtC,aAAa,EAAE,sBAAsB;IAG3C,YAAY,CACd,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,SAAS,EAAE,SAAS,EACpB,OAAO,EAAE,OAAO,YAAQ,EACxB,SAAS,EAAE,SAAS,GACrB,OAAO,CAAC,MAAM,CAAC;IA6FZ,aAAa,CACf,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,cAAc,EAAE,MAAM,GACvB,OAAO,CAAC,IAAI,CAAC;IAgEV,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,MAAM,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;CAKjE"}