Contract Search

backend/.gitignore

@@ -447,3 +447,5 @@ $RECYCLE.BIN/
 !.vscode/tasks.json
 !.vscode/launch.json
 !.vscode/extensions.json
+
+/Logs

backend/Application/Aggregates/Contract/BackgroundServices/ContractJobsBackgroundService.cs

@@ -1,6 +1,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Application.Aggregates.Contract.Jobs;
+using Application.Observability;
 using Application.Configurations;
 using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Options;
@@ -33,6 +34,8 @@ IOptions<FeatureFlagOptions> featureFlagsOptions
 
     protected override async Task ExecuteAsync(CancellationToken stoppingToken)
     {
+        using var _ = TraceContext.StartActivity(nameof(ContractJobsBackgroundService));
+
         if (!_featureFlags.ConcordiumNodeImportEnabled)
         {
             _logger.Information("Import data from Concordium node is disabled. This controller will not run!");
@@ -73,4 +76,4 @@ private async Task RunJob(IContractJob job, CancellationToken token)
             throw;
         }
     }
-}
+}

backend/Application/Aggregates/Contract/BackgroundServices/ContractNodeImportBackgroundService.cs

@@ -4,6 +4,7 @@
 using Application.Aggregates.Contract.Jobs;
 using Application.Aggregates.Contract.Observability;
 using Application.Api.GraphQL.EfCore;
+using Application.Observability;
 using Application.Configurations;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Hosting;
@@ -46,6 +47,8 @@ public ContractNodeImportBackgroundService(
 
     protected override async Task ExecuteAsync(CancellationToken stoppingToken)
     {
+        using var _ = TraceContext.StartActivity(nameof(ContractNodeImportBackgroundService));
+
         if (!_featureFlags.ConcordiumNodeImportEnabled)
         {
             _logger.Information("Import data from Concordium node is disabled. This controller will not run!");

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

@@ -11,5 +11,5 @@ public class ContractAggregateJobOptions
     ///
     /// Increasing batch size will increase memory consumption on job since more will be loaded into memory.
     /// </summary>
-    public int BatchSize { get; set; } = 10_000;
+    public int BatchSize { get; set; } = 5_000;
 }

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

@@ -1,3 +1,4 @@
+using Application.Aggregates.Contract.Entities;
 using Application.Api.GraphQL.EfCore.Converters.EfCore;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
@@ -11,9 +12,6 @@ public void Configure(EntityTypeBuilder<Entities.Contract> builder)
         builder.ToTable("graphql_contracts");
         builder.HasKey(x => new
         {
-            x.BlockHeight, 
-            x.TransactionIndex,
-            x.EventIndex,
             x.ContractAddressIndex,
             x.ContractAddressSubIndex
         });
@@ -29,12 +27,19 @@ public void Configure(EntityTypeBuilder<Entities.Contract> builder)
             .HasColumnName("contract_address_index");
         builder.Property(x => x.ContractAddressSubIndex)
             .HasColumnName("contract_address_sub_index");
+        builder.Property(x => x.ContractAddress)
+            .HasColumnName("contract_address");
         builder.Property(x => x.Creator)
             .HasColumnName("creator")
             .HasConversion<AccountAddressConverter>();
         builder.Property(x => x.Source)
             .HasColumnName("source");
         builder.Property(x => x.CreatedAt)
-            .HasColumnName("created_at");        
+            .HasColumnName("created_at");
+
+        builder
+            .HasMany<ContractEvent>(sm => sm.ContractEvents)
+            .WithOne()
+            .HasForeignKey(sme => new { sme.ContractAddressIndex, sme.ContractAddressSubIndex });
     }
 }

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

@@ -37,6 +37,6 @@ public void Configure(EntityTypeBuilder<ContractEvent> builder)
         builder.Property(x => x.Source)
             .HasColumnName("source");
         builder.Property(x => x.CreatedAt)
-            .HasColumnName("created_at");        
+            .HasColumnName("created_at");
     }
 }

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

@@ -16,7 +16,8 @@ public void Configure(EntityTypeBuilder<ModuleReferenceContractLinkEvent> builde
             x.EventIndex,
             x.ModuleReference,
             x.ContractAddressIndex,
-            x.ContractAddressSubIndex
+            x.ContractAddressSubIndex,
+            x.LinkAction
         });
         builder.Property(x => x.BlockHeight)
             .HasColumnName("block_height");

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

@@ -11,9 +11,6 @@ public void Configure(EntityTypeBuilder<ModuleReferenceEvent> builder)
         builder.ToTable("graphql_module_reference_events");
         builder.HasKey(x => new
         {
-            x.BlockHeight,
-            x.TransactionIndex,
-            x.EventIndex,
             x.ModuleReference
         });
         builder.Property(x => x.BlockHeight)

backend/Application/Aggregates/Contract/ContractAggregate.cs

@@ -5,6 +5,7 @@
 using Application.Aggregates.Contract.Observability;
 using Application.Aggregates.Contract.Types;
 using Application.Api.GraphQL.Transactions;
+using Application.Observability;
 using Concordium.Sdk.Types;
 using AccountAddress = Application.Api.GraphQL.Accounts.AccountAddress;
 using ContractAddress = Application.Api.GraphQL.ContractAddress;
@@ -19,6 +20,8 @@ internal sealed class ContractAggregate
     private readonly IContractRepositoryFactory _repositoryFactory;
     private readonly ContractAggregateOptions _options;
     private readonly ILogger _logger;
+    private const string NodeImportJobActivity = "NodeImportJobActivity";
+    private const string NodeImportJobLoopActivity = "NodeImportJobLoopActivity";
 
     public ContractAggregate(
         IContractRepositoryFactory repositoryFactory,
@@ -32,6 +35,8 @@ ContractAggregateOptions options
 
     internal async Task NodeImportJob(IContractNodeClient client, CancellationToken token = default)
     {
+        using var _ = TraceContext.StartActivity(NodeImportJobActivity);
+
         var retryCount = 0;
         while (!token.IsCancellationRequested)
         {
@@ -294,6 +299,7 @@ private async Task NodeImportRange(IContractNodeClient client, ulong fromBlockHe
     {
         for (var height = fromBlockHeight; height <= toBlockHeight; height++)
         {
+            using var __ = TraceContext.StartActivity(NodeImportJobLoopActivity);
             using var durationMetric = new ContractMetrics.DurationMetric(ImportSource.NodeImport);
             try
             {

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

@@ -1,6 +1,12 @@
+using Application.Aggregates.Contract.Exceptions;
 using Application.Aggregates.Contract.Types;
 using Application.Api.GraphQL;
 using Application.Api.GraphQL.Accounts;
+using Application.Api.GraphQL.EfCore;
+using Application.Api.GraphQL.Transactions;
+using HotChocolate;
+using HotChocolate.Types;
+using Microsoft.EntityFrameworkCore;
 
 namespace Application.Aggregates.Contract.Entities;
 
@@ -16,9 +22,11 @@ public sealed class Contract
     public uint EventIndex { get; init; }
     public ulong ContractAddressIndex { get; init; }
     public ulong ContractAddressSubIndex { get; init; }
+    public string ContractAddress { get; init; } = null!;
     public AccountAddress Creator { get; init; } = null!;
     public ImportSource Source { get; init; }
     public DateTimeOffset CreatedAt { get; init; } = DateTime.UtcNow;
+    public ICollection<ContractEvent> ContractEvents { get; set; } = null!;
 
     /// <summary>
     /// Needed for EF Core
@@ -42,6 +50,69 @@ internal Contract(
         Creator = creator;
         ContractAddressIndex = contractAddress.Index;
         ContractAddressSubIndex = contractAddress.SubIndex;
+        ContractAddress = contractAddress.AsString;
         Source = source;
     }
-}
+
+    [ExtendObjectType(typeof(Query))]
+    public class ContractQuery
+    {
+        [UsePaging]
+        public IQueryable<Contract> GetContracts(
+            GraphQlDbContext context)
+        {
+            return context.Contract
+                .AsNoTracking()
+                .Include(s => s.ContractEvents)
+                .OrderByDescending(c => c.ContractAddressIndex);
+        }
+    }
+
+    /// <summary>
+    /// Adds additional field to the returned GraphQL type <see cref="Contract"/>
+    /// </summary>
+    [ExtendObjectType(typeof(Contract))]
+    public sealed class ContractExtensions
+    {
+        /// <summary>
+        /// Returns aggregated amount from events on contract.
+        /// </summary>
+        public double GetAmount([Parent] Contract contract)
+        {
+            if (contract.ContractEvents is null)
+            {
+                return 0;
+            }
+
+            var amount = 0L;
+            foreach (var contractEvent in contract.ContractEvents)
+            {
+                switch (contractEvent.Event)
+                {
+                    case ContractInitialized contractInitialized:
+                        amount += (long)contractInitialized.Amount;
+                        break;
+                    case ContractUpdated contractUpdated:
+                        amount += (long)contractUpdated.Amount;
+                        break;
+                    case Transferred transferred:
+                        if (transferred.From is not ContractAddress contractAddress)
+                        {
+                            throw new ContractQueryException(
+                                $"Got transfer with txHash, {contractEvent.TransactionHash}, with event on contract <{contract.ContractAddressIndex},{contract.ContractAddressSubIndex}> with FROM which wasn't a contract address.");
+                        }
+                        if (contractAddress.Index != contract.ContractAddressIndex ||
+                            contractAddress.SubIndex != contract.ContractAddressSubIndex)
+                        {
+                            throw new ContractQueryException(
+                                $"Got transfer with txHash, {contractEvent.TransactionHash}, with event on contract <{contract.ContractAddressIndex},{contract.ContractAddressSubIndex}> with FROM which wasn't same contract address but instead <{contractAddress.Index},{contractAddress.SubIndex}>");
+                        }
+                        amount -= (long)transferred.Amount;
+                        break;
+                }
+            }
+
+            return amount;
+        }
+    }
+}

backend/Application/Aggregates/Contract/Exceptions/ContractQueryException.cs

@@ -0,0 +1,10 @@
+namespace Application.Aggregates.Contract.Exceptions;
+
+/// <summary>
+/// Thrown when query of data fails.
+/// </summary>
+public class ContractQueryException : Exception
+{
+    public ContractQueryException(string message) : base(message)
+    {}
+}

backend/Application/Aggregates/Contract/Extensions/ContractExtensions.cs

@@ -3,6 +3,7 @@
 using Application.Aggregates.Contract.Jobs;
 using Application.Aggregates.Contract.Observability;
 using Dapper;
+using HotChocolate.Execution.Configuration;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Diagnostics.HealthChecks;
@@ -45,6 +46,14 @@ internal static void AddDapperTypeHandlers()
         SqlMapper.AddTypeHandler(new AccountAddressHandler());
     }
 
+    internal static IRequestExecutorBuilder AddContractGraphQlConfigurations(this IRequestExecutorBuilder builder)
+    {
+        builder
+            .AddType<Entities.Contract.ContractQuery>()
+            .AddTypeExtension<Entities.Contract.ContractExtensions>();
+        return builder;
+    }
+
     /// <summary>
     /// Background service which executes all jobs related to Smart Contracts.
     ///

backend/Application/Aggregates/Contract/Jobs/ContractDatabaseImportJob.cs

@@ -6,6 +6,7 @@
 using Application.Aggregates.Contract.Types;
 using Application.Api.GraphQL.Accounts;
 using Application.Api.GraphQL.Transactions;
+using Application.Observability;
 using Microsoft.Extensions.Options;
 
 namespace Application.Aggregates.Contract.Jobs;
@@ -41,6 +42,8 @@ ContractHealthCheck healthCheck
 
     public async Task StartImport(CancellationToken token)
     {
+        using var _ = TraceContext.StartActivity(nameof(ContractDatabaseImportJob));
+
         try
         {
             _readCount = -1;
@@ -129,6 +132,8 @@ private async Task RunBatch(long finalHeight, CancellationToken token)
     {
         while (!token.IsCancellationRequested)
         {
+            using var _ = TraceContext.StartActivity(nameof(RunBatch));
+
             var height = Interlocked.Increment(ref _readCount);
             var blockHeightTo = height * _jobOptions.BatchSize;
             if (blockHeightTo > finalHeight)
@@ -139,7 +144,7 @@ private async Task RunBatch(long finalHeight, CancellationToken token)
             var affectedRows = await DatabaseBatchImportJob((ulong)blockHeightFrom, (ulong)blockHeightTo, token);
 
             if (affectedRows == 0) continue;
-            _logger.Debug("Written heights {From} to {To}", blockHeightFrom, blockHeightTo);   
+            _logger.Information("Written heights {From} to {To}", blockHeightFrom, blockHeightTo);   
         }
     }
 

backend/Application/Aggregates/Contract/Observability/ContractMetrics.cs

@@ -1,6 +1,7 @@
 using System.Diagnostics;
 using Application.Aggregates.Contract.Types;
 using Prometheus;
+using static Application.Observability.ApplicationMetrics;
 
 namespace Application.Aggregates.Contract.Observability;
 
@@ -70,25 +71,6 @@ public void Dispose()
                 .WithLabels(_source.ToStringCached(), _exceptionName)
                 .Observe(elapsedSeconds);
         }
-
-        private static string PrettyPrintException(Exception ex)
-        {
-            var type = ex.GetType();
-            if (type.GenericTypeArguments.Length == 0)
-            {
-                return type.Name;
-            }
-
-            var name = type.Name.AsSpan();
-            var indexOfGenericCount = name.IndexOf('`');
-            if (indexOfGenericCount != -1)
-            {
-                name = name[..indexOfGenericCount];
-            }
-            var typeArguments = string.Join(",", type.GenericTypeArguments.Select(t => t.Name));
-
-            return $"{name}<{typeArguments}>";
-        }
     }
 }