feat: pass userId to all blockdaemon endpoints (#1183)

Signed-off-by: Marc Juchli <marc.juchli@digitalasset.com>

Author: mjuchli-da

core/signing-blockdaemon/src/index.test.ts

@@ -4,7 +4,7 @@
 import { jest, expect, describe, test, beforeEach } from '@jest/globals'
 import BlockdaemonSigningDriver from './index.js'
 import { SigningAPIClient } from './signing-api-sdk.js'
-import { Transaction } from '@canton-network/core-signing-lib'
+import { Transaction, Key } from '@canton-network/core-signing-lib'
 
 describe('BlockdaemonSigningDriver', () => {
     const config = {
@@ -21,6 +21,10 @@ describe('BlockdaemonSigningDriver', () => {
 
         mockClient = {
             signTransaction: jest.fn(),
+            getTransaction: jest.fn(),
+            getTransactions: jest.fn(),
+            getKeys: jest.fn(),
+            createKey: jest.fn(),
         } as unknown as jest.Mocked<SigningAPIClient>
 
         driver = new BlockdaemonSigningDriver(config)
@@ -67,4 +71,139 @@ describe('BlockdaemonSigningDriver', () => {
             publicKey: mockResponse.publicKey,
         })
     })
+
+    test('createKey calls client.createKey with correct params', async () => {
+        const createKeyParams = {
+            name: 'new-key',
+        }
+
+        const mockResponse = {
+            id: 'key-id',
+            name: 'new-key',
+            publicKey: 'new-public-key',
+        }
+
+        mockClient.createKey.mockResolvedValue(mockResponse as Key)
+
+        const result = await driver
+            .controller(userId)
+            .createKey(createKeyParams)
+
+        expect(mockClient.createKey).toHaveBeenCalledWith({
+            name: createKeyParams.name,
+            userIdentifier: userId,
+        })
+
+        expect(result).toEqual({
+            id: mockResponse.id,
+            name: mockResponse.name,
+            publicKey: mockResponse.publicKey,
+        })
+    })
+
+    test('getTransaction calls client.getTransaction with correct params', async () => {
+        const getTransactionParams = {
+            txId: 'tx-id',
+        }
+
+        const mockResponse = {
+            txId: 'tx-id',
+            status: 'signed',
+            signature: 'signature-bytes',
+            publicKey: 'some-public-key',
+        }
+
+        mockClient.getTransaction.mockResolvedValue(mockResponse as Transaction)
+
+        const result = await driver
+            .controller(userId)
+            .getTransaction(getTransactionParams)
+
+        expect(mockClient.getTransaction).toHaveBeenCalledWith({
+            txId: getTransactionParams.txId,
+            userIdentifier: userId,
+        })
+
+        expect(result).toEqual({
+            txId: mockResponse.txId,
+            status: mockResponse.status,
+            signature: mockResponse.signature,
+            publicKey: mockResponse.publicKey,
+        })
+    })
+
+    test('getTransactions calls client.getTransactions with correct params', async () => {
+        const getTransactionsParams = {
+            txIds: ['tx-id-1', 'tx-id-2'],
+            publicKeys: ['pk-1'],
+        }
+
+        const mockResponse = [
+            {
+                txId: 'tx-id-1',
+                status: 'signed',
+                signature: 'sig-1',
+                publicKey: 'pk-1',
+            },
+            {
+                txId: 'tx-id-2',
+                status: 'pending',
+                signature: 'sig-2',
+                publicKey: 'pk-1',
+            },
+        ]
+
+        mockClient.getTransactions.mockResolvedValue(
+            mockResponse as Transaction[]
+        )
+
+        const result = await driver
+            .controller(userId)
+            .getTransactions(getTransactionsParams)
+
+        expect(mockClient.getTransactions).toHaveBeenCalledWith({
+            txIds: getTransactionsParams.txIds,
+            publicKeys: getTransactionsParams.publicKeys,
+            userIdentifier: userId,
+        })
+
+        expect(result).toEqual({
+            transactions: mockResponse.map((tx) => ({
+                txId: tx.txId,
+                status: tx.status,
+                signature: tx.signature,
+                publicKey: tx.publicKey,
+            })),
+        })
+    })
+
+    test('getKeys calls client.getKeys with correct params', async () => {
+        const mockResponse = [
+            {
+                id: 'key-1',
+                name: 'Key 1',
+                publicKey: 'pk-1',
+            },
+            {
+                id: 'key-2',
+                name: 'Key 2',
+                publicKey: 'pk-2',
+            },
+        ]
+
+        mockClient.getKeys.mockResolvedValue(mockResponse as Key[])
+
+        const result = await driver.controller(userId).getKeys()
+
+        expect(mockClient.getKeys).toHaveBeenCalled()
+
+        expect(result).toEqual({
+            keys: mockResponse.map((k) => ({
+                id: k.id,
+                name: k.name,
+                publicKey: k.publicKey,
+                userIdentifier: userId,
+            })),
+        })
+    })
 })

core/signing-blockdaemon/src/index.ts

@@ -88,6 +88,7 @@ export default class BlockdaemonSigningDriver implements SigningDriverInterface
                 try {
                     const tx = await this.client.getTransaction({
                         txId: params.txId,
+                        userIdentifier: userId,
                     })
                     return {
                         txId: tx.txId,
@@ -115,6 +116,7 @@ export default class BlockdaemonSigningDriver implements SigningDriverInterface
                         const transactions = await this.client.getTransactions({
                             txIds: params.txIds!,
                             publicKeys: params.publicKeys!,
+                            userIdentifier: userId,
                         })
                         return {
                             transactions: transactions.map((tx) => ({
@@ -147,6 +149,7 @@ export default class BlockdaemonSigningDriver implements SigningDriverInterface
                             id: k.id,
                             name: k.name,
                             publicKey: k.publicKey,
+                            userIdentifier: userId,
                         })),
                     }
                 } catch (error) {
@@ -163,6 +166,7 @@ export default class BlockdaemonSigningDriver implements SigningDriverInterface
                 try {
                     const key = await this.client.createKey({
                         name: params.name,
+                        userIdentifier: userId,
                     })
                     return {
                         id: key.id,