Typed ACS and transaction streams for Java codegen

language-support/java/bindings/src/main/java/com/daml/ledger/javaapi/data/TransactionFilter.java

@@ -4,7 +4,13 @@
 package com.daml.ledger.javaapi.data;
 
 import com.daml.ledger.api.v1.TransactionFilterOuterClass;
+import com.daml.ledger.javaapi.data.codegen.ContractCompanion;
+import com.daml.ledger.javaapi.data.codegen.ContractTypeCompanion;
+import java.util.Collections;
+import java.util.Map;
 import java.util.Set;
+import java.util.function.Function;
+import java.util.stream.Collectors;
 
 public abstract class TransactionFilter {
 
@@ -17,4 +23,17 @@ public static TransactionFilter fromProto(
   abstract TransactionFilterOuterClass.TransactionFilter toProto();
 
   public abstract Set<String> getParties();
+
+  public static TransactionFilter transactionFilter(
+      ContractTypeCompanion<?, ?> contractCompanion, Set<String> parties) {
+    Filter filter =
+        (contractCompanion instanceof ContractCompanion)
+            ? new InclusiveFilter(Set.of(contractCompanion.TEMPLATE_ID), Collections.emptyMap())
+            : new InclusiveFilter(
+                Collections.emptySet(),
+                Map.of(contractCompanion.TEMPLATE_ID, Filter.Interface.INCLUDE_VIEW));
+    Map<String, Filter> partyToFilters =
+        parties.stream().collect(Collectors.toMap(Function.identity(), x -> filter));
+    return new FiltersByParty(partyToFilters);
+  }
 }

language-support/java/bindings/src/main/java/com/daml/ledger/javaapi/data/codegen/Contract.java

@@ -42,9 +42,6 @@ protected Contract(
     this.observers = observers;
   }
 
-  // concrete 1st type param would need a self-reference type param in Contract
-  protected abstract ContractCompanion<? extends Contract<Id, Data>, Id, Data> getCompanion();
-
   @Override
   public boolean equals(Object object) {
     if (this == object) {
@@ -74,12 +71,7 @@ public int hashCode() {
   @Override
   public String toString() {
     return String.format(
-        "%s.Contract(%s, %s, %s, %s, %s)",
-        getCompanion().templateClassName,
-        this.id,
-        this.data,
-        this.agreementText,
-        this.signatories,
-        this.observers);
+        "Contract(%s, %s, %s, %s, %s)",
+        this.id, this.data, this.agreementText, this.signatories, this.observers);
   }
 }

language-support/java/bindings/src/main/java/com/daml/ledger/javaapi/data/codegen/ContractCompanion.java

@@ -3,10 +3,8 @@
 
 package com.daml.ledger.javaapi.data.codegen;
 
-import com.daml.ledger.javaapi.data.CreatedEvent;
+import com.daml.ledger.javaapi.data.*;
 import com.daml.ledger.javaapi.data.DamlRecord;
-import com.daml.ledger.javaapi.data.Identifier;
-import com.daml.ledger.javaapi.data.Value;
 import java.util.Optional;
 import java.util.Set;
 import java.util.function.Function;

language-support/java/bindings/src/main/java/com/daml/ledger/javaapi/data/codegen/ContractTypeCompanion.java

@@ -6,7 +6,7 @@
 import com.daml.ledger.javaapi.data.Identifier;
 
 /** The commonality between {@link ContractCompanion} and {@link InterfaceCompanion}. */
-public abstract class ContractTypeCompanion<Maker, Data> {
+public abstract class ContractTypeCompanion<Marker, Data> {
   /** The full template ID of the template or interface that defined this companion. */
   public final Identifier TEMPLATE_ID;
 

language-support/java/bindings/src/main/java/com/daml/ledger/javaapi/data/codegen/ContractWithInterfaceView.java

@@ -0,0 +1,24 @@
+// Copyright (c) 2022 Digital Asset (Switzerland) GmbH and/or its affiliates. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package com.daml.ledger.javaapi.data.codegen;
+
+import java.util.Optional;
+import java.util.Set;
+
+public final class ContractWithInterfaceView<Id, View> extends Contract<Id, View> {
+
+  ContractWithInterfaceView(
+      Id id,
+      View interfaceView,
+      Optional<String> agreementText,
+      Set<String> signatories,
+      Set<String> observers) {
+    super(id, interfaceView, agreementText, signatories, observers);
+  }
+
+  @Override
+  public boolean equals(Object object) {
+    return object instanceof ContractWithInterfaceView && super.equals(object);
+  }
+}

language-support/java/bindings/src/main/java/com/daml/ledger/javaapi/data/codegen/ContractWithKey.java

@@ -38,13 +38,7 @@ public final int hashCode() {
   @Override
   public final String toString() {
     return String.format(
-        "%s.Contract(%s, %s, %s, %s, %s, %s)",
-        getCompanion().templateClassName,
-        this.id,
-        this.data,
-        this.agreementText,
-        this.key,
-        this.signatories,
-        this.observers);
+        "Contract(%s, %s, %s, %s, %s, %s)",
+        this.id, this.data, this.agreementText, this.key, this.signatories, this.observers);
   }
 }

language-support/java/bindings/src/main/java/com/daml/ledger/javaapi/data/codegen/InterfaceCompanion.java

@@ -3,20 +3,57 @@
 
 package com.daml.ledger.javaapi.data.codegen;
 
-import com.daml.ledger.javaapi.data.Identifier;
+import com.daml.ledger.javaapi.data.*;
+import com.daml.ledger.javaapi.data.DamlRecord;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.Function;
 
 /**
  * Metadata and utilities associated with an interface as a whole. Its subclasses serve to
  * disambiguate various generated {@code toInterface} overloads.
  *
  * @param <I> The generated interface marker class.
  */
-public abstract class InterfaceCompanion<I, View> extends ContractTypeCompanion<I, View> {
+public abstract class InterfaceCompanion<I, Id, View> extends ContractTypeCompanion<I, View> {
+
+  protected final Function<String, Id> newContractId;
 
   public final ValueDecoder<View> valueDecoder;
 
-  protected InterfaceCompanion(Identifier templateId, ValueDecoder<View> valueDecoder) {
+  private Contract<Id, View> fromIdAndRecord(
+      String contractId,
+      Map<Identifier, DamlRecord> interfaceViews,
+      Optional<String> agreementText,
+      Set<String> signatories,
+      Set<String> observers)
+      throws IllegalAccessException {
+    Optional<DamlRecord> maybeRecord = Optional.ofNullable(interfaceViews.get(TEMPLATE_ID));
+    Id id = newContractId.apply(contractId);
+    if (maybeRecord.isPresent()) {
+      View view = valueDecoder.decode(maybeRecord.get());
+      return new ContractWithInterfaceView<>(id, view, agreementText, signatories, observers);
+    } else {
+      // TODO: CL handle all exceptional cases
+      throw new IllegalAccessException("interface view not found. It could be failed");
+    }
+  }
+
+  public final Contract<Id, View> fromCreatedEvent(CreatedEvent event)
+      throws IllegalAccessException {
+    return fromIdAndRecord(
+        event.getContractId(),
+        event.getInterfaceViews(),
+        event.getAgreementText(),
+        event.getSignatories(),
+        event.getObservers());
+  }
+
+  protected InterfaceCompanion(
+      Identifier templateId, Function<String, Id> newContractId, ValueDecoder<View> valueDecoder) {
     super(templateId);
+    this.newContractId = newContractId;
     this.valueDecoder = valueDecoder;
   }
 }

language-support/java/codegen/src/main/scala/com/digitalasset/daml/lf/codegen/backend/java/inner/ContractClass.scala

@@ -107,19 +107,6 @@ object ContractClass {
 
     private[this] val contractIdClassName = ClassName bestGuess "ContractId"
 
-    private[this] def generateGetCompanion(templateClassName: ClassName): MethodSpec = {
-      val contractClassName = ClassName bestGuess "Contract"
-      ClassGenUtils.generateGetCompanion(
-        ParameterizedTypeName.get(
-          ClassName get classOf[javaapi.data.codegen.ContractCompanion[_, _, _]],
-          contractClassName,
-          contractIdClassName,
-          templateClassName,
-        ),
-        companionFieldName,
-      )
-    }
-
     def create(
         templateClassName: ClassName,
         key: Option[Type],
@@ -172,8 +159,6 @@ object ContractClass {
       classBuilder.addMethod(constructor)
 
       val contractClassName = ClassName.bestGuess("Contract")
-      classBuilder
-        .addMethod(generateGetCompanion(templateClassName))
       new Builder(
         classBuilder,
         contractClassName,

language-support/java/codegen/src/main/scala/com/digitalasset/daml/lf/codegen/backend/java/inner/InterfaceClass.scala

@@ -84,27 +84,36 @@ object InterfaceClass extends StrictLogging {
   private def generateInterfaceCompanionClass(
       interfaceName: ClassName,
       interfaceViewTypeName: ClassName,
-  ): TypeSpec = TypeSpec
-    .classBuilder(companionName)
-    .superclass(
-      ParameterizedTypeName
-        .get(ClassName get classOf[InterfaceCompanion[_, _]], interfaceName, interfaceViewTypeName)
-    )
-    .addModifiers(Modifier.FINAL, Modifier.PUBLIC, Modifier.STATIC)
-    .addMethod {
-      MethodSpec
-        .constructorBuilder()
-        // intentionally package-private
-        .addStatement(
-          "super($T.$N, $T.$L())",
-          interfaceName,
-          ClassGenUtils.templateIdFieldName,
-          interfaceViewTypeName,
-          "valueDecoder",
-        )
-        .build()
-    }
-    .build()
+  ): TypeSpec = {
+    val contractIdClassName = ClassName bestGuess "ContractId"
+    TypeSpec
+      .classBuilder(companionName)
+      .superclass(
+        ParameterizedTypeName
+          .get(
+            ClassName get classOf[InterfaceCompanion[_, _, _]],
+            interfaceName,
+            contractIdClassName,
+            interfaceViewTypeName,
+          )
+      )
+      .addModifiers(Modifier.FINAL, Modifier.PUBLIC, Modifier.STATIC)
+      .addMethod {
+        MethodSpec
+          .constructorBuilder()
+          // intentionally package-private
+          .addStatement(
+            "super($T.$N, $T::new, $T.$L())",
+            interfaceName,
+            ClassGenUtils.templateIdFieldName,
+            contractIdClassName,
+            interfaceViewTypeName,
+            "valueDecoder",
+          )
+          .build()
+      }
+      .build()
+  }
 
   private def generateTemplateIdField(packageId: PackageId, name: QualifiedName): FieldSpec =
     ClassGenUtils.generateTemplateIdField(