feat: add support for HTTP-based external party allocation

.github/actions/check_resources/action.yml

@@ -0,0 +1,14 @@
+name: Check resource usage
+description: 'List current resource usage of the CI runner VM'
+runs:
+    using: composite
+    steps:
+        - name: Check memory usage
+          if: always()
+          shell: bash
+          run: free -h
+
+        - name: Check CPU usage
+          if: always()
+          shell: bash
+          run: ps -eo pid,comm,%cpu,%mem,exe,time --sort=-%cpu | head -n 20

.github/workflows/build.yml

@@ -190,12 +190,18 @@ jobs:
             - name: Start Localnet
               run: yarn start:localnet
 
+            - uses: ./.github/actions/check_resources
+
             - name: Test example snippets
               run: yarn nx snippets docs-wallet-integration-guide-examples
 
+            - uses: ./.github/actions/check_resources
+
             - name: Test example scripts
               run: yarn script:test:examples
 
+            - uses: ./.github/actions/check_resources
+
             - name: Save container logs
               if: failure()
               run: |

clients/remote/src/ledger/party-allocation-service.test.ts

@@ -13,24 +13,12 @@ const mockLedgerPost = jest.fn<AsyncFn>()
 const mockLedgerGrantUserRights = jest.fn()
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-const MockTopologyWriteService: jest.MockedClass<any> = jest
-    .fn()
-    .mockImplementation(() => ({
-        generateTransactions: jest.fn<AsyncFn>().mockResolvedValue({
-            generatedTransactions: [],
-        }),
-        addTransactions: jest.fn<AsyncFn>(),
-        authorizePartyToParticipant: jest.fn<AsyncFn>(),
-        submitExternalPartyTopology: jest.fn<AsyncFn>(),
-    }))
+const MockTopologyWriteService: jest.MockedClass<any> = jest.fn()
 
 // Add static method to the mock class
 MockTopologyWriteService.createFingerprintFromKey = jest
     .fn()
     .mockReturnValue('mypublickey')
-MockTopologyWriteService.combineHashes = jest
-    .fn()
-    .mockReturnValue('combinedhash')
 
 jest.unstable_mockModule('@canton-network/core-ledger-client', () => ({
     Signature: jest.fn(),
@@ -43,6 +31,15 @@ jest.unstable_mockModule('@canton-network/core-ledger-client', () => ({
             get: mockLedgerGet,
             post: mockLedgerPost,
             grantUserRights: mockLedgerGrantUserRights,
+            generateTopology: jest.fn<AsyncFn>().mockResolvedValue({
+                partyId: 'party2::mypublickey',
+                publicKeyFingerprint: 'mypublickey',
+                topologyTransactions: ['tx1'],
+                multiHash: 'combinedHash',
+            }),
+            allocateExternalParty: jest
+                .fn<AsyncFn>()
+                .mockResolvedValue({ partyId: 'party2::mypublickey' }),
         }
     }),
     TopologyWriteService: MockTopologyWriteService,
@@ -81,7 +78,6 @@ describe('PartyAllocationService', () => {
             network.synchronizerId,
             'admin.jwt',
             network.ledgerApi.baseUrl,
-            network.ledgerApi.adminGrpcUrl,
             mockLogger
         )
     })

clients/remote/src/ledger/party-allocation-service.ts

@@ -20,25 +20,17 @@ type SigningCbFn = (hash: string) => Promise<string>
  */
 export class PartyAllocationService {
     private ledgerClient: LedgerClient
-    private topologyClient: TopologyWriteService
 
     constructor(
         private synchronizerId: string,
         adminToken: string,
         httpLedgerUrl: string,
-        adminApiUrl: string,
-        logger: Logger
+        private logger: Logger
     ) {
         this.ledgerClient = new LedgerClient(
             new URL(httpLedgerUrl),
             adminToken,
-            logger
-        )
-        this.topologyClient = new TopologyWriteService(
-            this.synchronizerId,
-            adminApiUrl,
-            adminToken,
-            this.ledgerClient
+            this.logger
         )
     }
 
@@ -110,35 +102,31 @@ export class PartyAllocationService {
     ): Promise<AllocatedParty> {
         const namespace =
             TopologyWriteService.createFingerprintFromKey(publicKey)
-        const partyId = `${hint}::${namespace}`
 
-        const transactions = await this.topologyClient
-            .generateTransactions(publicKey, partyId)
-            .then((resp) => resp.generatedTransactions)
-
-        const txHashes = transactions.map((tx) =>
-            Buffer.from(tx.transactionHash)
+        const transactions = await this.ledgerClient.generateTopology(
+            this.synchronizerId,
+            publicKey,
+            hint
         )
 
-        const combinedHash = TopologyWriteService.combineHashes(txHashes)
+        const signature = await signingCallback(transactions.multiHash)
 
-        const signature = await signingCallback(combinedHash)
-
-        const signedTopologyTxs = transactions.map((transaction) =>
-            TopologyWriteService.toSignedTopologyTransaction(
-                txHashes,
-                transaction.serializedTransaction,
-                signature,
-                namespace
-            )
-        )
-
-        await this.topologyClient.submitExternalPartyTopology(
-            signedTopologyTxs,
-            partyId
+        const res = await this.ledgerClient.allocateExternalParty(
+            this.synchronizerId,
+            transactions.topologyTransactions!.map((transaction) => ({
+                transaction,
+            })),
+            [
+                {
+                    format: 'SIGNATURE_FORMAT_CONCAT',
+                    signature: signature,
+                    signedBy: namespace,
+                    signingAlgorithmSpec: 'SIGNING_ALGORITHM_SPEC_ED25519',
+                },
+            ]
         )
-        await this.ledgerClient.grantUserRights(userId, partyId)
 
-        return { hint, partyId, namespace }
+        await this.ledgerClient.grantUserRights(userId, res.partyId)
+        return { hint, partyId: res.partyId, namespace }
     }
 }

clients/remote/src/user-api/controller.ts

@@ -129,7 +129,6 @@ export const userController = (
                 network.synchronizerId,
                 adminToken,
                 network.ledgerApi.baseUrl,
-                network.ledgerApi.adminGrpcUrl,
                 logger
             )
             const driver = drivers[

core/ledger-client/package.json

@@ -32,10 +32,8 @@
         "@canton-network/core-splice-client": "workspace:^",
         "@canton-network/core-token-standard": "workspace:^",
         "@canton-network/core-types": "workspace:^",
-        "@grpc/grpc-js": "^1.13.4",
+        "@grpc/grpc-js": "^1.14.0",
         "@protobuf-ts/grpc-transport": "^2.11.1",
-        "@protobuf-ts/runtime": "^2.11.1",
-        "@protobuf-ts/runtime-rpc": "^2.11.1",
         "bignumber.js": "^9.2.1",
         "dayjs": "^1.11.13",
         "openapi-fetch": "^0.14.0",

core/ledger-client/src/ledger-client.ts

@@ -56,6 +56,20 @@ export type GetResponse<Path extends GetEndpoint> = paths[Path] extends {
     ? Res
     : never
 
+// Explicitly use the 3.3 schema here, as there has not been a 3.4 snapshot containing these yet
+export type GenerateTransactionResponse =
+    v3_3.components['schemas']['GenerateExternalPartyTopologyResponse']
+
+export type AllocateExternalPartyResponse =
+    v3_3.components['schemas']['AllocateExternalPartyResponse']
+
+export type OnboardingTransactions = NonNullable<
+    v3_3.components['schemas']['AllocateExternalPartyRequest']['onboardingTransactions']
+>
+
+export type MultiHashSignatures = NonNullable<
+    v3_3.components['schemas']['AllocateExternalPartyRequest']['multiHashSignatures']
+>
 // Any options the client accepts besides body/params
 type ExtraPostOpts = Omit<FetchOptions<paths>, 'body' | 'params'>
 
@@ -195,6 +209,76 @@ export class LedgerClient {
         return
     }
 
+    /** TODO: simplify once 3.4 snapshot contains this endpoint */
+    public async allocateExternalParty(
+        synchronizerId: string,
+        onboardingTransactions: OnboardingTransactions,
+        multiHashSignatures: MultiHashSignatures
+    ): Promise<AllocateExternalPartyResponse> {
+        await this.init()
+
+        if (this.clientVersion !== '3.3') {
+            throw new Error(
+                'allocateExternalParty is only supported on 3.3 clients'
+            )
+        }
+
+        const client: Client<v3_3.paths> = this.clients['3.3']
+
+        const resp = await client.POST('/v2/parties/external/allocate', {
+            body: {
+                synchronizer: synchronizerId,
+                identityProviderId: '',
+                onboardingTransactions,
+                multiHashSignatures,
+            },
+        })
+
+        return this.valueOrError(resp)
+    }
+
+    /** TODO: simplify once 3.4 snapshot contains this endpoint  */
+    public async generateTopology(
+        synchronizerId: string,
+        publicKey: string,
+        partyHint: string,
+        localParticipantObservationOnly: boolean = false,
+        confirmationThreshold: number = 1,
+        otherConfirmingParticipantUids: string[] = []
+    ): Promise<GenerateTransactionResponse> {
+        await this.init()
+
+        if (this.clientVersion !== '3.3') {
+            throw new Error(
+                'allocateExternalParty is only supported on 3.3 clients'
+            )
+        }
+
+        const client: Client<v3_3.paths> = this.clients['3.3']
+
+        const body = {
+            synchronizer: synchronizerId,
+            partyHint,
+            publicKey: {
+                format: 'CRYPTO_KEY_FORMAT_RAW',
+                keyData: publicKey,
+                keySpec: 'SIGNING_KEY_SPEC_EC_CURVE25519',
+            },
+            localParticipantObservationOnly,
+            confirmationThreshold,
+            otherConfirmingParticipantUids,
+        }
+
+        this.logger.debug(body, 'generateTopology request body')
+
+        const resp = await client.POST(
+            '/v2/parties/external/generate-topology',
+            { body }
+        )
+
+        return this.valueOrError(resp)
+    }
+
     public async post<Path extends PostEndpoint>(
         path: Path,
         body: PostRequest<Path>,