Merge branch 'main' into phol/connection-status

Author: PHOL-DA

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

@@ -83,7 +83,7 @@ export class ACSContainer {
         key: ACSKey,
         api: LedgerClient,
         wsSupport?: WSSupport
-    ): Promise<Array<JsGetActiveContractsResponse>> {
+    ): Promise<JsGetActiveContractsResponse[]> {
         if (this.acsSet === null) {
             const acs = await this.readACS(offset, key, api, wsSupport)
             this.acsSet = acs

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

@@ -74,7 +74,7 @@ export class ACSHelper {
             cacheSize: this.contractsSet.size,
             hitRate: hitRate.toFixed(2) + '%',
             averageLookupTime: avgLookupTime.toFixed(3) + ' ms',
-            cacheServeTime: this.totalCacheServeTime.toFixed(3),
+            cacheServeTime: SharedACSCacheStats.totalCacheServeTime.toFixed(3),
         }
     }
 
@@ -92,7 +92,7 @@ export class ACSHelper {
 
     private findACSContainer(key: ACSKey): ACSContainer {
         const keyStr = ACSHelper.keyToString(key, this.apiInstance.baseUrl.href)
-        // this.logger.info(`ACS KEY ${keyStr}`)
+
         const start = performance.now()
         const existing = this.contractsSet.get(keyStr)
         const end = performance.now()
@@ -114,59 +114,84 @@ export class ACSHelper {
         return newContainer
     }
 
-    async activeContractsForTemplate(
-        offset: number,
-        partyFilter: string,
-        templateId: string
-    ): Promise<Array<JsGetActiveContractsResponse>> {
-        const key = ACSHelper.createKey(partyFilter, templateId, undefined)
+    async updateSingleKey(offset: number, key: ACSKey) {
         const start = performance.now()
         const container = this.findACSContainer(key)
-        const result = container.update(
+        const result = await container.update(
             offset,
             key,
             this.apiInstance,
             this.wsSupport
         )
+
         const end = performance.now()
 
-        if (
-            this.contractsSet.has(
-                ACSHelper.keyToString(key, this.apiInstance.baseUrl.href)
-            )
-        ) {
+        const keyStr = ACSHelper.keyToString(key, this.apiInstance.baseUrl.href)
+
+        if (this.contractsSet.has(keyStr)) {
             SharedACSCacheStats.totalCacheServeTime += end - start
         }
 
         return result
     }
 
-    async activeContractsForInterface(
+    async queryAcsByKeys(offset: number, keys: ACSKey[]) {
+        const result: JsGetActiveContractsResponse[] = []
+
+        for (const key of keys) {
+            const contracts = await this.updateSingleKey(offset, key)
+            result.push(...contracts)
+        }
+
+        return result
+    }
+
+    async activeContractsForTemplates(
         offset: number,
-        partyFilter: string | undefined,
-        interfaceId: string
-    ): Promise<Array<JsGetActiveContractsResponse>> {
-        const key = ACSHelper.createKey(partyFilter, undefined, interfaceId)
-        const start = performance.now()
-        const container = this.findACSContainer(key)
+        parties: PartyId[],
+        templateIds: string[]
+    ): Promise<JsGetActiveContractsResponse[]> {
+        const keys = parties.flatMap((party) =>
+            templateIds.map((templateId) =>
+                ACSHelper.createKey(party, templateId, undefined)
+            )
+        )
+        return this.queryAcsByKeys(offset, keys)
+    }
 
-        const result = container.update(
-            offset,
-            key,
-            this.apiInstance,
-            this.wsSupport
+    async activeContractsForInterfaces(
+        offset: number,
+        parties: PartyId[],
+        interfaceIds: string[]
+    ): Promise<JsGetActiveContractsResponse[]> {
+        const keys = parties.flatMap((party) =>
+            interfaceIds.map((interfaceId) =>
+                ACSHelper.createKey(party, undefined, interfaceId)
+            )
         )
 
-        const end = performance.now()
+        return this.queryAcsByKeys(offset, keys)
+    }
 
-        if (
-            this.contractsSet.has(
-                ACSHelper.keyToString(key, this.apiInstance.baseUrl.href)
-            )
-        ) {
-            SharedACSCacheStats.totalCacheServeTime += end - start
-        }
+    async activeContractsForTemplate(
+        offset: number,
+        partyFilter: PartyId,
+        templateId: string
+    ): Promise<JsGetActiveContractsResponse[]> {
+        return this.updateSingleKey(
+            offset,
+            ACSHelper.createKey(partyFilter, templateId, undefined)
+        )
+    }
 
-        return result
+    async activeContractsForInterface(
+        offset: number,
+        partyFilter: PartyId | undefined,
+        interfaceId: string
+    ): Promise<Array<JsGetActiveContractsResponse>> {
+        return this.updateSingleKey(
+            offset,
+            ACSHelper.createKey(partyFilter, undefined, interfaceId)
+        )
     }
 }

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

@@ -534,50 +534,26 @@ export class LedgerClient {
         interfaceIds?: string[]
         limit?: number
     }): Promise<Array<Types['JsGetActiveContractsResponse']>> {
-        const {
-            offset,
-            templateIds,
-            parties,
-            filterByParty,
-            interfaceIds,
-            limit,
-        } = options
+        const { offset, templateIds, parties, interfaceIds, limit } = options
 
         this.logger.debug(options, 'options for active contracts')
 
-        if (templateIds?.length === 1 && parties?.length === 1) {
-            const party = parties[0]
-            const templateId = templateIds[0]
-            return this.acsHelper.activeContractsForTemplate(
-                offset,
-                party,
-                templateId
-            )
-        }
+        const hasParties = Array.isArray(parties) && parties.length > 0
 
-        if (interfaceIds?.length === 1 && parties?.length === 1) {
-            const party = parties[0]
-            const interfaceId = interfaceIds[0]
-            return this.acsHelper.activeContractsForInterface(
+        if (templateIds?.length && hasParties) {
+            return this.acsHelper.activeContractsForTemplates(
                 offset,
-                party,
-                interfaceId
+                parties!,
+                templateIds!
             )
         }
 
-        if (
-            filterByParty &&
-            !templateIds?.length &&
-            !interfaceIds?.length &&
-            parties?.length === 1
-        ) {
-            const party = parties[0]
-            const r = this.acsHelper.activeContractsForInterface(
+        if (interfaceIds?.length && hasParties) {
+            return this.acsHelper.activeContractsForInterfaces(
                 offset,
-                party,
-                ''
+                parties!,
+                interfaceIds!
             )
-            return r
         }
 
         const filter = this.buildActiveContractFilter(options)