From c88c74cb70cfbb709d9bcd9aa98376b178826a37 Mon Sep 17 00:00:00 2001
From: Mirko Da Corte <mirko@etherna.io>
Date: Sun, 26 Feb 2023 00:29:54 +0100
Subject: [PATCH 1/2] start upload service refactor

---
 .../Dtos/ManifestDto.cs                       | 30 +++++++++++++++++--
 .../Dtos/ManifestThumbnailDto.cs              | 20 ++++++++++++-
 src/EthernaVideoImporter.Core/Models/Video.cs | 12 +++++++-
 .../Models/VideoMetadataBase.cs               |  3 ++
 .../Models/YouTubeVideoMetadataBase.cs        |  3 +-
 .../Services/VideoUploaderService.cs          |  8 ++---
 .../Utilities/YoutubeDownloader.cs            |  2 +-
 .../Models/MdFileVideoMetadata.cs             |  3 +-
 .../Services/MdVideoProvider.cs               | 10 +++++--
 .../Models/YouTubeVideoMetadata.cs            |  3 +-
 .../Services/YouTubeChannelVideoProvider.cs   |  6 ++++
 11 files changed, 84 insertions(+), 16 deletions(-)

diff --git a/src/EthernaVideoImporter.Core/Dtos/ManifestDto.cs b/src/EthernaVideoImporter.Core/Dtos/ManifestDto.cs
index cef1023..57100ed 100644
--- a/src/EthernaVideoImporter.Core/Dtos/ManifestDto.cs
+++ b/src/EthernaVideoImporter.Core/Dtos/ManifestDto.cs
@@ -12,20 +12,45 @@
 //   See the License for the specific language governing permissions and
 //   limitations under the License.
 
+using Etherna.VideoImporter.Core.Models;
+using System;
 using System.Collections.Generic;
+using System.Linq;
+using System.Text.Json;
 
 namespace Etherna.VideoImporter.Core.Dtos
 {
     public sealed class ManifestDto
     {
         // Constructors.
+        public ManifestDto(
+            Video video,
+            string batchId,
+            string ownerAddress)
+        {
+            if (video is null)
+                throw new ArgumentNullException(nameof(video));
+
+            Title = video.Metadata.Title;
+            Description = video.Metadata.Description;
+            OriginalQuality = video.Metadata.OriginVideoQualityLabel;
+            OwnerAddress = ownerAddress;
+            Duration = (long)video.Metadata.Duration.TotalSeconds;
+            Thumbnail = video.ThumbnailFile is null ? null : new ManifestThumbnailDto(video.ThumbnailFile);
+            Sources = video.EncodedFiles.OfType<VideoFile>().Select(vf => new ManifestVideoSourceDto(vf));
+            CreatedAt = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();
+            UpdatedAt = null;
+            BatchId = batchId;
+            PersonalData = JsonSerializer.Serialize(ManifestPersonalDataDto.BuildNew(video.Metadata.Id));
+        }
+
         public ManifestDto(
             string title,
             string description,
             string originalQuality,
             string ownerAddress,
             long duration,
-            ManifestThumbnailDto thumbnail,
+            ManifestThumbnailDto? thumbnail,
             IEnumerable<ManifestVideoSourceDto> sources,
             long createdAt,
             long? updatedAt,
@@ -46,13 +71,12 @@ public ManifestDto(
         }
 
         // Properties.
-        //public string Id { get; }
         public string Title { get; }
         public string Description { get; }
         public string OriginalQuality { get; }
         public string OwnerAddress { get; }
         public long Duration { get; }
-        public ManifestThumbnailDto Thumbnail { get; }
+        public ManifestThumbnailDto? Thumbnail { get; }
         public IEnumerable<ManifestVideoSourceDto> Sources { get; }
         public long CreatedAt { get; }
         public long? UpdatedAt { get; }
diff --git a/src/EthernaVideoImporter.Core/Dtos/ManifestThumbnailDto.cs b/src/EthernaVideoImporter.Core/Dtos/ManifestThumbnailDto.cs
index ee44d47..ca006cc 100644
--- a/src/EthernaVideoImporter.Core/Dtos/ManifestThumbnailDto.cs
+++ b/src/EthernaVideoImporter.Core/Dtos/ManifestThumbnailDto.cs
@@ -12,13 +12,32 @@
 //   See the License for the specific language governing permissions and
 //   limitations under the License.
 
+using Blurhash.SkiaSharp;
+using Etherna.VideoImporter.Core.Models;
+using SkiaSharp;
+using System;
 using System.Collections.Generic;
+using System.IO;
 
 namespace Etherna.VideoImporter.Core.Dtos
 {
     public sealed class ManifestThumbnailDto
     {
         // Constructors.
+        public ManifestThumbnailDto(ThumbnailFile thumbnailFile)
+        {
+            if (thumbnailFile?.UploadedHashReference is null)
+                throw new ArgumentNullException(nameof(thumbnailFile));
+
+            using var thumbFileStream = File.OpenRead(thumbnailFile.DownloadedFilePath);
+            using var thumbManagedStream = new SKManagedStream(thumbFileStream);
+            using var thumbBitmap = SKBitmap.Decode(thumbManagedStream);
+
+            AspectRatio = thumbnailFile.Width / thumbnailFile.Height;
+            Blurhash = Blurhasher.Encode(thumbBitmap, 4, 4);
+            Sources = new Dictionary<string, string>() { {$"{thumbBitmap.Width}w", thumbnailFile.UploadedHashReference} };
+        }
+
         public ManifestThumbnailDto(
             float aspectRatio,
             string blurhash,
@@ -33,6 +52,5 @@ public ManifestThumbnailDto(
         public float AspectRatio { get; set; }
         public string Blurhash { get; set; }
         public IDictionary<string, string> Sources { get; }
-        public string V { get; } = "1.0";
     }
 }
diff --git a/src/EthernaVideoImporter.Core/Models/Video.cs b/src/EthernaVideoImporter.Core/Models/Video.cs
index ccfc5ef..3653a16 100644
--- a/src/EthernaVideoImporter.Core/Models/Video.cs
+++ b/src/EthernaVideoImporter.Core/Models/Video.cs
@@ -1,4 +1,8 @@
-using System.Collections.Generic;
+using Etherna.VideoImporter.Core.Dtos;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text.Json;
 
 namespace Etherna.VideoImporter.Core.Models
 {
@@ -10,6 +14,9 @@ public Video(
             IEnumerable<FileBase> encodedFiles,
             ThumbnailFile? thumbnailFile)
         {
+            if (!encodedFiles.Any())
+                throw new ArgumentException("Must exist at least a stream");
+
             EncodedFiles = encodedFiles;
             Metadata = metadata;
             ThumbnailFile = thumbnailFile;
@@ -21,5 +28,8 @@ public Video(
         public string? EthernaPermalinkHash { get; set; }
         public VideoMetadataBase Metadata { get; }
         public ThumbnailFile? ThumbnailFile { get; }
+        public long TotalByteSize => EncodedFiles.Sum(f => f.ByteSize) +
+            ThumbnailFile?.ByteSize ?? 0 +
+            JsonSerializer.Serialize(new ManifestDto(this, "0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000")).Length;
     }
 }
diff --git a/src/EthernaVideoImporter.Core/Models/VideoMetadataBase.cs b/src/EthernaVideoImporter.Core/Models/VideoMetadataBase.cs
index 02168b9..471c1be 100644
--- a/src/EthernaVideoImporter.Core/Models/VideoMetadataBase.cs
+++ b/src/EthernaVideoImporter.Core/Models/VideoMetadataBase.cs
@@ -22,10 +22,12 @@ public abstract class VideoMetadataBase
         protected VideoMetadataBase(
             string description,
             TimeSpan duration,
+            string originVideoQualityLabel,
             string title)
         {
             Description = description;
             Duration = duration;
+            OriginVideoQualityLabel = originVideoQualityLabel;
             Title = title;
         }
 
@@ -33,6 +35,7 @@ protected VideoMetadataBase(
         public abstract string Id { get; }
         public string Description { get; }
         public TimeSpan Duration { get; }
+        public string OriginVideoQualityLabel { get; }
         public string Title { get; }
     }
 }
diff --git a/src/EthernaVideoImporter.Core/Models/YouTubeVideoMetadataBase.cs b/src/EthernaVideoImporter.Core/Models/YouTubeVideoMetadataBase.cs
index 1e7f3db..ce4a36c 100644
--- a/src/EthernaVideoImporter.Core/Models/YouTubeVideoMetadataBase.cs
+++ b/src/EthernaVideoImporter.Core/Models/YouTubeVideoMetadataBase.cs
@@ -11,10 +11,11 @@ public abstract class YouTubeVideoMetadataBase : VideoMetadataBase
         protected YouTubeVideoMetadataBase(
             string description,
             TimeSpan duration,
+            string originVideoQualityLabel,
             Thumbnail? thumbnail,
             string title,
             string youtubeUrl)
-            : base(description, duration, title)
+            : base(description, duration, originVideoQualityLabel, title)
         {
             Thumbnail = thumbnail;
             YoutubeUrl = youtubeUrl;
diff --git a/src/EthernaVideoImporter.Core/Services/VideoUploaderService.cs b/src/EthernaVideoImporter.Core/Services/VideoUploaderService.cs
index e6da695..63a9b66 100644
--- a/src/EthernaVideoImporter.Core/Services/VideoUploaderService.cs
+++ b/src/EthernaVideoImporter.Core/Services/VideoUploaderService.cs
@@ -75,14 +75,12 @@ public async Task UploadVideoAsync(
         {
             if (video is null)
                 throw new ArgumentNullException(nameof(video));
-            if (!video.EncodedFiles.Any())
-                throw new ArgumentException("Must exists at least an encoded file", nameof(video));
 
             // Create new batch.
-            Console.WriteLine("Create batch...");
+            Console.WriteLine("Creating batch...");
 
-            // Size of all video to upload.
-            var totalSize = video.EncodedFiles.Sum(v => v.ByteSize);
+            //calculate size of all contents to upload.
+            var totalSize = video.TotalByteSize;
 
             // Calculate batch deep.
             var batchDeep = 17;
diff --git a/src/EthernaVideoImporter.Core/Utilities/YoutubeDownloader.cs b/src/EthernaVideoImporter.Core/Utilities/YoutubeDownloader.cs
index 316adc9..4c34953 100644
--- a/src/EthernaVideoImporter.Core/Utilities/YoutubeDownloader.cs
+++ b/src/EthernaVideoImporter.Core/Utilities/YoutubeDownloader.cs
@@ -39,7 +39,7 @@ public async Task<Video> GetVideoAsync(
                 throw new ArgumentNullException(nameof(videoMetadata));
 
             // Get manifest data.
-            var youtubeStreamsManifest = await youtubeClient.Videos.Streams.GetManifestAsync(videoMetadata.YoutubeUrl).ConfigureAwait(false);
+            var youtubeStreamsManifest = await youtubeClient.Videos.Streams.GetManifestAsync(videoMetadata.Id).ConfigureAwait(false);
 
             var videoOnlyStreamsInfo = youtubeStreamsManifest.GetVideoOnlyStreams()
                 .Where(stream => stream.Container == Container.Mp4)
diff --git a/src/EthernaVideoImporter.Devcon/Models/MdFileVideoMetadata.cs b/src/EthernaVideoImporter.Devcon/Models/MdFileVideoMetadata.cs
index 5f78a09..ca44fed 100644
--- a/src/EthernaVideoImporter.Devcon/Models/MdFileVideoMetadata.cs
+++ b/src/EthernaVideoImporter.Devcon/Models/MdFileVideoMetadata.cs
@@ -10,13 +10,14 @@ public class MdFileVideoMetadata : YouTubeVideoMetadataBase
         public MdFileVideoMetadata(
             string description,
             TimeSpan duration,
+            string originVideoQualityLabel,
             Thumbnail? thumbnail,
             string title,
             string mdFileRelativePath,
             string youtubeUrl,
             string? ethernaIndexUrl,
             string? ethernaPermalinkUrl)
-            : base(description, duration, thumbnail, title, youtubeUrl)
+            : base(description, duration, originVideoQualityLabel, thumbnail, title, youtubeUrl)
         {
             EthernaIndexUrl = ethernaIndexUrl;
             EthernaPermalinkUrl = ethernaPermalinkUrl;
diff --git a/src/EthernaVideoImporter.Devcon/Services/MdVideoProvider.cs b/src/EthernaVideoImporter.Devcon/Services/MdVideoProvider.cs
index b3d7639..2ce471e 100644
--- a/src/EthernaVideoImporter.Devcon/Services/MdVideoProvider.cs
+++ b/src/EthernaVideoImporter.Devcon/Services/MdVideoProvider.cs
@@ -25,6 +25,7 @@
 using System.Text.Json;
 using System.Threading.Tasks;
 using YoutubeExplode;
+using YoutubeExplode.Videos.Streams;
 
 namespace Etherna.VideoImporter.Devcon.Services
 {
@@ -66,7 +67,7 @@ public async Task<IEnumerable<VideoMetadataBase>> GetVideosMetadataAsync()
 
             Console.WriteLine($"Total files: {mdFilesPaths.Length}");
 
-            var videosMetadata = new List<(ArchiveMdFileDto mdDto, YoutubeExplode.Videos.Video ytVideo, string mdRelativePath)>();
+            var videosMetadata = new List<(ArchiveMdFileDto mdDto, YoutubeExplode.Videos.Video ytVideo, VideoOnlyStreamInfo ytBestStreamInfo, string mdRelativePath)>();
             foreach (var mdFilePath in mdFilesPaths)
             {
                 // Get from md file.
@@ -118,14 +119,19 @@ public async Task<IEnumerable<VideoMetadataBase>> GetVideosMetadataAsync()
 
                 // Get from youtube.
                 var youtubeVideo = await youtubeClient.Videos.GetAsync(videoDataInfoDto.YoutubeUrl).ConfigureAwait(false);
+                var youtubeBestStreamInfo = (await youtubeClient.Videos.Streams.GetManifestAsync(youtubeVideo.Id).ConfigureAwait(false))
+                    .GetVideoOnlyStreams()
+                    .OrderByDescending(s => s.VideoResolution.Area)
+                    .First();
 
-                videosMetadata.Add((videoDataInfoDto, youtubeVideo, Path.GetRelativePath(mdFilePath, mdFolderRootPath)));
+                videosMetadata.Add((videoDataInfoDto, youtubeVideo, youtubeBestStreamInfo, Path.GetRelativePath(mdFilePath, mdFolderRootPath)));
             }
 
             return videosMetadata.Select(
                 p => new MdFileVideoMetadata(
                     p.mdDto.Description,
                     p.ytVideo.Duration ?? throw new InvalidOperationException("Live streams are not supported"),
+                    p.ytBestStreamInfo.VideoQuality.Label,
                     p.ytVideo.Thumbnails.OrderByDescending(t => t.Resolution.Area).FirstOrDefault(),
                     p.mdDto.Title,
                     p.mdRelativePath,
diff --git a/src/EthernaVideoImporter/Models/YouTubeVideoMetadata.cs b/src/EthernaVideoImporter/Models/YouTubeVideoMetadata.cs
index 0b0a36a..6ea18c9 100644
--- a/src/EthernaVideoImporter/Models/YouTubeVideoMetadata.cs
+++ b/src/EthernaVideoImporter/Models/YouTubeVideoMetadata.cs
@@ -10,10 +10,11 @@ internal sealed class YouTubeVideoMetadata : YouTubeVideoMetadataBase
         internal YouTubeVideoMetadata(
             string description,
             TimeSpan duration,
+            string originVideoQualityLabel,
             Thumbnail? thumbnail,
             string title,
             string youtubeUrl)
-            : base(description, duration, thumbnail, title, youtubeUrl)
+            : base(description, duration, originVideoQualityLabel, thumbnail, title, youtubeUrl)
         { }
 
         // Properties.
diff --git a/src/EthernaVideoImporter/Services/YouTubeChannelVideoProvider.cs b/src/EthernaVideoImporter/Services/YouTubeChannelVideoProvider.cs
index cc46700..a6d8c4c 100644
--- a/src/EthernaVideoImporter/Services/YouTubeChannelVideoProvider.cs
+++ b/src/EthernaVideoImporter/Services/YouTubeChannelVideoProvider.cs
@@ -62,9 +62,15 @@ public async Task<IEnumerable<VideoMetadataBase>> GetVideosMetadataAsync()
             foreach (var video in youtubeVideos)
             {
                 var metadata = await youtubeClient.Videos.GetAsync(video.Url).ConfigureAwait(false);
+                var bestStreamInfo = (await youtubeClient.Videos.Streams.GetManifestAsync(metadata.Id).ConfigureAwait(false))
+                    .GetVideoOnlyStreams()
+                    .OrderByDescending(s => s.VideoResolution.Area)
+                    .First();
+
                 videosMetadata.Add(new YouTubeVideoMetadata(
                     metadata.Description,
                     metadata.Duration ?? throw new InvalidOperationException("Live streams are not supported"),
+                    bestStreamInfo.VideoQuality.Label,
                     metadata.Thumbnails.OrderByDescending(t => t.Resolution.Area).FirstOrDefault(),
                     metadata.Title,
                     metadata.Url));

From 9d1736f2e08ca91df3998d24f9837f153b06e44d Mon Sep 17 00:00:00 2001
From: Mirko Da Corte <mirko@etherna.io>
Date: Mon, 27 Feb 2023 01:14:50 +0100
Subject: [PATCH 2/2] review upload service

---
 src/EthernaVideoImporter.Core/CommonConsts.cs |  25 +-
 src/EthernaVideoImporter.Core/Models/Video.cs |   5 +-
 .../SSO/SignServices.cs                       |   4 +-
 .../Services/VideoUploaderService.cs          | 346 ++++++------------
 .../Utilities/YoutubeDownloader.cs            |  18 +-
 src/EthernaVideoImporter.Devcon/Program.cs    |  19 +-
 .../Services/DevconLinkReporterService.cs     |   4 +-
 src/EthernaVideoImporter/Program.cs           |  19 +-
 8 files changed, 152 insertions(+), 288 deletions(-)

diff --git a/src/EthernaVideoImporter.Core/CommonConsts.cs b/src/EthernaVideoImporter.Core/CommonConsts.cs
index 9b92493..e01ed8a 100644
--- a/src/EthernaVideoImporter.Core/CommonConsts.cs
+++ b/src/EthernaVideoImporter.Core/CommonConsts.cs
@@ -21,14 +21,18 @@ namespace Etherna.VideoImporter.Core
 {
     public sealed class CommonConsts
     {
-        public const int BEENODE_GATEWAYPORT = 443;
-        public const GatewayApiVersion BEENODE_GATEWAYVERSION = GatewayApiVersion.v4_0_0;
-        public const DebugApiVersion BEENODE_DEBUGVERSION = DebugApiVersion.v4_0_0;
-        public const int DOWNLOAD_MAX_RETRY = 3;
-        public static readonly TimeSpan DOWNLOAD_RETRY_TIMESPAN = TimeSpan.FromMilliseconds(3500);
-        public const string ETHERNA_CREDIT = "https://credit.etherna.io/";
-        public const string ETHERNA_INDEX = "https://index.etherna.io/";
-        public const string ETHERNA_GATEWAY = "https://gateway.etherna.io/";
+        public const int BeeNodeGatewayPort = 443;
+        public const GatewayApiVersion BeeNodeGatewayVersion = GatewayApiVersion.v4_0_0;
+        public const DebugApiVersion BeeNodeDebugVersion = DebugApiVersion.v4_0_0;
+        public const int DownloadMaxRetry = 3;
+        public static readonly TimeSpan DownloadTimespanRetry = TimeSpan.FromMilliseconds(3500);
+        public const string EthernaCreditUrl = "https://credit.etherna.io/";
+        public const string EthernaIndexUrl = "https://index.etherna.io/";
+        public const string EthernaIndexContentUrlPrefix = "https://etherna.io/embed/";
+        public const string EthernaGatewayUrl = "https://gateway.etherna.io/";
+        public const string EthernaPermalinkContentUrlPrefix = "https://etherna.io/embed/";
+        public const string EthernaSsoClientId = "ethernaVideoImporterId";
+        public const string EthernaSsoUrl = "https://sso.etherna.io/";
         public static string FFMpegBinaryName
         {
             get
@@ -43,9 +47,6 @@ public static string FFMpegBinaryName
                 throw new InvalidOperationException("OS not supported");
             }
         }
-        public const string SSO_AUTHORITY = "https://sso.etherna.io/";
-        public const string SSO_CLIENT_ID = "ethernaVideoImporterId";
-        public const string PREFIX_ETHERNA_INDEX = "https://etherna.io/embed/";
-        public const string PREFIX_ETHERNA_PERMALINK = "https://etherna.io/embed/";
+        public static readonly TimeSpan GnosisBlockTime = TimeSpan.FromSeconds(5);
     }
 }
diff --git a/src/EthernaVideoImporter.Core/Models/Video.cs b/src/EthernaVideoImporter.Core/Models/Video.cs
index 3653a16..26a55b3 100644
--- a/src/EthernaVideoImporter.Core/Models/Video.cs
+++ b/src/EthernaVideoImporter.Core/Models/Video.cs
@@ -28,7 +28,10 @@ public Video(
         public string? EthernaPermalinkHash { get; set; }
         public VideoMetadataBase Metadata { get; }
         public ThumbnailFile? ThumbnailFile { get; }
-        public long TotalByteSize => EncodedFiles.Sum(f => f.ByteSize) +
+
+        // Methods.
+        public long GetTotalByteSize() =>
+            EncodedFiles.Sum(f => f.ByteSize) +
             ThumbnailFile?.ByteSize ?? 0 +
             JsonSerializer.Serialize(new ManifestDto(this, "0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000")).Length;
     }
diff --git a/src/EthernaVideoImporter.Core/SSO/SignServices.cs b/src/EthernaVideoImporter.Core/SSO/SignServices.cs
index 5b4b182..c64712c 100644
--- a/src/EthernaVideoImporter.Core/SSO/SignServices.cs
+++ b/src/EthernaVideoImporter.Core/SSO/SignServices.cs
@@ -29,8 +29,8 @@ public static async Task<LoginResult> SigInSSO()
 
             var options = new OidcClientOptions
             {
-                Authority = CommonConsts.SSO_AUTHORITY,
-                ClientId = CommonConsts.SSO_CLIENT_ID,
+                Authority = CommonConsts.EthernaSsoUrl,
+                ClientId = CommonConsts.EthernaSsoClientId,
                 RedirectUri = redirectUri,
                 Scope = "openid profile offline_access ether_accounts userApi.gateway userApi.index",
                 FilterClaims = false,
diff --git a/src/EthernaVideoImporter.Core/Services/VideoUploaderService.cs b/src/EthernaVideoImporter.Core/Services/VideoUploaderService.cs
index 63a9b66..99e33e5 100644
--- a/src/EthernaVideoImporter.Core/Services/VideoUploaderService.cs
+++ b/src/EthernaVideoImporter.Core/Services/VideoUploaderService.cs
@@ -18,12 +18,10 @@
 using Etherna.ServicesClient.Clients.Index;
 using Etherna.VideoImporter.Core.Dtos;
 using Etherna.VideoImporter.Core.Models;
-using SkiaSharp;
 using System;
 using System.Collections.Generic;
 using System.IO;
-using System.Linq;
-using System.Net.Http;
+using System.Text;
 using System.Text.Json;
 using System.Threading.Tasks;
 
@@ -32,19 +30,15 @@ namespace Etherna.VideoImporter.Core.Services
     public sealed class VideoUploaderService : IVideoUploaderService
     {
         // Const.
-        private readonly TimeSpan BATCH_CHECK_TIME = new(0, 0, 0, 10);
-        private readonly TimeSpan BATCH_TIMEOUT_TIME = new(0, 0, 7, 0);
-        private const int BLOCK_TIME = 5;
-        private const int MAX_RETRY = 3;
-        private const int WAITING_PROPAGATION_BATCH_SECONDS = 5000; // ms.
-        private const int WAITING_PROPAGATION_BATCH_RETRY = 50; // retry.
+        private readonly TimeSpan BatchCheckTimeSpan = new(0, 0, 0, 5);
+        private readonly TimeSpan BatchCreationTimeout = new(0, 0, 10, 0);
+        private readonly TimeSpan BatchUsableTimeout = new(0, 0, 10, 0);
 
         // Fields.
         private readonly BeeNodeClient beeNodeClient;
         private readonly IUserGatewayClient ethernaGatewayClient;
         private readonly IUserIndexClient ethernaIndexClient;
-        private readonly HttpClient httpClient;
-        private readonly int ttlPostageStamp;
+        private readonly TimeSpan ttlPostageStamp;
         private readonly string userEthAddr;
 
         // Constructor.
@@ -53,8 +47,7 @@ public VideoUploaderService(
             IUserGatewayClient ethernaGatewayClient,
             IUserIndexClient ethernaIndexClient,
             string userEthAddr,
-            HttpClient httpClient,
-            int ttlPostageStamp)
+            TimeSpan ttlPostageStamp)
         {
             if (beeNodeClient is null)
                 throw new ArgumentNullException(nameof(beeNodeClient));
@@ -63,7 +56,6 @@ public VideoUploaderService(
             this.ethernaGatewayClient = ethernaGatewayClient;
             this.ethernaIndexClient = ethernaIndexClient;
             this.userEthAddr = userEthAddr;
-            this.httpClient = httpClient;
             this.ttlPostageStamp = ttlPostageStamp;
         }
 
@@ -79,116 +71,40 @@ public async Task UploadVideoAsync(
             // Create new batch.
             Console.WriteLine("Creating batch...");
 
-            //calculate size of all contents to upload.
-            var totalSize = video.TotalByteSize;
-
-            // Calculate batch deep.
+            //calculate batch deep
+            var totalSize = video.GetTotalByteSize();
             var batchDeep = 17;
-            while (Math.Pow(2, batchDeep) * 4 * 1000 < totalSize)
-            {
+            while (Math.Pow(2, batchDeep) * 4096 < totalSize * 1.2) //keep 20% of tollerance
                 batchDeep++;
-                if (batchDeep > 64)
-                    throw new InvalidOperationException("Batch deep exceeds the maximum");
-            }
 
+            //calculate amount
             var chainState = await ethernaGatewayClient.SystemClient.ChainstateAsync().ConfigureAwait(false);
-            var amount = (long)new TimeSpan(ttlPostageStamp * 24, 0, 0).TotalSeconds * chainState.CurrentPrice / BLOCK_TIME;
-            var batchReferenceId = await ethernaGatewayClient.UsersClient.BatchesPostAsync(batchDeep, amount).ConfigureAwait(false);
-
-            // Check and wait until created batchId is avaiable.
-            Console.WriteLine("Waiting for batch ready...");
-
-            double timeWaited = 0;
-            string batchId;
-            do
-            {
-                // Timeout throw exception.
-                if (timeWaited >= BATCH_TIMEOUT_TIME.TotalSeconds)
-                {
-                    var ex = new InvalidOperationException("Batch not avaiable");
-                    ex.Data.Add("BatchReferenceId", batchReferenceId);
-                    throw ex;
-                }
-
-                // Waiting for batchId avaiable.
-                await Task.Delay((int)BATCH_CHECK_TIME.TotalMilliseconds).ConfigureAwait(false);
-                //batchId = await ethernaClientService.GetBatchIdFromBatchReferenceAsync(batchReferenceId).ConfigureAwait(false);
-
-                var httpResponse = await httpClient.GetAsync(new Uri($"https://gateway.etherna.io/api/v0.3/System/postageBatchRef/{batchReferenceId}")).ConfigureAwait(false);
-
-                batchId = httpResponse.StatusCode != System.Net.HttpStatusCode.OK ? "" :
-                    await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false);
-
-                timeWaited += BATCH_CHECK_TIME.TotalSeconds;
-            } while (string.IsNullOrWhiteSpace(batchId));
-
-            // Check and wait until created batch is usable.
-            timeWaited = 0;
-            bool batchUsable = false;
-            do
-            {
-                // Timeout throw exception.
-                if (timeWaited >= BATCH_TIMEOUT_TIME.TotalSeconds)
-                {
-                    var ex = new InvalidOperationException("Batch not usable");
-                    ex.Data.Add("BatchId", batchId);
-                    throw ex;
-                }
+            var amount = (long)(ttlPostageStamp.TotalSeconds * chainState.CurrentPrice / CommonConsts.GnosisBlockTime.TotalSeconds);
 
-                // Waiting for batch ready.
-                await Task.Delay((int)BATCH_CHECK_TIME.TotalMilliseconds).ConfigureAwait(false);
+            //create batch
+            var batchId = await CreatePostageBatchAsync(batchDeep, amount).ConfigureAwait(false);
 
-                //waiting propagation time on bee
-                for (int i = 0; i <= WAITING_PROPAGATION_BATCH_RETRY; i++)
-                {
-                    if (i == WAITING_PROPAGATION_BATCH_RETRY)
-                        throw new InvalidOperationException($"Some error during get batch status");
-
-                    try
-                    {
-                        batchUsable = (await ethernaGatewayClient.UsersClient.BatchesGetAsync(batchId).ConfigureAwait(false)).Usable;
-                        break;
-                    }
-                    catch { await Task.Delay(WAITING_PROPAGATION_BATCH_SECONDS).ConfigureAwait(false); }
-                }
-
-                timeWaited += BATCH_CHECK_TIME.TotalSeconds;
-            } while (!batchUsable);
-
-            // Upload video file.
+            // Upload video files.
             foreach (var encodedFile in video.EncodedFiles)
             {
-                // Upload video.
                 Console.WriteLine(encodedFile switch
                 {
                     AudioFile _ => "Uploading audio track in progress...",
                     VideoFile evf => $"Uploading video track {evf.VideoQualityLabel} in progress...",
                     _ => throw new InvalidOperationException()
                 });
-                var k = 0;
-                while (k <= MAX_RETRY)
-                {
-                    if (k == MAX_RETRY)
-                        throw new InvalidOperationException("Some error during upload of video");
-
-                    try
-                    {
-                        k++;
-                        var fileParameterInput = new FileParameterInput(
-                            File.OpenRead(encodedFile.DownloadedFilePath!),
-                            Path.GetFileName(encodedFile.DownloadedFilePath!),
-                            MimeTypes.GetMimeType(Path.GetFileName(encodedFile.DownloadedFilePath!)));
-
-                        encodedFile.UploadedHashReference = await beeNodeClient.GatewayClient!.UploadFileAsync(
-                            batchId,
-                            files: new List<FileParameterInput> { fileParameterInput },
-                            swarmPin: pinVideo).ConfigureAwait(false);
-                        break;
-                    }
-                    catch { await Task.Delay(3500).ConfigureAwait(false); }
-                }
 
-                if (offerVideo && encodedFile.UploadedHashReference is not null)
+                var fileParameterInput = new FileParameterInput(
+                    File.OpenRead(encodedFile.DownloadedFilePath),
+                    Path.GetFileName(encodedFile.DownloadedFilePath),
+                    MimeTypes.GetMimeType(Path.GetFileName(encodedFile.DownloadedFilePath)));
+
+                encodedFile.UploadedHashReference = await beeNodeClient.GatewayClient!.UploadFileAsync(
+                    batchId,
+                    files: new List<FileParameterInput> { fileParameterInput },
+                    swarmPin: pinVideo).ConfigureAwait(false);
+
+                if (offerVideo)
                     await ethernaGatewayClient.ResourcesClient.OffersPostAsync(encodedFile.UploadedHashReference).ConfigureAwait(false);
             }
 
@@ -197,120 +113,37 @@ public async Task UploadVideoAsync(
             {
                 Console.WriteLine("Uploading thumbnail in progress...");
 
-                var j = 0;
-                while (j <= MAX_RETRY)
-                {
-                    if (j == MAX_RETRY)
-                        throw new InvalidOperationException("Some error during upload of thumbnail");
-
-                    try
-                    {
-                        j++;
-                        var fileThumbnailParameterInput = new FileParameterInput(
-                            File.OpenRead(video.ThumbnailFile.DownloadedFilePath),
-                            Path.GetFileName(video.ThumbnailFile.DownloadedFilePath),
-                            MimeTypes.GetMimeType(Path.GetFileName(video.ThumbnailFile.DownloadedFilePath)));
-
-                        var thumbnailReference = await beeNodeClient.GatewayClient!.UploadFileAsync(
-                            batchId,
-                            files: new List<FileParameterInput> { fileThumbnailParameterInput },
-                            swarmPin: pinVideo).ConfigureAwait(false);
-
-                        video.ThumbnailFile.UploadedHashReference = thumbnailReference;
-                        break;
-                    }
-                    catch { await Task.Delay(3500).ConfigureAwait(false); }
-                }
-
-                if (offerVideo && video.ThumbnailFile.UploadedHashReference is not null)
-                    await ethernaGatewayClient.ResourcesClient.OffersPostAsync(video.ThumbnailFile.UploadedHashReference).ConfigureAwait(false);
-            }
+                var fileThumbnailParameterInput = new FileParameterInput(
+                    File.OpenRead(video.ThumbnailFile.DownloadedFilePath),
+                    Path.GetFileName(video.ThumbnailFile.DownloadedFilePath),
+                    MimeTypes.GetMimeType(Path.GetFileName(video.ThumbnailFile.DownloadedFilePath)));
 
-            // Upload metadata.
-            if (string.IsNullOrWhiteSpace(video.Metadata.Title))
-                throw new InvalidOperationException("Title not defined");
-            if (string.IsNullOrWhiteSpace(video.Metadata.Description))
-                throw new InvalidOperationException("Description not defined");
+                var thumbnailReference = await beeNodeClient.GatewayClient!.UploadFileAsync(
+                    batchId,
+                    files: new List<FileParameterInput> { fileThumbnailParameterInput },
+                    swarmPin: pinVideo).ConfigureAwait(false);
 
-            // Get all Thumbnails.
-            Dictionary<string, string> thumbnailReferences = new();
-            var thumbnailBestResolution = 0;
-            string? downloadedThumbnailPathBestResolution = null;
-
-            if (!string.IsNullOrWhiteSpace(video.ThumbnailFile?.DownloadedFilePath))
-            {
+                video.ThumbnailFile.UploadedHashReference = thumbnailReference;
 
-                using var input = File.OpenRead(video.ThumbnailFile.DownloadedFilePath);
-                using var inputStream = new SKManagedStream(input);
-                using var sourceImage = SKBitmap.Decode(inputStream);
-
-                var keyResolution = $"{sourceImage.Width}w";
-                if (!thumbnailReferences.ContainsKey(keyResolution))
-                {
-                    thumbnailReferences.Add(keyResolution, video.ThumbnailFile.UploadedHashReference!);
-                    if (sourceImage.Width > thumbnailBestResolution)
-                    {
-                        thumbnailBestResolution = sourceImage.Width;
-                        downloadedThumbnailPathBestResolution = video.ThumbnailFile.DownloadedFilePath;
-                    }
-                }
-            }
-
-            ManifestThumbnailDto? swarmImageRaw = null;
-            if (!string.IsNullOrWhiteSpace(downloadedThumbnailPathBestResolution))
-            {
-                using var input = File.OpenRead(video.ThumbnailFile!.DownloadedFilePath!);
-                using var inputStream = new SKManagedStream(input);
-                using var sourceImage = SKBitmap.Decode(inputStream);
-                var hash = Blurhash.SkiaSharp.Blurhasher.Encode(sourceImage, 4, 4);
-                swarmImageRaw = new ManifestThumbnailDto(
-                    (float)sourceImage.Width / (float)sourceImage.Height,
-                    hash,
-                    thumbnailReferences);
+                if (offerVideo)
+                    await ethernaGatewayClient.ResourcesClient.OffersPostAsync(video.ThumbnailFile.UploadedHashReference).ConfigureAwait(false);
             }
 
             // Manifest.
-            var metadataVideo = new ManifestDto(
-                video.Metadata.Title,
-                video.Metadata.Description,
-                $"{video.EncodedFiles.OfType<VideoFile>().First().VideoQualityLabel}",
-                userEthAddr,
-                (long)video.Metadata.Duration.TotalSeconds,
-                swarmImageRaw!,
-                video.EncodedFiles.OfType<VideoFile>().Select(vf => new ManifestVideoSourceDto(vf)).ToList(),
-                DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(),
-                null,
-                batchId,
-                JsonSerializer.Serialize(ManifestPersonalDataDto.BuildNew(video.Metadata.Id)));
-
-            var hashMetadataReference = await UploadVideoManifestAsync(metadataVideo, pinVideo).ConfigureAwait(false);
-            video.EthernaPermalinkHash = hashMetadataReference;
+            var metadataVideo = new ManifestDto(video, batchId, userEthAddr);
+            video.EthernaPermalinkHash = await UploadVideoManifestAsync(metadataVideo, pinVideo).ConfigureAwait(false);
 
             if (offerVideo)
-                await ethernaGatewayClient.ResourcesClient.OffersPostAsync(hashMetadataReference).ConfigureAwait(false);
+                await ethernaGatewayClient.ResourcesClient.OffersPostAsync(video.EthernaPermalinkHash).ConfigureAwait(false);
 
-            // Sync Index.
-            Console.WriteLine("Video indexing in progress...");
-            if (!string.IsNullOrEmpty(video.EthernaIndexId))
-            {
-                // Update manifest index.
-                Console.WriteLine($"Update Index: {video!.EthernaIndexId}\t{hashMetadataReference}");
-
-                await ethernaIndexClient.VideosClient.VideosPutAsync(video.EthernaIndexId!, hashMetadataReference).ConfigureAwait(false);
-            }
-            else
-            {
-                // Create new manifest index.
-                Console.WriteLine($"Create Index: {hashMetadataReference}");
+            // List on index.
+            Console.WriteLine($"List on Etherna index: {video.EthernaPermalinkHash}");
 
-                var videoCreateInput = new VideoCreateInput
+            video.EthernaIndexId = await ethernaIndexClient.VideosClient.VideosPostAsync(
+                new VideoCreateInput
                 {
-                    ManifestHash = hashMetadataReference,
-                };
-                var indexVideoId = await ethernaIndexClient.VideosClient.VideosPostAsync(videoCreateInput).ConfigureAwait(false);
-
-                video.EthernaIndexId = indexVideoId;
-            }
+                    ManifestHash = video.EthernaPermalinkHash,
+                }).ConfigureAwait(false);
         }
 
         public async Task<string> UploadVideoManifestAsync(
@@ -320,39 +153,68 @@ public async Task<string> UploadVideoManifestAsync(
             if (videoManifest is null)
                 throw new ArgumentNullException(nameof(videoManifest));
 
-            var tmpMetadata = Path.GetTempFileName();
-            var hashMetadataReference = "";
-            try
+            var serializedManifest = JsonSerializer.Serialize(videoManifest);
+            using var manifestStream = new MemoryStream(Encoding.UTF8.GetBytes(serializedManifest));
+
+            // Upload manifest.
+            return await beeNodeClient.GatewayClient!.UploadFileAsync(
+                videoManifest.BatchId,
+                files: new[] {
+                    new FileParameterInput(
+                        manifestStream,
+                        "metadata.json",
+                        "application/json")
+                },
+                swarmPin: pinManifest).ConfigureAwait(false);
+        }
+
+        // Helpers.
+        private async Task<string> CreatePostageBatchAsync(int batchDeep, long amount)
+        {
+            var batchReferenceId = await ethernaGatewayClient.UsersClient.BatchesPostAsync(batchDeep, amount).ConfigureAwait(false);
+
+            // Wait until created batch is avaiable.
+            Console.WriteLine("Waiting for batch ready...");
+
+            var batchStartWait = DateTime.UtcNow;
+            string? batchId;
+            do
             {
-                await File.WriteAllTextAsync(tmpMetadata, JsonSerializer.Serialize(videoManifest)).ConfigureAwait(false);
-
-                var i = 0;
-                while (i < MAX_RETRY &&
-                    string.IsNullOrWhiteSpace(hashMetadataReference))
-                    try
-                    {
-                        i++;
-                        // Upload file.
-                        var fileParameterInput = new FileParameterInput(
-                            File.OpenRead(tmpMetadata),
-                            Path.GetFileName("metadata.json"),
-                            MimeTypes.GetMimeType("application/json"));
-                        hashMetadataReference = await beeNodeClient.GatewayClient!.UploadFileAsync(
-                            videoManifest.BatchId,
-                            files: new List<FileParameterInput> { fileParameterInput },
-                            swarmPin: pinManifest).ConfigureAwait(false);
-                    }
-                    catch { await Task.Delay(3500).ConfigureAwait(false); }
-                if (string.IsNullOrWhiteSpace(hashMetadataReference))
-                    throw new InvalidOperationException("Some error during upload of metadata");
-            }
-            finally
+                //timeout throw exception
+                if (DateTime.UtcNow - batchStartWait >= BatchCreationTimeout)
+                {
+                    var ex = new InvalidOperationException("Batch not avaiable after timeout");
+                    ex.Data.Add("BatchReferenceId", batchReferenceId);
+                    throw ex;
+                }
+
+                batchId = await ethernaGatewayClient.SystemClient.PostageBatchRefAsync(batchReferenceId).ConfigureAwait(false);
+
+                //waiting for batchId avaiable
+                await Task.Delay(BatchCheckTimeSpan).ConfigureAwait(false);
+
+            } while (string.IsNullOrWhiteSpace(batchId));
+
+            // Wait until created batch is usable.
+            batchStartWait = DateTime.UtcNow;
+            bool batchIsUsable;
+            do
             {
-                if (File.Exists(tmpMetadata))
-                    File.Delete(tmpMetadata);
-            }
+                //timeout throw exception
+                if (DateTime.UtcNow - batchStartWait >= BatchUsableTimeout)
+                {
+                    var ex = new InvalidOperationException("Batch not usable after timeout");
+                    ex.Data.Add("BatchId", batchId);
+                    throw ex;
+                }
+
+                batchIsUsable = (await ethernaGatewayClient.UsersClient.BatchesGetAsync(batchId).ConfigureAwait(false)).Usable;
+
+                //waiting for batch usable
+                await Task.Delay(BatchCheckTimeSpan).ConfigureAwait(false);
+            } while (!batchIsUsable);
 
-            return hashMetadataReference;
+            return batchId;
         }
     }
 }
diff --git a/src/EthernaVideoImporter.Core/Utilities/YoutubeDownloader.cs b/src/EthernaVideoImporter.Core/Utilities/YoutubeDownloader.cs
index 4c34953..a991b03 100644
--- a/src/EthernaVideoImporter.Core/Utilities/YoutubeDownloader.cs
+++ b/src/EthernaVideoImporter.Core/Utilities/YoutubeDownloader.cs
@@ -84,9 +84,9 @@ private async Task<AudioFile> DownloadAudioTrackAsync(
             var audioFileName = $"{videoTitle.ToSafeFileName()}_onlyaudio.{audioStream.Container}";
             var audioFilePath = Path.Combine(downloadDirectory.FullName, audioFileName);
 
-            for (int i = 0; i <= CommonConsts.DOWNLOAD_MAX_RETRY; i++)
+            for (int i = 0; i <= CommonConsts.DownloadMaxRetry; i++)
             {
-                if (i == CommonConsts.DOWNLOAD_MAX_RETRY)
+                if (i == CommonConsts.DownloadMaxRetry)
                     throw new InvalidOperationException($"Some error during download of audio track");
 
                 try
@@ -100,7 +100,7 @@ await youtubeClient.Videos.Streams.DownloadAsync(
                         })).ConfigureAwait(false);
                     break;
                 }
-                catch { await Task.Delay(CommonConsts.DOWNLOAD_RETRY_TIMESPAN).ConfigureAwait(false); }
+                catch { await Task.Delay(CommonConsts.DownloadTimespanRetry).ConfigureAwait(false); }
             }
 
             return new AudioFile(
@@ -117,9 +117,9 @@ private async Task<ThumbnailFile> DownloadThumbnailAsync(
 
             string thumbnailFilePath = Path.Combine(downloadDirectory.FullName, $"{videoTitle.ToSafeFileName()}_thumb.jpg");
             
-            for (int i = 0; i <= CommonConsts.DOWNLOAD_MAX_RETRY; i++)
+            for (int i = 0; i <= CommonConsts.DownloadMaxRetry; i++)
             {
-                if (i == CommonConsts.DOWNLOAD_MAX_RETRY)
+                if (i == CommonConsts.DownloadMaxRetry)
                     throw new InvalidOperationException($"Some error during download of thumbnail");
 
                 try
@@ -130,7 +130,7 @@ private async Task<ThumbnailFile> DownloadThumbnailAsync(
                     await stream.CopyToAsync(fileStream).ConfigureAwait(false);
                     break;
                 }
-                catch { await Task.Delay(CommonConsts.DOWNLOAD_RETRY_TIMESPAN).ConfigureAwait(false); }
+                catch { await Task.Delay(CommonConsts.DownloadTimespanRetry).ConfigureAwait(false); }
             }
 
             return new ThumbnailFile(
@@ -150,9 +150,9 @@ private async Task<VideoFile> DownloadVideoStreamAsync(
             var videoQualityLabel = videoOnlyStream.VideoQuality.Label;
 
             // Download video.
-            for (int i = 0; i <= CommonConsts.DOWNLOAD_MAX_RETRY; i++)
+            for (int i = 0; i <= CommonConsts.DownloadMaxRetry; i++)
             {
-                if (i == CommonConsts.DOWNLOAD_MAX_RETRY)
+                if (i == CommonConsts.DownloadMaxRetry)
                     throw new InvalidOperationException($"Some error during download of video");
 
                 try
@@ -167,7 +167,7 @@ await youtubeClient.Videos.DownloadAsync(
                         })).ConfigureAwait(false);
                     break;
                 }
-                catch { await Task.Delay(CommonConsts.DOWNLOAD_RETRY_TIMESPAN).ConfigureAwait(false); }
+                catch { await Task.Delay(CommonConsts.DownloadTimespanRetry).ConfigureAwait(false); }
             }
 
             return new VideoFile(
diff --git a/src/EthernaVideoImporter.Devcon/Program.cs b/src/EthernaVideoImporter.Devcon/Program.cs
index 6503ba2..547abc6 100644
--- a/src/EthernaVideoImporter.Devcon/Program.cs
+++ b/src/EthernaVideoImporter.Devcon/Program.cs
@@ -112,25 +112,24 @@ static async Task Main(string[] args)
             // Inizialize services.
             using var httpClient = new HttpClient(authResult.RefreshTokenHandler) { Timeout = TimeSpan.FromHours(2) };
             var ethernaUserClients = new EthernaUserClients(
-                new Uri(CommonConsts.ETHERNA_CREDIT),
-                new Uri(CommonConsts.ETHERNA_GATEWAY),
-                new Uri(CommonConsts.ETHERNA_INDEX),
-                new Uri(CommonConsts.SSO_AUTHORITY),
+                new Uri(CommonConsts.EthernaCreditUrl),
+                new Uri(CommonConsts.EthernaGatewayUrl),
+                new Uri(CommonConsts.EthernaIndexUrl),
+                new Uri(CommonConsts.EthernaSsoUrl),
                 () => httpClient);
             using var beeNodeClient = new BeeNodeClient(
-                CommonConsts.ETHERNA_GATEWAY,
-                CommonConsts.BEENODE_GATEWAYPORT,
+                CommonConsts.EthernaGatewayUrl,
+                CommonConsts.BeeNodeGatewayPort,
                 null,
-                CommonConsts.BEENODE_GATEWAYVERSION,
-                CommonConsts.BEENODE_DEBUGVERSION,
+                CommonConsts.BeeNodeGatewayVersion,
+                CommonConsts.BeeNodeDebugVersion,
                 httpClient);
             var videoUploaderService = new VideoUploaderService(
                 beeNodeClient,
                 ethernaUserClients.GatewayClient,
                 ethernaUserClients.IndexClient,
                 userEthAddr,
-                httpClient,
-                ttlPostageStamp);
+                TimeSpan.FromDays(ttlPostageStamp));
 
             // Call runner.
             var importer = new EthernaVideoImporter(
diff --git a/src/EthernaVideoImporter.Devcon/Services/DevconLinkReporterService.cs b/src/EthernaVideoImporter.Devcon/Services/DevconLinkReporterService.cs
index 84901d4..5e4dbbd 100644
--- a/src/EthernaVideoImporter.Devcon/Services/DevconLinkReporterService.cs
+++ b/src/EthernaVideoImporter.Devcon/Services/DevconLinkReporterService.cs
@@ -34,8 +34,8 @@ public async Task SetEthernaReferencesAsync(
             string ethernaIndexId,
             string ethernaPermalinkHash)
         {
-            var ethernaIndexUrl = CommonConsts.PREFIX_ETHERNA_INDEX + ethernaIndexId;
-            var ethernaPermalinkUrl = CommonConsts.PREFIX_ETHERNA_PERMALINK + ethernaPermalinkHash;
+            var ethernaIndexUrl = CommonConsts.EthernaIndexContentUrlPrefix + ethernaIndexId;
+            var ethernaPermalinkUrl = CommonConsts.EthernaPermalinkContentUrlPrefix + ethernaPermalinkHash;
 
             // Reaad all line.
             var lines = File.ReadLines(sourceVideoId).ToList();
diff --git a/src/EthernaVideoImporter/Program.cs b/src/EthernaVideoImporter/Program.cs
index e4e8c75..c7f76ce 100644
--- a/src/EthernaVideoImporter/Program.cs
+++ b/src/EthernaVideoImporter/Program.cs
@@ -125,25 +125,24 @@ static async Task Main(string[] args)
             // Inizialize services.
             using var httpClient = new HttpClient(authResult.RefreshTokenHandler) { Timeout = TimeSpan.FromHours(2) };
             var ethernaUserClients = new EthernaUserClients(
-                new Uri(CommonConsts.ETHERNA_CREDIT),
-                new Uri(CommonConsts.ETHERNA_GATEWAY),
-                new Uri(CommonConsts.ETHERNA_INDEX),
-                new Uri(CommonConsts.SSO_AUTHORITY),
+                new Uri(CommonConsts.EthernaCreditUrl),
+                new Uri(CommonConsts.EthernaGatewayUrl),
+                new Uri(CommonConsts.EthernaIndexUrl),
+                new Uri(CommonConsts.EthernaSsoUrl),
                 () => httpClient);
             using var beeNodeClient = new BeeNodeClient(
-                CommonConsts.ETHERNA_GATEWAY,
-                CommonConsts.BEENODE_GATEWAYPORT,
+                CommonConsts.EthernaGatewayUrl,
+                CommonConsts.BeeNodeGatewayPort,
                 null,
-                CommonConsts.BEENODE_GATEWAYVERSION,
-                CommonConsts.BEENODE_DEBUGVERSION,
+                CommonConsts.BeeNodeGatewayVersion,
+                CommonConsts.BeeNodeDebugVersion,
                 httpClient);
             var videoUploaderService = new VideoUploaderService(
                 beeNodeClient,
                 ethernaUserClients.GatewayClient,
                 ethernaUserClients.IndexClient,
                 userEthAddr,
-                httpClient,
-                ttlPostageStamp);
+                TimeSpan.FromDays(ttlPostageStamp));
 
             // Call runner.
             var importer = new EthernaVideoImporter(