Contract Listing View

backend/Application/Aggregates/Contract/Configurations/ContractEntityTypeConfigurations.cs

@@ -41,5 +41,10 @@ public void Configure(EntityTypeBuilder<Entities.Contract> builder)
             .HasMany<ContractEvent>(sm => sm.ContractEvents)
             .WithOne()
             .HasForeignKey(sme => new { sme.ContractAddressIndex, sme.ContractAddressSubIndex });
+
+        builder
+            .HasMany<ModuleReferenceContractLinkEvent>(c => c.ModuleReferenceContractLinkEvents)
+            .WithOne()
+            .HasForeignKey(link => new { link.ContractAddressIndex, link.ContractAddressSubIndex });
     }
 }

backend/Application/Aggregates/Contract/Entities/Contract.cs

@@ -26,7 +26,8 @@ public sealed class Contract
     public ImportSource Source { get; init; }
     public DateTimeOffset BlockSlotTime { get; init; }
     public DateTimeOffset CreatedAt { get; init; } = DateTime.UtcNow;
-    public ICollection<ContractEvent> ContractEvents { get; set; }
+    public ICollection<ContractEvent> ContractEvents { get; set; } = null!;
+    public ICollection<ModuleReferenceContractLinkEvent> ModuleReferenceContractLinkEvents { get; set; } = null!;
 
     /// <summary>
     /// Needed for EF Core
@@ -58,13 +59,27 @@ internal Contract(
     [ExtendObjectType(typeof(Query))]
     public class ContractQuery
     {
+        /// <summary>
+        /// Get contracts with pagination support.
+        /// 
+        /// Currently contracts module reference are not updated for the lifetime of the contract. Hence often there will
+        /// be only one module link event for each contract.
+        ///
+        /// Because of this we are currently not using <see cref="Microsoft.EntityFrameworkCore.RelationalQueryableExtensions.AsSplitQuery"/>.
+        /// If performance issues on this query is seen and module reference links increases then look into using above splitting technique.
+        /// </summary>
+        /// <remarks>
+        ///     See <see href="https://aka.ms/efcore-docs-split-queries">EF Core split queries</see> for more information.
+        /// </remarks> 
         [UsePaging]
         public IQueryable<Contract> GetContracts(
             GraphQlDbContext context)
         {
             return context.Contract
                 .AsNoTracking()
-                .Include(s => s.ContractEvents);
+                .Include(s => s.ContractEvents)
+                .Include(s => s.ModuleReferenceContractLinkEvents)
+                .OrderByDescending(c => c.ContractAddressIndex);
         }
     }
 
@@ -77,6 +92,20 @@ public sealed class ContractExtensions
         public ContractAddress GetContractAddress([Parent] Contract contract) => 
             new(contract.ContractAddressIndex, contract.ContractAddressSubIndex);
 
+        /// <summary>
+        /// Returns the current linked module reference which is the latest added <see cref="ModuleReferenceContractLinkEvent"/>.
+        /// </summary>
+        public string GetModuleReference([Parent] Contract contract)
+        {
+            var link = contract.ModuleReferenceContractLinkEvents
+                .Where(link => link.LinkAction == ModuleReferenceContractLinkEvent.ModuleReferenceContractLinkAction.Added)
+                .OrderByDescending(link => link.BlockHeight)
+                .ThenByDescending(link => link.TransactionIndex)
+                .ThenByDescending(link => link.EventIndex)
+                .First();
+            return link.ModuleReference;
+        }
+
         /// <summary>
         /// Returns aggregated amount from events on contract.
         /// </summary>

backend/Application/Common/Logging/TraceEnricher.cs

@@ -18,7 +18,7 @@ public void Enrich(LogEvent logEvent, ILogEventPropertyFactory propertyFactory)
         }
 
         logEvent.AddPropertyIfAbsent(propertyFactory.CreateProperty(Id, Activity.Current.Id));
-        logEvent.AddPropertyIfAbsent(propertyFactory.CreateProperty(TraceId, Activity.Current.Id));
-        logEvent.AddPropertyIfAbsent(propertyFactory.CreateProperty(SpanId, Activity.Current.Id));
+        logEvent.AddPropertyIfAbsent(propertyFactory.CreateProperty(TraceId, Activity.Current.TraceId));
+        logEvent.AddPropertyIfAbsent(propertyFactory.CreateProperty(SpanId, Activity.Current.SpanId));
     }
-}
+}

backend/Application/Observability/ObservabilityExecutionDiagnosticEventListener.cs

@@ -170,4 +170,4 @@ private static bool TryGetQuery(IHasContextData context, out string? query)
 
         return false;
     }
-}
+}

backend/Tests/Aggregates/Contract/Entities/ContractTests.cs

@@ -0,0 +1,85 @@
+using System.Collections.Generic;
+using Application.Aggregates.Contract.Entities;
+using Application.Api.GraphQL;
+using Application.Api.GraphQL.Transactions;
+using FluentAssertions;
+using Tests.TestUtilities.Builders;
+
+namespace Tests.Aggregates.Contract.Entities;
+
+public sealed class ContractTests
+{
+    private readonly Application.Aggregates.Contract.Entities.Contract.ContractExtensions _contractExtensions;
+
+    public ContractTests()
+    {
+        _contractExtensions = new Application.Aggregates.Contract.Entities.Contract.ContractExtensions();
+    }
+
+    [Fact]
+    public void WhenGetModuleReference_ThenReturnLatestAdded()
+    {
+        // Arrange
+        const string expectedModuleReference = "foobar";
+        var a = ModuleReferenceContractLinkEventBuilder.Create()
+            .WithBlockHeight(6)
+            .WithTransactionIndex(5)
+            .WithEventIndex(4)
+            .WithModuleReference(expectedModuleReference)
+            .WithLinkAction(ModuleReferenceContractLinkEvent.ModuleReferenceContractLinkAction.Added)
+            .Build();
+        var b = ModuleReferenceContractLinkEventBuilder.Create()
+            .WithBlockHeight(7)
+            .WithTransactionIndex(5)
+            .WithEventIndex(4)
+            .WithLinkAction(ModuleReferenceContractLinkEvent.ModuleReferenceContractLinkAction.Removed)
+            .Build();
+        var c = ModuleReferenceContractLinkEventBuilder.Create()
+            .WithBlockHeight(6)
+            .WithTransactionIndex(4)
+            .WithLinkAction(ModuleReferenceContractLinkEvent.ModuleReferenceContractLinkAction.Added)
+            .Build();
+        var d = ModuleReferenceContractLinkEventBuilder.Create()
+            .WithBlockHeight(5)
+            .WithLinkAction(ModuleReferenceContractLinkEvent.ModuleReferenceContractLinkAction.Added)
+            .Build();
+        var contract = ContractBuilder
+            .Create()
+            .WithModuleReferenceContractLinkEvents(new List<ModuleReferenceContractLinkEvent>
+            {
+                a, b, c, d
+            })
+            .Build();
+
+        // Act
+        var moduleReference = _contractExtensions.GetModuleReference(contract);
+
+        // Assert
+        moduleReference.Should().Be(expectedModuleReference);
+    }
+
+    [Fact]
+    public void WhenGetAmount_ThenReturnCorrectAmount()
+    {
+        // Arrange
+        var from = new ContractAddress(1, 1);
+        var to = new ContractAddress(2, 1);
+        var contractEvents = new List<ContractEvent>{
+            ContractEventBuilder.Create().WithEvent(new Transferred(42, from, to)).Build(),
+            ContractEventBuilder.Create().WithEvent(new Transferred(2, to, from)).Build(),
+            ContractEventBuilder.Create().WithEvent(new ContractInitialized("", new ContractAddress(1,0), 10, "", ContractVersion.V0, Array.Empty<string>())).Build(),
+            ContractEventBuilder.Create().WithEvent(new ContractUpdated(new ContractAddress(1,0), new ContractAddress(1,0), 7, "", "", ContractVersion.V0,  Array.Empty<string>())).Build()
+        };
+        var contract = ContractBuilder
+            .Create()
+            .WithContractAddress(to)
+            .WithContractEvents(contractEvents)
+            .Build();
+
+        // Act
+        var amount = _contractExtensions.GetAmount(contract);
+
+        // Assert
+        amount.Should().Be(57);
+    }
+}

backend/Tests/Api/GraphQL/__snapshots__/committed-schema.verified.graphql

@@ -722,7 +722,9 @@ type Contract {
   blockSlotTime: DateTime!
   createdAt: DateTime!
   contractEvents: [ContractEvent!]!
+  moduleReferenceContractLinkEvents: [ModuleReferenceContractLinkEvent!]!
   contractAddress: ContractAddress!
+  moduleReference: String!
   amount: Float!
 }
 
@@ -1193,6 +1195,21 @@ type ModuleNotWf {
   _: Boolean! @deprecated(reason: "Don't use! This field is only in the schema to make sure reject reasons without any fields are valid types in GraphQL (which does not allow types without any fields)")
 }
 
+type ModuleReferenceContractLinkEvent {
+  blockHeight: UnsignedLong!
+  transactionHash: String!
+  transactionIndex: UnsignedLong!
+  eventIndex: UnsignedInt!
+  moduleReference: String!
+  contractAddressIndex: UnsignedLong!
+  contractAddressSubIndex: UnsignedLong!
+  sender: AccountAddress!
+  source: ImportSource!
+  linkAction: ModuleReferenceContractLinkAction!
+  blockSlotTime: DateTime!
+  createdAt: DateTime!
+}
+
 type NewEncryptedAmount {
   accountAddress: AccountAddress!
   newIndex: UnsignedLong!
@@ -1939,6 +1956,11 @@ enum MetricsPeriod {
   LAST_YEAR
 }
 
+enum ModuleReferenceContractLinkAction {
+  ADDED
+  REMOVED
+}
+
 enum NodeSortDirection {
   ASC
   DSC

backend/Tests/TestUtilities/Builders/ContractBuilder.cs

@@ -0,0 +1,65 @@
+using System.Collections.Generic;
+using Application.Aggregates.Contract.Entities;
+using Application.Aggregates.Contract.Types;
+using Application.Api.GraphQL;
+using Application.Api.GraphQL.Accounts;
+
+namespace Tests.TestUtilities.Builders;
+
+internal sealed class ContractBuilder
+{
+    private readonly ulong _blockHeight = 1;
+    private readonly string _transactionHash = "";
+    private readonly ulong _transactionIndex = 1;
+    private readonly uint _eventIndex = 1;
+    private ContractAddress _contractAddress = new(1, 0);
+    private readonly AccountAddress _accountAddress = new("");
+    private readonly ImportSource _source = ImportSource.DatabaseImport;
+    private readonly DateTimeOffset _dateTimeOffset = DateTimeOffset.UtcNow;
+    private IList<ModuleReferenceContractLinkEvent> _moduleReferenceContractLinkEvents = new List<ModuleReferenceContractLinkEvent>();
+    private IList<ContractEvent> _contractEvents = new List<ContractEvent>();
+
+    private ContractBuilder() {}
+
+    internal static ContractBuilder Create()
+    {
+        return new ContractBuilder();
+    }
+
+    internal Contract Build()
+    {
+        return new Contract(
+            _blockHeight,
+            _transactionHash,
+            _transactionIndex,
+            _eventIndex,
+            _contractAddress,
+            _accountAddress,
+            _source,
+            _dateTimeOffset
+        )
+        {
+            ModuleReferenceContractLinkEvents = _moduleReferenceContractLinkEvents,
+            ContractEvents = _contractEvents
+        };
+    }
+
+    internal ContractBuilder WithContractEvents(IList<ContractEvent> events)
+    {
+        _contractEvents = events;
+        return this;
+    }
+
+    internal ContractBuilder WithModuleReferenceContractLinkEvents(IList<ModuleReferenceContractLinkEvent> events)
+    {
+        _moduleReferenceContractLinkEvents = events;
+        return this;
+    }
+
+    internal ContractBuilder WithContractAddress(ContractAddress contractAddress)
+    {
+        _contractAddress = contractAddress;
+        return this;
+    }
+
+}

backend/Tests/TestUtilities/Builders/ContractEventBuilder.cs

@@ -0,0 +1,53 @@
+using Application.Aggregates.Contract.Entities;
+using Application.Aggregates.Contract.Types;
+using Application.Api.GraphQL;
+using Application.Api.GraphQL.Accounts;
+using Application.Api.GraphQL.Transactions;
+
+namespace Tests.TestUtilities.Builders;
+
+internal sealed class ContractEventBuilder
+{
+    private readonly ulong _blockHeight = 1;
+    private readonly string _transactionHash = "";
+    private readonly ulong _transactionIndex = 1;
+    private readonly uint _eventIndex = 1;
+    private readonly ContractAddress _contractAddress = new(1, 0);
+    private readonly AccountAddress _accountAddress = new("");
+    private TransactionResultEvent _event =
+        new Transferred(1, new ContractAddress(1, 0), new ContractAddress(2, 0));
+
+    private readonly ImportSource _source = ImportSource.DatabaseImport;
+    private readonly DateTimeOffset _dateTimeOffset = DateTimeOffset.UtcNow;
+
+    private ContractEventBuilder()
+    {
+    }
+
+    internal static ContractEventBuilder Create()
+    {
+        return new ContractEventBuilder();
+    }
+
+    internal ContractEvent Build()
+    {
+        return new ContractEvent(
+            _blockHeight,
+            _transactionHash,
+            _transactionIndex, 
+            _eventIndex,
+            _contractAddress,
+            _accountAddress,
+            _event,
+            _source,
+            _dateTimeOffset
+        );
+    }
+
+    internal ContractEventBuilder WithEvent(TransactionResultEvent @event)
+    {
+        _event = @event;
+        return this;
+    }
+
+}