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

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

@@ -0,0 +1,356 @@
+// 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' });
+            });
+        });
+    });
+});

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"}

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

@@ -15,10 +15,10 @@ export class FireblocksWalletAllocator {
         this.partyAllocator = partyAllocator;
         this.signingDriver = signingDriver;
     }
-    async createWallet(userId, email, partyHint, primary = false) {
+    async createWallet(userId, email, partyHint, primary = false, vaultName) {
         const driver = this.signingDriver.controller(userId);
         const keys = await driver.getKeys().then(handleSigningError);
-        const key = keys?.keys?.find((k) => k.name === 'Canton Party');
+        const key = keys?.keys?.find((k) => k.name === vaultName);
         if (!key)
             throw new Error('Fireblocks key not found');
         const formattedPublicKey = Buffer.from(key.publicKey, 'hex').toString('base64');
@@ -92,10 +92,6 @@ export class FireblocksWalletAllocator {
             throw new Error('Existing wallet is missing field externalTxId or topologyTransactions');
         }
         const driver = this.signingDriver.controller(userId);
-        const keys = await driver.getKeys().then(handleSigningError);
-        const key = keys?.keys?.find((k) => k.name === 'Canton Party');
-        if (!key)
-            throw new Error('Fireblocks key not found');
         const { signature, status } = await driver
             .getTransaction({
             userId,
@@ -138,4 +134,9 @@ export class FireblocksWalletAllocator {
         }
         return this.store.updateWallet(walletUpdate);
     }
+    async getVaults(userId) {
+        const driver = this.signingDriver.controller(userId);
+        const keys = await driver.getKeys().then(handleSigningError);
+        return { vaults: keys?.keys?.map((key) => key.name) ?? [] };
+    }
 }

package/dist/ledger/wallet-allocation/wallet-allocation-service.d.ts

@@ -1,12 +1,15 @@
-import { UserId } from '@canton-network/core-wallet-auth';
+import { AuthContext, UserId } from '@canton-network/core-wallet-auth';
 import { Store, Wallet } from '@canton-network/core-wallet-store';
 import { SigningDriverInterface, SigningProvider } 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';
 export interface WalletAllocator {
-    createWallet(userId: UserId, email: string | undefined, partyHint: PartyHint, primary: Primary): Promise<Wallet>;
+    createWallet(userId: UserId, email: string | undefined, partyHint: PartyHint, primary: Primary, vaultName?: VaultName | undefined): Promise<Wallet>;
     allocateParty(userId: UserId, email: string | undefined, existingWallet: Wallet): Promise<void>;
+    getVaults?(userId: UserId): Promise<{
+        vaults: string[];
+    }>;
 }
 export declare class WalletAllocationService {
     private readonly participantAllocator;
@@ -15,7 +18,10 @@ export declare class WalletAllocationService {
     private readonly blockdaemonAllocator?;
     private readonly dfnsAllocator?;
     constructor(store: Store, logger: Logger, partyAllocator: PartyAllocationService, signingDrivers?: Partial<Record<SigningProvider, SigningDriverInterface>>);
-    createWallet(userId: UserId, email: string | undefined, partyHint: PartyHint, primary: Primary, signingProviderId: SigningProvider): Promise<Wallet>;
-    allocateParty(userId: UserId, email: string | undefined, existingWallet: Wallet, signingProviderId: SigningProvider): Promise<void>;
+    createWallet(authContext: AuthContext, partyHint: PartyHint, primary: Primary, signingProviderId: SigningProvider, vaultName?: VaultName | undefined): Promise<Wallet>;
+    allocateParty(authContext: AuthContext, existingWallet: Wallet, signingProviderId: SigningProvider): Promise<void>;
+    getVaults(authContext: AuthContext, signingProviderId: SigningProvider): Promise<{
+        vaults: string[];
+    }>;
 }
 //# sourceMappingURL=wallet-allocation-service.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"wallet-allocation-service.d.ts","sourceRoot":"","sources":["../../../src/ledger/wallet-allocation/wallet-allocation-service.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,MAAM,EAAE,MAAM,kCAAkC,CAAA;AACzD,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,mCAAmC,CAAA;AACjE,OAAO,EACH,sBAAsB,EACtB,eAAe,EAClB,MAAM,kCAAkC,CAAA;AACzC,OAAO,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAC7B,OAAO,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAA;AACvE,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,mCAAmC,CAAA;AAOtE,MAAM,WAAW,eAAe;IAC5B,YAAY,CACR,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,SAAS,EAAE,SAAS,EACpB,OAAO,EAAE,OAAO,GACjB,OAAO,CAAC,MAAM,CAAC,CAAA;IAClB,aAAa,CACT,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,cAAc,EAAE,MAAM,GACvB,OAAO,CAAC,IAAI,CAAC,CAAA;CACnB;AAED,qBAAa,uBAAuB;IAChC,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAA4B;IACjE,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAuB;IACxD,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAC,CAA2B;IAChE,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAC,CAA4B;IAClE,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAqB;gBAGhD,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,MAAM,EACd,cAAc,EAAE,sBAAsB,EACtC,cAAc,GAAE,OAAO,CACnB,MAAM,CAAC,eAAe,EAAE,sBAAsB,CAAC,CAC7C;IAiDG,YAAY,CACrB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,SAAS,EAAE,SAAS,EACpB,OAAO,EAAE,OAAO,EAChB,iBAAiB,EAAE,eAAe,GACnC,OAAO,CAAC,MAAM,CAAC;IA+DL,aAAa,CACtB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,cAAc,EAAE,MAAM,EACtB,iBAAiB,EAAE,eAAe,GACnC,OAAO,CAAC,IAAI,CAAC;CAyDnB"}
+{"version":3,"file":"wallet-allocation-service.d.ts","sourceRoot":"","sources":["../../../src/ledger/wallet-allocation/wallet-allocation-service.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,kCAAkC,CAAA;AACtE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,mCAAmC,CAAA;AACjE,OAAO,EACH,sBAAsB,EACtB,eAAe,EAClB,MAAM,kCAAkC,CAAA;AACzC,OAAO,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AAC7B,OAAO,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAA;AACvE,OAAO,EACH,SAAS,EACT,OAAO,EACP,SAAS,EACZ,MAAM,mCAAmC,CAAA;AAO1C,MAAM,WAAW,eAAe;IAC5B,YAAY,CACR,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,SAAS,EAAE,SAAS,EACpB,OAAO,EAAE,OAAO,EAChB,SAAS,CAAC,EAAE,SAAS,GAAG,SAAS,GAClC,OAAO,CAAC,MAAM,CAAC,CAAA;IAClB,aAAa,CACT,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,cAAc,EAAE,MAAM,GACvB,OAAO,CAAC,IAAI,CAAC,CAAA;IAChB,SAAS,CAAC,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,MAAM,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC,CAAA;CAC5D;AAED,qBAAa,uBAAuB;IAChC,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAA4B;IACjE,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAuB;IACxD,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAC,CAA2B;IAChE,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAC,CAA4B;IAClE,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAqB;gBAGhD,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,MAAM,EACd,cAAc,EAAE,sBAAsB,EACtC,cAAc,GAAE,OAAO,CACnB,MAAM,CAAC,eAAe,EAAE,sBAAsB,CAAC,CAC7C;IAiDG,YAAY,CACrB,WAAW,EAAE,WAAW,EACxB,SAAS,EAAE,SAAS,EACpB,OAAO,EAAE,OAAO,EAChB,iBAAiB,EAAE,eAAe,EAClC,SAAS,CAAC,EAAE,SAAS,GAAG,SAAS,GAClC,OAAO,CAAC,MAAM,CAAC;IAqEL,aAAa,CACtB,WAAW,EAAE,WAAW,EACxB,cAAc,EAAE,MAAM,EACtB,iBAAiB,EAAE,eAAe,GACnC,OAAO,CAAC,IAAI,CAAC;IA0DH,SAAS,CAClB,WAAW,EAAE,WAAW,EACxB,iBAAiB,EAAE,eAAe,GACnC,OAAO,CAAC;QAAE,MAAM,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;CAanC"}

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

@@ -26,66 +26,80 @@ export class WalletAllocationService {
             this.dfnsAllocator = new DfnsWalletAllocator(store, logger, partyAllocator, dfnsDriver);
         }
     }
-    async createWallet(userId, email, partyHint, primary, signingProviderId) {
+    async createWallet(authContext, partyHint, primary, signingProviderId, vaultName) {
         switch (signingProviderId) {
             case SigningProvider.PARTICIPANT:
-                return this.participantAllocator.createWallet(userId, email, partyHint, primary);
+                return this.participantAllocator.createWallet(authContext.userId, authContext.email, partyHint, primary);
             case SigningProvider.WALLET_KERNEL:
                 if (!this.kernelAllocator) {
                     throw new Error('Wallet Gateway signing driver not available');
                 }
-                return this.kernelAllocator.createWallet(userId, email, partyHint, primary);
+                return this.kernelAllocator.createWallet(authContext.userId, authContext.email, partyHint, primary);
             case SigningProvider.FIREBLOCKS:
                 if (!this.fireblocksAllocator) {
                     throw new Error('Fireblocks signing driver not available');
                 }
-                return this.fireblocksAllocator.createWallet(userId, email, partyHint, primary);
+                if (!vaultName) {
+                    throw new Error('vaultName is required for creating a wallet with Fireblocks');
+                }
+                return this.fireblocksAllocator.createWallet(authContext.userId, authContext.email, partyHint, primary, vaultName);
             case SigningProvider.BLOCKDAEMON:
                 if (!this.blockdaemonAllocator) {
                     throw new Error('Blockdaemon signing driver not available');
                 }
-                if (!email) {
+                if (!authContext.email) {
                     throw new Error('Email is required for Blockdaemon wallet allocation');
                 }
-                return this.blockdaemonAllocator.createWallet(userId, email, partyHint, primary);
+                return this.blockdaemonAllocator.createWallet(authContext.userId, authContext.email, partyHint, primary);
             case SigningProvider.DFNS:
                 if (!this.dfnsAllocator) {
                     throw new Error('Dfns signing driver not available');
                 }
-                return this.dfnsAllocator.createWallet(userId, email, partyHint, primary);
+                return this.dfnsAllocator.createWallet(authContext.userId, authContext.email, partyHint, primary);
             default:
                 throw new Error(`Unsupported signing provider: ${signingProviderId}`);
         }
     }
-    async allocateParty(userId, email, existingWallet, signingProviderId) {
+    async allocateParty(authContext, existingWallet, signingProviderId) {
         switch (signingProviderId) {
             case SigningProvider.PARTICIPANT:
-                return this.participantAllocator.allocateParty(userId, email, existingWallet);
+                return this.participantAllocator.allocateParty(authContext.userId, authContext.email, existingWallet);
             case SigningProvider.WALLET_KERNEL:
                 if (!this.kernelAllocator) {
                     throw new Error('Wallet Gateway signing driver not available');
                 }
-                return this.kernelAllocator.allocateParty(userId, email, existingWallet);
+                return this.kernelAllocator.allocateParty(authContext.userId, authContext.email, existingWallet);
             case SigningProvider.FIREBLOCKS:
                 if (!this.fireblocksAllocator) {
                     throw new Error('Fireblocks signing driver not available');
                 }
-                return this.fireblocksAllocator.allocateParty(userId, email, existingWallet);
+                return this.fireblocksAllocator.allocateParty(authContext.userId, authContext.email, existingWallet);
             case SigningProvider.BLOCKDAEMON:
                 if (!this.blockdaemonAllocator) {
                     throw new Error('Blockdaemon signing driver not available');
                 }
-                if (!email) {
+                if (!authContext.email) {
                     throw new Error('Email is required for Blockdaemon wallet allocation');
                 }
-                return this.blockdaemonAllocator.allocateParty(userId, email, existingWallet);
+                return this.blockdaemonAllocator.allocateParty(authContext.userId, authContext.email, existingWallet);
             case SigningProvider.DFNS:
                 if (!this.dfnsAllocator) {
                     throw new Error('Dfns signing driver not available');
                 }
-                return this.dfnsAllocator.allocateParty(userId, email, existingWallet);
+                return this.dfnsAllocator.allocateParty(authContext.userId, authContext.email, existingWallet);
             default:
                 throw new Error(`Unsupported signing provider: ${signingProviderId}`);
         }
     }
+    async getVaults(authContext, signingProviderId) {
+        switch (signingProviderId) {
+            case SigningProvider.FIREBLOCKS:
+                if (!this.fireblocksAllocator) {
+                    throw new Error('Fireblocks signing driver not available');
+                }
+                return this.fireblocksAllocator.getVaults(authContext.userId);
+            default:
+                throw new Error(`Signing provider ${signingProviderId} does not support listing vaults`);
+        }
+    }
 }