Unwrap.ai

unwrapai

In the previous , it was described a six-point method to unwrap wine labels. Finding anchor points were performed with Hough transform. It gave fair results for good labels, but for many real cases it was quite unstable, and the efforts to tune it didn’t help much. It became clear at some point, Hough transform itself wasn’t capable of handling the variety of label forms, so the next step was training a neural network. article This article describes how were collecting and labeling a dataset, and trying neural network architectures — it was lots of fun. we A dataset is probably the most important part of neural network training. Potentially, it’s possible to create a synthetic set of pictures, but in that case, it’s not clear how well it corresponds to the real images, that’s why the dataset must consist of labeled photos at least partially. Training a network will require marking images first, and that requires a special tool for tagging. There are lots of tools available for machine learning, but the choice is mostly limited to classification tasks, segmentation, or bounding box. In our case, it was required to specify six points, also we needed to dynamically visualize 3D mesh — so we created our own tool. The first milestone, “Pallas’s cat” (each milestone we called after different cats), goals: * Create a simple system to label images
* Mark a thousand of images
* Try neural network proof of the concept Create a simple system to label imagesMark a thousand of imagesTry neural network proof of the concept Requirements: * Ability to process images online by a distributed team
* Each image had to be a separate task
* Two-step processing (processing and reviewing)
* Direct links to each of the tasks
* Visualization Statistics and permission management was not a part of the initial scope, as we were going to process the first thousand of images ourselves. I chose Django framework to build the labeling system — it has admin out of the box, there is a great Django REST framework to build API, and it’s extensible. Let’s create ImageTask model: orig_image = models.OneToOneField(
        Image, blank= , null= , on_delete=models.CASCADE, related_name= ,
    )

    status = models.IntegerField(choices=get_enum_choices(TaskStatus))

    type = models.IntegerField(
        choices=get_enum_choices(TaskType), default=TaskType.detect_marker.value
    )

    worker = models.ForeignKey(
        User, null= , blank= , on_delete=models.SET_NULL, related_name= )
    reviewer = models.ForeignKey(
        User, null= , blank= , on_delete=models.SET_NULL, related_name= )

    data = JSONField(blank= , default=dict)

    created = models.DateTimeField(auto_now_add= )
    updated = models.DateTimeField(auto_now= ) url = self.orig_image:
            url = self.orig_image.full_url
        task_url = tag = mark_safe(tag) : class ImageTask (models.Model) True True '+' True True 'workers' True True 'reviewers' True True True : def clickable_preview (self) '' if f'/static/jsapp/task/ ' {self.id} f"""
            <a href=" " target="_blank">
                <img src=" " height="100" width="100" object-fit: "scale-down">
            </a>
        """ {task_url} {url} return Then define its admin: list_display = [ , , , , , ]
    list_filter = [ ,
        TrelloCardFilter, , ]
    readonly_fields = [ , ]
    ordering = [ , ]
    list_select_related = [ ] @admin.register(ImageTask) : class ImageTaskAdmin (admin.ModelAdmin) 'id' 'thumb' 'task_status' 'tags_list' 'perform_action' "updated" "status" "worker" "reviewer" 'orig_image' 'processed_image' "-updated" '-id' 'orig_image' And override tasks template: {# templates/admin/labelapp/imagetask/change_list.html #} {% "admin/change_list.html" %} extends {% bootstrap3 %} load {% extrastyle %} block {{ block.super }} < = = = /> link rel "stylesheet" type "text/css" href "/static/css/imagetask_admin_changel\
ist.css" < = = = /> link rel "stylesheet" type "text/css" href "/static/css/toastr.min.css" {% extrastyle %} endblock {% extrahead %} block {{ block.super }} {% %} bootstrap_css < > script csrftoken = var ' {{ csrf_token }} </ > script < = = > script type "text/javascript" src "/static/js/jquery-3.3.1.min.js" </ > script < = = > script type "text/javascript" src "/static/js/toastr.min.js" </ > script < = = > script type "text/javascript" src "/static/js/const.js" </ > script < = = > script type "text/javascript" src "/static/js/imagetask_admin_changelist.js" </ > \ script {% extrahead %} endblock The code is shortened a little for simplicity. Let’s open “Image Task’s” page, and see a backlog: The labeling interface is the most interesting part, of course. The most recent version is depicted below: The labeled image on the left part of the page has six draggable keypoints. Once their position is changed, the mesh is recalculated in real-time. The first version of the interface was written in jQuery + Canvas, and some UI elements in the picture above were missing. It took me about three days to write it (Django and simple Javascript are awesome), and we started labeling the dataset right away. It took around 30 man-hours, spread across two weeks, to process a thousand of items. The moto of processing a dataset — “Move fast, everything is fixable”. The flow must be speed-oriented, with no modal windows — any action is performed through a single click. On the other hand, if the error occurred (that happens), it must be a way to fix it easily. Here is an example — all the uploaded images have status “New”. We add them manually by going through the list and clicking “Move to backlog” button”. If you changed your mind, it can be easily restored by another button “Set as new”: I can’t say it’s rocket science, but all that makes the work highly effective. So, once the dataset is ready, we can do the most interesting part — a neural network! We took U-net, trained it, and it worked! Not ideally, of course, but good enough for proof of the concept. So, continued labeling the dataset further. Next milestone, “Rose panther”, goals: * Create a working dataset
* Choose an optimal neural network architecture
* Run REST API to detect wine label keypoints
* Stitch labels Meantime Kirill (he was responsible for the architecture and stuff) tried to make changes in labeling interface. His face when he saw my jQuery code: So, the first thing he did — refactored the page to use React.js, and added dynamic preview: Later the interface had the other changes — we added hotkeys, classification tags, Trello integration, setting up initial markers by a neural network, but the interface didn’t change much visually. In general, putting six-point markers was not a trivial task. There were a lot of different wine label shapes, and it was required to make the basic rules on how to mark them. For example, which of the cases below is correct? If the dataset is not consistent in similar cases, the neural network will get confused, and the accuracy will suffer. At some point, we had to update the rules and reprocess the existing dataset (it was about 3000 images). I mentioned Trello integration — we used it to start a discussion thread linked to a task if it was not clear how to tag it: All the questions from workers go to the first column. The reviewer picks up a card and drags it to the “Conversations” column. Once the discussion is over, the worker will archive the card, but the link is still available from the original processing task. The benefit of that approach — the integration can be done in half a day, so it’s not required to write own chat, and Trello is free, and it has nice wallpapers :) Two-step processing — firstly by a worker, secondly by a reviewer, is required not even to reduce the number of errors, but to make the process more parallel. One or two reviewers can review tasks pretty quickly, and they know markup rules better than workers. But workers should not worry about the rules too much — if something is wrong, the reviewer will catch the error and explain how to fix it. Another problem with building a dataset — where to collect source images. Even in supermarkets, there are about 2–3 thousand different bottles, and there is an intersection in products between stores. Taking pictures is not too hard — I could take around a thousand in an hour, luckily I was never asked to leave by the staff. One day I realized I shot every single bottle in New Jersey, and it was no point to walk with the camera anymore. Additionally, the dataset we collected consisted of bottles, standing on shelves, which was quite a uniform environment. At some point, we noticed the neural network detected wine labels on this background very well but was totally confused if it was something different. So, we decided to extend the dataset with web scraping. We looked for images with a white background, with text, or something unexpected. For example, if a picture of beer also contained a glass full of foamy amber, the neural network could not focus well enough. So, we trained its stamina with the additional hundred images. I also want to share a lifehack, as it’s important to understand that the dataset work is boring. And if you are Google, and own Re-Captcha, the boredom is distributed across millions of innocent people, but if you mark the dataset yourself, all the monotony is distributed on you personally. I just want to say, all the steps that can be automated have to be automated. In the case of downloading images, we launched an API that took an image URL, downloaded it, unwrapped, and visualized the queue. On the client-side, we used CopyQ application — it’s cross-platform, runs in the background, and executes actions if a hotkey is detected. In my case, I had the following configuration: The first step is to look up images in Google, then, if you like one, copy its URL and hit Win-Z. CopyQ sends the URL to API, adding the image to a processing queue, and once, let’s say, 100 items are accumulated, you can switch back to admin and add to backlog the worst cases: There is no need to add images that are already being recognized well, but the example above (it’s a random image from the internet) shows the top left keypoint in the wrong position — it’s positioned nearby the label, meantime it had to be left side of the bottle. Now we click “Add to dataset”, and the image goes to the backlog. We processed 10k images in 3 months eventually, it doesn’t seem too much, but the dataset was well-balanced. In reality, a big dataset is not necessarily good, as it’s much harder to balance it, i.e. to choose the different examples in equal proportions. If you don’t, it might be easier for the neural network to ignore some of the examples, rather than to generalize the algorithm. Let’s say the dataset contains 1 million images, and all of them are made in good light conditions. And you realize 15% of real photos are made in bad light conditions and the neural network is not able to recognize them. The solution is simple — it’s necessary to add low light samples, but as your dataset is large, you’ll have to add thousands of them, before they affect the accuracy. It’s like a bureaucratic system, that is targeted to handle common cases but ignores the outliners. But 10k items can lead to an overfitting problem, so it’s required to apply augmentations. There are nice libraries like imgaug or albumentations that can modify images in different ways — rotate, reflect, blur, or change color balance. It’s only required to keep the image readable and take into account that even little changes, applied together, may have an unexpected effect — for example, blurring and saturation applied at the same time, can visually shift bottle edges. So, the dataset is ready, it’s well balanced and large enough due to augmentations. There is still a question — what neural network to use? Is it required to invent a new architecture, or there are some universal ones? The truth is — no one knows, but what’s is clear distinctively — it will be necessary to try many different architectures and settings, and any machine learning project is built around this idea. If it takes 3 weeks to try a new architecture, it’s bad news. Ideally, a pipeline must be designed in a way, that only a few changes in configuration, and, maybe, a couple of adapter classes to change input/output format, will connect a new architecture. Our proof of the concept was written without those requirements, of course, but once it worked, our next step was to build such a pipeline. Initially, it was built using Keras, but Sergey (our artificial intelligence charmer) switched to Pytorch finally. We also made neural network nightly builds available via REST API, which was used by labeling interface — for automatic image labeling. Django REST Framework has a very convenient feature — token authentication . The token can be created with the admin: https://www.django-rest-framework.org/api-guide/authentication/#tokenauthentication Then, to get access to the endpoint, it’s just necessary to pass the token in the request header. I’d rather finish the article halfway through, soon there will be the other ones: * Stitching several images into a long one
* How to register a company in Delaware
* A little about B2B and SaaS promotion

Unwrapping Wine Labels - How We Trained A Neural Network To Do It

Async/await in C# is a framework used for writing asynchronous C# code that is both readable and maintainable. These tips will help you to integrate async/await programming more effectively in the # projects: 1. ValueTask for Lightweight Operations Use ValueTask instead of Task for asynchronous methods that often complete synchronously, reducing the allocation overhead. public async ValueTask<int> GetResultAsync()
    {
        if (cachedResult != null)
            return cachedResult;
        int result = await ComputeResultAsync();
        cachedResult = result;
        return result;
    } 2. ConfigureAwait for Library Code Use ConfigureAwait(false) in the library code to avoid deadlocks by not capturing the synchronization context. public async Task SomeLibraryMethodAsync()
    {
        await SomeAsyncOperation().ConfigureAwait(false);
    } 3. Avoiding async void Prefer async Task over async void except for event handlers, as async void can lead to unhandled exceptions and is harder to test. public async Task EventHandlerAsync(object sender, EventArgs e)
    {
        await PerformOperationAsync();
    } 4. Using IAsyncDisposable For asynchronous cleanup, implement IAsyncDisposable and use await to ensure resources are released properly. public async ValueTask DisposeAsync()
    {
        await DisposeAsyncCore();
    }
    
    private async ValueTask DisposeAsyncCore()
    {
        if (resource != null)
        {
            await resource.DisposeAsync();
        }
    } 5. Efficiently Combine Tasks Use Task.WhenAll for running multiple tasks in parallel and waiting for all to complete, which is more efficient than awaiting each task sequentially public async Task ProcessTasksAsync()
    {
        Task task1 = DoTask1Async();
        Task task2 = DoTask2Async();
        await Task.WhenAll(task1, task2);
    } 6. Cancellation Support Support cancellation in asynchronous methods using CancellationToken. public async Task DoOperationAsync(CancellationToken cancellationToken)
    {
        await LongRunningOperationAsync(cancellationToken);
        cancellationToken.ThrowIfCancellationRequested();
    } 7. State Machine Optimization For performance-critical code, consider structuring your async methods to minimize the creation of state machines by separating synchronous and asynchronous paths. public async Task<int> FastPathAsync()
    {
        if (TryGetCachedResult(out int result))
        {
            return result;
        }
        return await ComputeResultAsync();
    } 8. Avoid Blocking Calls Avoid blocking on async code with .Result or .Wait(). Instead, use asynchronous waiting through the stack. public async Task WrapperMethodAsync()
    {
        int result = await GetResultAsync();
    } 9. Eliding Async/Await In simple passthrough scenarios or when returning a task directly, you can elide the async and await keywords for slightly improved performance. public Task<int> GetResultAsync() => ComputeResultAsync(); 10. Custom Task Schedulers For advanced scenarios, like limiting concurrency or capturing synchronization contexts, consider implementing a custom TaskScheduler. public sealed class LimitedConcurrencyLevelTaskScheduler : TaskScheduler
    {
        // Implement the scheduler logic here.
    } 11. Using Asynchronous Streams Leverage asynchronous streams with IAsyncEnumerable<T> for processing sequences of data asynchronously, introduced in C# 8.0. public async IAsyncEnumerable<int> GetNumbersAsync()
    {
        for (int i = 0; i < 10; i++)
        {
            await Task.Delay(100); // Simulate async work
            yield return i;
        }
    } 12. Avoid Async Lambdas in Hot Paths Async lambdas can introduce overhead. In performance-critical paths, consider refactoring them into separate async methods. // Before optimization
    Func<Task> asyncLambda = async () => await DoWorkAsync();
    
    // After optimization
    public async Task DoWorkMethodAsync()
    {
        await DoWorkAsync();
    } 13. Use SemaphoreSlim for Async Coordination SemaphoreSlim can be used for async coordination, such as limiting access to a resource in a thread-safe manner. private readonly SemaphoreSlim semaphore = new SemaphoreSlim(1, 1);
    
    public async Task UseResourceAsync()
    {
        await semaphore.WaitAsync();
        try
        {
            // Access the resource
        }
        finally
        {
            semaphore.Release();
        }
    } 14. Task.Yield for UI Responsiveness Use await Task.Yield() in UI applications to ensure the UI remains responsive by allowing other operations to process. public async Task LoadDataAsync()
    {
        await Task.Yield(); // Return control to the UI thread
        // Load data here
    } 15. Asynchronous Lazy Initialization Use Lazy<Task<T>> for asynchronous lazy initialization, ensuring the initialization logic runs only once and is thread-safe. private readonly Lazy<Task<MyObject>> lazyObject = new Lazy<Task<MyObject>>(async () =>
    {
        return await InitializeAsync();
    });
    
    public async Task<MyObject> GetObjectAsync() => await lazyObject.Value; 16. Combining async and LINQ Be cautious when combining async methods with LINQ queries; consider using asynchronous streams or explicitly unwrapping tasks when necessary. public async Task<IEnumerable<int>> ProcessDataAsync()
    {
        var data = await GetDataAsync(); // Assume this returns Task<List<int>>
        return data.Where(x => x > 10);
    } 17. Error Handling in Async Streams Handle errors gracefully in asynchronous streams by encapsulating the yielding loop in a try-catch block. public async IAsyncEnumerable<int> GetNumbersWithErrorsAsync()
    {
        try
        {
            for (int i = 0; i < 10; i++)
            {
                if (i == 5) throw new InvalidOperationException("Test error");
                yield return i;
            }
        }
        catch (Exception ex)
        {
            // Handle or log the error
        }
    } 18. Use Parallel.ForEachAsync for Asynchronous Parallel Loops Utilize Parallel.ForEachAsync in .NET 6 and later for running asynchronous operations in parallel, providing a more efficient way to handle CPU-bound and I/O-bound operations concurrently. await Parallel.ForEachAsync(data, async (item, cancellationToken) =>
    {
        await ProcessItemAsync(item, cancellationToken);
    }); 22. Avoid Excessive Async/Await in High-Performance Code In performance-critical sections, minimize the use of async/await. Instead, consider using Task.ContinueWith with caution or redesigning the workflow to reduce asynchronous calls. Task<int> task = ComputeAsync();
    task.ContinueWith(t => Process(t.Result)); 23. Async Main Method Utilize the async entry point for console applications introduced in C# 7.1 to simplify initialization code. public static async Task Main(string[] args)
    {
        await StartApplicationAsync();
    } 24. Optimize Async Loops For loops performing asynchronous operations, consider batching or parallelizing tasks to improve throughput. var tasks = new List<Task>();
    for (int i = 0; i < items.Length; i++)
    {
        tasks.Add(ProcessItemAsync(items[i]));
    }
    await Task.WhenAll(tasks); More Cheatsheets Cheat Sheets - .Net C# Programming🚀 Thank you for being a part of the C# community! Before you leave: Follow us: | | | Visit our other platforms: More content at Youtube X LinkedIn Dev.to GitHub C# Programming Also published . here

Async/Await For Basic to Advanced C# Developers: 24 Essential Tips

Imagine we're stepping into a sci-fi movie, but it's real life. That's the vibe at SXSW sessions, where tomorrow's ideas feel like they're unfolding today. In one of the first talks I caught at SXSW this year, , the big boss at MIT Technology Review, laid out a list of ten tech breakthroughs. She's betting these will seriously shake up our daily lives and how we work. Elizabeth Bramson-Boudreau Here's the scoop on what made her list: It's like AI's about to be in everything we touch. AI for Everything: Think sun power on steroids. Super Efficient Solar Panels: This one got everyone buzzing. ( or advertising..) Apple Vision Pro: No gym? No problem, maybe. Weight Loss Medicines: It's about getting cozy with Earth's heat. Advanced Geothermal Systems: But not the snack kind. Chips: Sounds like sci-fi, but it's real. First Gene Editing Therapy: Big word, even bigger deal. Exascale Computers: They're hot, literally. Heat Pumps: After Elon Musk stirred the pot with X, new social networks are popping up trying to take the throne. Twitter Killers: What Are Exascale Computers? These beasts can do a quintillion operations per second. Yes, that's a lot of zeros. Elizabeth thinks these computers will change the game for everyone, not just the science folks. Imagine cracking problems or discovering stuff that seemed out of reach before. She believes we'll see how these computers can be more accessible to regular folks soon. The Brave New Future of the Recent Past from the kicked off a and a chat about how our stories, especially . It's all about the power of storytelling and finding new ways to talk about artificial intelligence that matters to us as people. Brent Reidy New York Public Library session with a throwback to Plato around AI, need a fresh, human-centered twist The next day, I caught a keynote with , aka and These guys are the brains behind which won seven Oscars. They discussed why they make films and how storytelling is core to being human. The Daniels Daniel Scheinert Daniel Kwan. "Everything Everywhere All at Once," Kwan shared his unease about AI in filmmaking, hinting at excitement and worry about what's to come. The Brave New Future of the Recent Past 's dive into Plato's cave allegory at SXSW wasn't just a trip back to Philosophy 101. It turned out to be a sneak peek into a theme I'd bump into repeatedly at the event: the sheer power of storytelling. Especially the kind we need right now about AI—stories about us, the humans, at the heart of it all. Brent Reidy This moment was like a heads-up that at SXSW, amidst all the tech talk, there's this big conversation about how we tell stories in the age of artificial intelligence. And it's not just any stories, but those that zoom in on the human experience, making sure we're not just talking tech for tech's sake but connecting it to what it means for us, living in this world, right here, right now. The Rise of Brain-Computer Interfaces (BCI) Even though the idea of a wearable device that processes the electrical signals in your brain and spits out real-time data might still feel like a page ripped from a sci-fi novel, we're seeing this tech grow leaps and bounds every single day. And now, it's inching closer to becoming something we might see in the market, not just in movies. During a session at SXSW, Adam Molnar from Neurable shared how they're crafting headsets equipped with BCI tech. These aren't your average headsets, though. They're designed to track how focused you are on a task. The cool part? They might even help you improve at focusing, theoretically teaching us how to tune into what we're doing with laser precision. "Your Brain in Artificial Intelligence: Neurotech's New Horizons" Adam dished out details about these demo headsets that haven't hit the shelves yet, expressing his strong belief that BCI gadgets will be part of our everyday lives pretty soon. This is a hint that the future of how we interact with our devices, and maybe even how we understand our own brains, is about to shift in a big way. AI Isn't a Usurper of Human Creativity; it's a Compliment That Enriches it. In an invigorating exploration of the intersection between artificial intelligence and marketing, I had the pleasure of moderating a panel titled in Austin. The session was with marketers Justin Day and Anne Ahola Ward. "Marketing to Humans in an AI World" at SXSW 2024 Our discussion explored AI's transformative impact on marketing, unwrapping layers of how this technology reshapes strategies, content creation, customer engagement, and more. The panelists shared insights, shedding light on how AI tools, like the , demonstrated, are revolutionizing the way marketing agencies craft presentations, proposals, websites, or visuals. Companies, in turn, are encouraged to foster an environment of learning and experimentation, allowing their teams to engage with these 'new tools’ and unlock their full potential. Gamma app SXSW’24 Startup Pitching Competition Watching the SXSW Pitch 2024, presented by KPMG, was a real treat. The place was packed. This year, the big themes among the showcased innovations were artificial intelligence integration, industry-specific solutions, and projects focused on sustainability and environmental impact. The competition was international, with startups from Belgium, Britain, Estonia, France, Israel, the Netherlands, South Korea, Taiwan, and Vietnam. Category Winners: AI, Robotics, and Voice: Gan.ai (San Francisco, CA)
Enterprise and Smart Data: Swif.ai (Santa Clara, CA)
Entertainment, Media, and Content: OpusClip (Redwood City, CA)
Extended Reality and Web3: Applix (Austin, TX)
Food, Nutrition, and Health: STMPatch (Storrs, CT)
Future of Work: Folio.works (Oakland, CA)
Innovative World Technologies: Cephable (Boston, MA)
Smart Cities, Transportation, and Logistics: Lotus (San Jose, CA)
Student Startup: Paradigm Robotics (Austin, TX) "Best in Show" at the SXSW Pitch 2024, went to OpusClip. Winners bagged a cash prize and earned two badges for next year's SXSW conference. However, perhaps the biggest win was the chance to present to a massive audience of SXSW attendees and potential investors. From 2009 to 2023, over 93% of the 647 companies participating in the SXSW Pitch have secured around $23.2 billion (excluding undisclosed grants, angel, and seed funding). SXSW 2024 once again proved it's more than just a tech and innovation event; it's a preview of tomorrow that already has us all buzzing about next year. And for those already looking forward to the next chapter, mark your calendars: SXSW 2025 is set for March 7-15, 2025. It's never too early to start planning for another round of inspiring discussions and groundbreaking ideas! Also published here

Step Towards Sci-Fi: AI and BCI Insights From SXSW

Let's learn about via these 33 free stories. They are ordered by most time reading created on HackerNoon. Visit the to find the most read stories about any technology. Image Recognition /Learn Repo 1. Using Image Classification for Fitness and Dieting Apps Body management is desired yet hard. Knowing how much the daily take-in is can also be a challenge. Read on to use ML tech to overcome these challenges. 2. How Computer Vision Turns Images Into Arrays How Images are turned into arrays in Computer Vision 3. Universal Data Tool Introduction: Weekly Update 2 If you haven’t heard of the Universal Data Tool, it’s an open-source web or desktop program to collaborate, build and edit text, image, video, and audio datasets with labels and annotations. 4. An Intro to AI Image Recognition and Image Generation The ability of artificial intelligence to recognize and generate images or even videos is assisting businesses to enhance the speed and quality of their work. 5. How AI Is Helping To Diagnose Cancer Read how artificial intelligence is used in digital pathology for cancer diagnosis and reveal MobiDev’s research on WSI processing using machine learning models 6. This Is How Easy it Is to Read and Display Images Working with images is more and more popularized; we are going to take dive into this field, first with the basics and starting with an open CV library. 7. Small Object Detection in Computer Vision: The Patch-Based Approach How to carry out small object detection with Computer Vision - An example of finding lost people in a forest. 8. 10 Best Image Classification Datasets for ML Projects To help you build object recognition models, scene recognition models, and more, we’ve compiled a list of the best image classification datasets. These datasets vary in scope and magnitude and can suit a variety of use cases. Furthermore, the datasets have been divided into the following categories: medical imaging, agriculture & scene recognition, and others. 9. What Makes "Good" Fashion Image Tagging Fashion image tagging is infamously tedious for eCommerce. But, how can AI help create accurate tags--and go a step beyond in understanding fashion information? 10. How to Build Neural Network that Recognizes People Wearing Masks CDC officially recommends wearing face masks (even though not everyone complies). Meanwhile, governments in European countries like Spain, Ukraine, or certain regions in Italy require everyone, big or small, to wear masks all the time, when shopping, walking a dog, or plainly going outside. Breaking the requirements could result in a hefty fine. 11. Image Annotation Business Models [Reviewed] In the rise of robotics, computer vision and image processing cameras, image annotation comes as the first step to get the right AI training data for Deep Learning models. Whether you build an app to allow users to snap fashion items at the store as a new omni-channel sales or use machine vision installed at edge device at the industrial facility to monitor anomalies: it starts with training massive image data sets. 12. What's The Best Image Labeling Tool for Object Detection? An image labeling or annotation tool is used to label the images for bounding box object detection and segmentation. It is the process of highlighting the images by humans. They have to be readable for machines. With the help of the image labeling tools, the objects in the image could be labeled for a specific purpose. The process of object labeling makes it easy for people to understand what is in the image. The labeling tool helps the people to mark the items in an image. There are several image labeling tools for object detection, and some of them use varied techniques for detection of the object, like a semantic, bounding box, key-point, cuboid, semantic and many more. In this article, we will talk about image labeling and the best image labeling tools. 13. Hacking Your Mind with AI: The Case of Addictive TikTok Discover how the AI algorithms used in TikTok make you addicted to the app.  Find out how companies use them to improve their marketing efforts! 14. ICDAR 2021 Competition: Detecting Tables Using Image Recognition To participate go to: https://competitions.codalab.org/competitions/26979 15. Unwrapping Wine Labels - How We Trained A Neural Network To Do It In the previous article, it was described a six-point method to unwrap wine labels. Finding anchor points were performed with Hough transform. It gave fair results for good labels, but for many real cases it was quite unstable, and the efforts to tune it didn’t help much. It became clear at some point, Hough transform itself wasn’t capable of handling the variety of label forms, so the next step was training a neural network. 16. Experiencing Seattle's Amazon Go Grocery Capitol Hill, Seattle. That’s the location of the most futuristic supermarket on the planet, the Amazon Go Grocery store. Today it opened its doors to the general public for the first time, and this was my experience. 17. The “Magic of Tidying for Photos” App — Introduction This post shares about the idea of applying Kon Marie organising method to your digital photos, and I developed an IOS app  with AppleML and PhotoKits to solve the problem. I share my reflection on lean product development strategy and my journey of making the app end-to-end using a minimum, iterable tech stack and strategy. 18. Creating an Image Recognizer on Golang Telegram Bot In this article, we will go over a project on image recognition using Go. We will also create a Telegram bot, through which we can send images for recognition. 19. Major Image Recognition And Annotation Trends Image recognition and annotation technologies are evolving. New techniques that allow you to solve a wide variety of tasks quickly appear. We are happy to present five major trends in image recognition and annotation. 20. Facial Recognition On Drone A facial recognition demonstration using Keras, Tensorflow, python and the drone Tello, from DJI. 21. Are Your Photos Exposing You? You may be accidentally sharing personal information in your photos 22. Clearview AI Fined in UK for Illegally Storing Facial Images In this thread, our community discusses Clearview's endeavor and the backlash that followed. 23. Can I Avoid Facial Recognition At The Airport? Technically, yes, but it is not always easy 24. High-Resolution Photorealistic Image Translation in Real Time You can apply any design, lighting, or graphics style to your 4K image in real-time using this new machine learning-based approach 25. Image Analysis using AWS Rekognition via Lambda Function In this blog, I am going to show you how we can use rekognition for image analysis using lambda function.we will be going to perform label detection and object detection for an image so basically we are performing image analysis in this blog. 26. Using Sparse R-CNN As A Detection Model Today, we are going to discuss a method proposed by researchers from four institutions one of which is ByteDance AI Lab (known for their TikTok App). 27. How Artificial Intelligence Can Improve Modern Radiology Artificial Intelligence in Radiology - Advantages, Use Cases & Trends. Read about the challenges radiology AI is facing on the way to deployment 28. Use Cases and Roll-Out Tips for Image Recognition in Retail Heavily shattered by the pandemic, the retail sector is on the lookout for innovation. 29. Image Analysis using AWS Rekognition via AWS CLI In this blog, I am going to show you how we can use rekognition for image analysis using AWS CLI. So you can test the image analysis on your local machine. We will be going to perform label detection and object detection for an image so basically we are performing image analysis in this blog by using AWS CLI. 30. How To Identify Trees with Deep Learning Idea / inspiration 31. How Synthetic Data is Accelerating Computer Vision In the spring of 1993, a Harvard statistics professor named Donald Rubin sat down to write a paper. Rubin’s paper would go on to change the way that artificial intelligence is researched and practiced, but its stated goal was more modest: analyze data from the 1990 U.S. census, while preserving the anonymity of its respondents. 32. What is Human Pose Estimation? Part of the broader artificial intelligence and computer vision realms, human pose estimation (HPE) technology has been gradually making its presence seen in all kinds of software apps and hardware solutions. Still, human pose estimation seemed to be stuck at the edge, failing to cross into mainstream adoption. 33. Manipulate Images Using Text Commands via this AI Manipulate Real Images With Text - An AI For Creative Artists! StyleCLIP Explained Thank you for checking out the 33 most read stories about Image Recognition on HackerNoon. to find the most read stories about any technology. Visit the /Learn Repo

33 Stories To Learn About Image Recognition

214 Stories To Learn About Computer Vision

I despise Christmas. The city becomes like a pestering showroom, seemingly designed to provoke me. Flaunting what they have: Christmas trees, gifts, loving families gathering around the tree once a year like in the movies. I once had a family too—a beautiful wife and a lovely daughter. But I screwed it up... My wife left and took our daughter with her. They might be living in England now. I know nothing about them. I can't even be angry; after all, I was the one who drove them away. Since then, Christmas for me has been about loneliness. About how people constantly remind me of what I've lost. But this Christmas will be different. This year, I'll have a tree too. I will be the tree. I've picked out a sturdy roof beam. That's where I'll hang myself. I thought it would be easier, but I've realized that this actually requires the most courage. Being suicidal isn't simple. So, I jumped down to the store for a bottle of whiskey, to drink up some bravery one last time. The street was completely deserted. There was no sign of life, except for that one convenience store where I finally managed to get some booze. I paid for it; the cashier wished me a Merry Christmas. I just shrugged and walked out the door. Why not start drinking right now? I opened the bottle and took a big swig. The whiskey scraped its way down my throat, and then became a warmth in my stomach, which felt particularly good on this cold winter night. After a few sips, when my steps began to wobble, I decided to stop for a moment to relieve myself. That's when I noticed the homeless person on the street corner. He wore tattered white clothes, possibly burlap. Maybe he stole it from a nearby nativity scene. The light played a strange game on his body as if he was glowing. Or maybe it was just my eyes playing tricks, which wouldn't be surprising after downing half a bottle of whiskey in about fifteen minutes. Come, buddy, sit with me. — he called out. Why not, after all? I'm not in such a hurry to hang myself that I can't spare a few minutes for a half-crazed man. Want some? — I offered him the whiskey. The homeless man just nodded, then took a sip of the whiskey. That's when it hit me where I recognized this face from. No, not an old friend. The last time I saw him was in the church. A very long time ago, when I still went to such places. It was Jesus himself sitting next to me, looking exactly as he was depicted in the church. I sat there with the most influential man in the world on an empty street, sharing a bottle of whiskey. He seemed so real, but I knew it couldn't be true. For a few moments, I just stared blankly, then he broke the silence. I know what you're thinking. You think all of this isn't real. That you've gone mad and your mind is playing tricks on you. But that's nonsensical. If I'm merely a product of your mind, anything you do to prove the contrary will be unsuccessful. You can't deceive your own mind. I could say I know everything about you, but that wouldn’t prove anything; if I'm just a figment of your imagination, you obviously can't ask a question I wouldn't know the answer to. Was the shopkeeper real? Or even this whiskey? How can you know if anything is real beyond yourself? And God? What about God? — I didn’t really understand his point, but I thought discussing God would be a good start in a conversation with Jesus. If everything is just a creation of your mind, then you are God, right?! If I am God, why is my life so miserable? Because you made it that way. And if I die, does everything end? Death is overrated. If you're a butterfly in your dream and someone steps on you, do you mourn the butterfly? You just wake up. Maybe ponder for a bit about what it was like, then start a new dream. So, I'm sitting here with Jesus himself, and you're suggesting I should commit suicide? Jesus? Why do you call me that? What should I call you? Last time you called me Arnold. Arnold? Yes, Arnold, your personal assistant. Personal assistant? Yes. That's the protocol. If you stray too far off the path, you can choose to start a new life or roll back the current one. I’m a bit confused. Can you explain all this clearly? Oh, sure. In the 2050s, human technology reached the singularity. People continue to live in digital form. Great. So, you're a time traveler? Not at all. I'm just a second-generation AI. Second generation? Yes. Humans are the first generation, and artificial intelligence based on the first generation is the second. So, you're some kind of robot? Now I'm starting to understand the Arnold name. A time-traveling robot from the future. Just like the Terminator... — I said, laughing, because this all started to seem very frivolous. Not exactly. Currently, a computer is running your mind, which includes me and all other people. Essentially, you are just a part of your own larger mind. It's hard to explain in a way that you would understand, but at a higher level, we are all one entity. I see. We are God, experiencing a massive split in consciousness. Something like that. The computer running us orbits the Earth with millions of similar machines. The machines are powered by the sun and arranged in a spherical formation around the planet. Nanomachines continuously transform the Earth so that dumb matter becomes smart matter. So, everything around us isn't real? It depends on how you define reality. Currently, it's 2019. If we reach 2050, humanity will likely achieve singularity and move into simulated worlds. From that perspective, this will be reality; from here, the outer world is. But who knows if the outer world is the ultimate objective reality? This is starting to give me a headache, but I still don't understand why you're here. To offer you the choice. A new life, or a rollback? What's a rollback? Before you created this personality, you set a path that you must follow. Why? Why not just enjoy omnipotence? Because it's boring. If you irrevocably stray from the path, you have the option to return to an earlier point and continue from there. It's like a backup of your mind at a specific state. Since your mind reverts to an earlier state, you won't remember what happened afterward. So that's how fate works? Yes. You feel as if a series of random decisions guide your path. Everything seems to lead in one direction. But that's only because we roll back the bad decisions. If something is meant to happen, it will, and you can't prevent it. If you tried, something random would always interfere. At least that's how you would experience it, since every time you managed to prevent an event, the system would roll back. In a mostly deterministic world, randomness is God's only tool. If the world is deterministic, how can anything happen by chance? It's like quantum mechanics. Exciting things happen when no one is watching. The slice of reality that no one is aware of is God's territory. Here happen the big things that people just shrug off as random. So, you came to ask if I'd rather reincarnate or go back in time to correct my mistakes? You could say that. At that point, I took a big gulp of whiskey. Then I want my family back. That last gulp might have been unnecessary. I started to feel dizzy, and the world became increasingly blurry. Finally, everything melted away… I felt a pressure on my chest. Slowly, I opened my eyes and stretched widely. A fire flickered in the fireplace, and Katy, my little girl, was sitting on my stomach. Daddy, daddy! Santa has come. Let’s open the presents! I clambered out of bed and rubbed my eyes. Under the ceiling-high tree, the presents were already laid out. Annie had taken care of everything, and let me sleep until this little imp jumped on my stomach. By the time I came to my senses, Katy was already unwrapping the gifts, then suddenly stopped for a moment and turned towards me. Daddy, didn’t Santa bring you anything? Oh yes, my little girl, he did. I watched Katy unwrap the presents, and a feeling of otherworldly joy washed over me. This is my gift. I had forgotten how much I adore Christmas. If you are confused, read my very first article on HackerNoon: https://hackernoon.com/our-universe-is-a-massive-neural-network-heres-why-c14j3ze1 I wish you a very merry Christmas!

A Christmas Story (After the Technological Singularity)

Jingle Bells, Hackers Smell: Riding the CVE Sleigh to Cyber-Safe Holidays (Santa's Alert for Appearances!) While we deck the halls and rock around the Christmas tree, hackers treat CVEs like the ultimate Secret Santa—a gift that keeps on giving (them access to our networks). But don't let your sing the blues this festive season; with some smart moves, we can wrap those CVEs up tighter than the most stubborn of holiday gifts. 🎅🔒🎁 cybersecurity Introduction Imagine you're all snug in your bed while visions of sugarplums (or perhaps encrypted data) dance in your head. In the merry land of cybersecurity, however, there's no rest for the weary, as CVEs become the Grinch plotting to steal the Christmas of our network's tranquillity. But take heart! We can outsmart these humbugs and keep our cyber-chimneys clear of unwanted visitors. 🛡️🔒 The Advent Calendar of CVEs: A Not-So-Jolly Countdown Think of a CVE like the calendar countdown to the big day, but instead of chocolates, there's a different kind of surprise in every window: : This is when the elves spot a potential toy malfunction before it hits Santa's sleigh. 🕵️‍♂️🔍 Identification : Imagine announcing over the North Pole PA system which toys might break. 📢🎁 Disclosure : If the mischievous elves (aka hackers) get there first, it's coal for everyone. ⚠️👿 Exploitation Hackers' Winter Wonderland: Why They're Merrymaking with CVEs 'Tis the season for hackers to spread their malicious cheer, as they find joy in exploiting CVEs during the holiday season. Just like characters from Tim Burton's "Nightmare Before Christmas," these cyber-Scrooges have their own twisted version of festive fun. : Picture bots zipping through the digital snow faster than St. Nick's Midnight Express. These automated agents are quick to identify vulnerabilities, constantly searching for weaknesses in systems and networks. They navigate with precision, leaving no stone unturned in their quest to find a way in. Sleigh Ride Scouts : Unfortunately, patches sometimes arrive fashionably late, just like a Christmas card from your dear aunt in July. While security researchers and software vendors work diligently to develop fixes, there can be delays in their release. This gives hackers an extended window of opportunity to exploit the vulnerabilities, like a delayed gift that arrives just in time for the holidays. Patchwork Presents : Security teams find themselves bombarded with an overwhelming number of CVEs, much like trying to discern your own pitch in a chaotic round of '12 Days of Christmas'. With so many alerts, it becomes challenging for security professionals to prioritize and address each vulnerability effectively. Carol of Alerts But why do hackers find such delight in exploiting these vulnerabilities? The excitement and thrill of successfully exploiting a CVE and gaining unauthorized access to systems fuel their motivation. Just as a laser pointer captures a cat's attention, CVEs give hackers an enticing target to focus their efforts on. It's like watching a mischievous cat chasing a laser pointer. So, as we enjoy the holiday season, let's not forget that hackers are also in a festive mood, seeking opportunities to exploit vulnerabilities. By understanding their tactics and taking proactive measures to protect our systems, we can stay one step ahead and ensure a cyber-safe holiday season for ourselves and our organizations. The Naughty List: How the CVE System Can Coal Things Up Our digital Santa Claus faces challenges in keeping his list up-to-date when it comes to managing CVEs: : The teams responsible for managing CVEs are like Santa's reindeer powering a sleigh built for NASA—full of spirit but in need of an upgrade. They work tirelessly to identify and address vulnerabilities, but with the ever-growing software and hardware complexity, they could benefit from increased resources and support. 🦌🔌🚀 Reindeer Resources : Just like that fruitcake from last year that often goes unnoticed but has the potential to cause a disruption, many vulnerabilities may slip through the cracks. These vulnerabilities, although not always in the spotlight, can pose significant risks if left unaddressed. It's crucial to ensure comprehensive coverage and actively identify and patch these vulnerabilities to maintain strong cybersecurity defenses. 🎂🔍 The Great Gingerbread Gap : With millions of toys (or software components) being developed and deployed, Santa's workshop faces the challenge of checking every single one twice. It's a monumental task to ensure that each component is thoroughly vetted and free of vulnerabilities. This requires efficient coordination, collaboration, and quality assurance practices among developers, testers, and security professionals to minimize the chances of introducing vulnerabilities into the software ecosystem. 🧸✅✅ Toy Factory Tangles Expanding on these challenges and exploring how developers play a crucial role in addressing CVEs and strengthening cybersecurity defenses will be the focus of a future blog post. Stay tuned for more insights on this topic! A Carol of Cyber Tactics: How the Grinchy Hackers Move In the world of cybersecurity, hackers have mastered the art of exploiting vulnerabilities, and their tactics are as cunning as a Grinch stealing Christmas presents. Let's take a closer look at two of their most common tactics: : These villains are like carolers who show up at your door before you even have a chance to sing along. Zero-day exploits refer to vulnerabilities that hackers discover and exploit before developers are aware of them. It's like finding a flaw in Santa's sleigh and taking advantage of it before anyone has a chance to fix it. These exploits can cause significant damage as they target vulnerabilities that are unknown to the vendor and, therefore, unpatched. Zero-Day Carolers : Imagine if someone took apart Santa's toys to see how they were built, but instead of putting them back together, they created traps. That's what hackers do when they reverse-engineer patches. When a patch is released to fix a vulnerability, hackers can analyze it to understand the vulnerability and develop an attack to exploit systems that haven't been updated yet. It's like using Santa's own tools against him. Reverse-Engineering Workshop Understanding these tactics is crucial in the . By staying informed and implementing robust security measures, businesses and individuals can protect themselves from these Grinchy hackers and ensure a safer digital environment. 🎄🔒💻 fight against cybercrime Jingling All the Way: The Real-World Impact of CVE Delays In the fast-paced world of cybersecurity, every moment that vulnerabilities go unpatched is like leaving our holiday lights tangled in a box—frustrating and unproductive. Just as we eagerly anticipate the joy of unwrapping presents, cybercriminals eagerly await the opportunity to exploit vulnerabilities that have not been addressed in a timely manner. 🎄🔌 In this winter cybersecurity wonderland, losing time to a CVE is like dropping your roasted chestnuts all over the floor—annoying, messy, and entirely preventable with a little foresight. Just as Santa is said to be watching, hackers are vigilantly observing too, and instead of presents, they're ready to hand out security incidents. We must be proactive in addressing vulnerabilities to ensure a secure digital environment for ourselves and our organizations. 🌰🚫🔒👿💻 It's crucial to understand the real-world impact of CVE delays. Every minute that vulnerabilities are left unpatched increases the risk of data breaches, system downtime, and other costly incidents. These incidents can lead to reputational damage, financial losses, and compromised security. ⏰💥💻 To prevent such consequences, it is essential to prioritize timely patching and implement robust security measures. By promptly addressing CVEs and applying necessary security updates, organizations can minimize the window of opportunity for cybercriminals to exploit vulnerabilities. Remember, in the cybersecurity race, time is of the essence, and staying ahead requires proactive action. ⏳🔒🏃 Let us take the necessary steps to protect our valuable data and assets, ensuring a cyber-safe environment not just during the holiday season but all year round. 🛡️💻🔒 Wrapping Up Your Network: The Cybersecurity Gift-Giving Guide Fear not, for here are some effective strategies to secure your cyber defenses tightly, leaving Santa's elves unable to sneak a peek: : Just like Santa's fleet on Christmas Eve, ensure that your monitoring is omnipresent. Keep a watchful eye on your systems and networks, ready to detect any potential threats. 🦌👀🛡️ Reindeer Reconnaissance : Employ automated tools that tirelessly patch up vulnerabilities, much like Santa's elves wrapping gifts in his workshop. Let these tools work diligently to apply necessary security updates, minimizing the risk of exploitation. 🤖🔧🎁 Automated Elves : Train your team to be as vigilant and alert as a frosty friend. Equip them with the knowledge and awareness to identify and respond to phishing scams, ensuring that they don't fall for any tricks disguised as Santa's outfit. ⛄🎣🎅 Savvy Snowmen (and Women) With these powerful strategies at your disposal, you are not merely waiting for Santa; instead, you're joining him on the rooftop, standing ready to protect your valuable data and assets. 🎅🔒🍪 By implementing these proactive measures, you can confidently safeguard your digital environment, outpacing hackers in this ever-evolving landscape. Conclusion: Sleighing the CVE Grinches In our cyber fairytale, might seem like they're leading the Grinch-conga line toward our digital goodies. But even Santa needs a little help sometimes, and with our advanced preparation and cyber-smart strategies, we're ready to hang our stockings with care—and confidence. 🎄🎅🔒 CVEs Remember, in the cybersecurity night sky, be the brightest star atop the tree, guiding Santa’s sleigh through the fog—not the blinking warning light on a hacker's dashboard. ✨🌟🎅🔒 Because after all, 'tis the season to be secure! 🎄🔒 FAQ Can you give me a festive refresher on CVEs? 🎅🔒 Q: CVEs, also known as Common Vulnerabilities and Exposures, are like those tricky Christmas lights; if one bulb is faulty, the entire string can go dark. Just as you need to regularly check your Christmas lights to ensure they are all functioning properly, CVEs require constant monitoring to identify and address any vulnerabilities in software or hardware. 🕵️‍♀️💡 A: How do CVEs impact cybersecurity? Q: CVEs pose a significant threat to cybersecurity. When vulnerabilities are left unaddressed, hackers can exploit them to gain unauthorized access to systems, leading to data breaches, system downtime, and other costly incidents. Promptly addressing CVEs and implementing robust security measures are crucial to mitigating their impact and protecting valuable assets. 🛡️💻💥 A: What are some challenges with the CVE system? Q: While the CVE system serves as a valuable resource for cataloging and tracking vulnerabilities, it faces certain limitations and challenges. These include limited resources for assigning and tracking vulnerabilities, incomplete coverage of less popular or niche software and hardware, and the complexity of coordinating vulnerability identification and assigning CVEs across various vendors and organizations. 🚫🔍🌐 A: How can organizations defend against CVEs? Q: Organizations can adopt proactive measures to defend against CVEs. This includes staying vigilant through continuous monitoring of systems and networks, implementing automated patch management systems to ensure timely application of critical security updates, and educating employees about cybersecurity risks and best practices. By combining these strategies, organizations can stay one step ahead of hackers and enhance their cybersecurity defenses. 👀🔒🚀 A: May Infosec Be with You.

'Tis the Season to Secure: How CVEs Are the Grinch for Cybersecurity

Solidity 0.8.19 came up with quite a few changes and upgrades. In this post, I’ll talk about user-defined operators for user-defined value types. (I’ll use UDO and UDVT ). Before learning about UDOs, we need to look into UDVTs. What are User-Defined Value Types UDVTs are gasless abstractions of value types over the pre-defined value types in solidity. This was . In simpler terms, we can call them aliases for other value types. The core reason behind introducing this was to facilitate more strict definitions of variables. introduced in solidity 0.8.8 Quick Example For example, our contract stores two types of addresses, one for buyers and the other for sellers. We already know that under the hood, both of these variables will be of type address; however, what if we want to make them different to avoid any confusion or intermingling of different concepts? What if we want the data types to be more descriptive about the value it’s storing? Before UDVTs were introduced, this goal was attained using structs. Below is an example. The four functions in this code are used to wrap or unwrap the given data type into or from the defined data type. I am sure you have seen this type of usage in some contracts. However, as we know, structs are reference types; they’ll use memory, costing more gas than just using uint. This is where UDVTs are being used. They are simple extracts that don’t cost gas. Now, as far as the syntax is concerned, we can define UDVTs like where is the extracted value type, can also call an alias for which is the underlying type that can be uint, address, etc. Once we declare these value types, we get two attached methods with them, and , can be used to convert an underlying type to the newly created value type, is used for the vice versa. type A is B A B wrap unwrap A.wrap(value) and Let’s see this in the code. This was a demonstration related to the previous code snippet however, you might have realized that we don’t need to define the wrapping/unwrapping functions explicitly because . So, if we talk about the usage of these functions, below is another code snippet. solidity gives wrap/unwrap functions // SPDX-License-Identifier: GPL-3.0 
  pragma solidity ^0.8.8;

// Represent an 18 decimal, 256-bit wide fixed point type// using a user-defined value type.type UFixed is uint256;

/// A minimal library to do fixed point operations on UFixed.
uint256 constant multiplier = 10\*\*18;  

/// Adds two UFixed numbers. Reverts on overflow,  
/// relying on checked arithmetic on uint256.  
function add(UFixed a, UFixed b) internal pure returns (UFixed) {  
    return UFixed.wrap(UFixed.unwrap(a) + UFixed.unwrap(b));  
}  

/// Multiplies UFixed and uint256. Reverts on overflow,  
/// relying on checked arithmetic on uint256.  
function mul(UFixed a, uint256 b) internal pure returns (UFixed) {  
    return UFixed.wrap(UFixed.unwrap(a) \* b);  
}  

/// Take the floor of a UFixed number.  
/// @return the largest integer that does not exceed \`a\`.  
function floor(UFixed a) internal pure returns (uint256) {  
    return UFixed.unwrap(a) / multiplier;  
}  

/// Turns a uint256 into a UFixed of the same value.  
/// Reverts if the integer is too large.  
function toUFixed(uint256 a) internal pure returns (UFixed) {  
    return UFixed.wrap(a \* multiplier);  
}  

} We can conclude that UDVTs are not something that affects the logic of the contract but a kind of syntactical sugar that makes our code clearer and readable. math library, for example, which is a library used to tackle the floating number issue in solidity, uses UDVTs to define different types of floating numbers. PRB Now, the problem arises when we try to use arithmetic operations on UDVTs. As you can see in the above example, we have to unwrap the passed variables to use built-in operators. This is where UDOs are introduced. What are User Defined Operators? UDOs are built using the two built-in features of solidity, i.e., built-in operators and . using … for … UDOs are an extended version of . To recall, is used to: using for using for Attaching all Library functions to a data type. using LibrayName for TypeName Attaching library functions to all the data types. using LibrayName for * Attaching specific library functions or free functions to any specific type. using {LibrayName.FunctionName, FreeFunctionName} for TypeName Now, UDO comes into play and defines the fourth type of using for statement. Something like this: using {FunctionName as OperatorSign} for UDVTName global; This syntax facilitates attaching a function as an operator sign, the same as attaching a library function. The difference is we can use an operator sign instead of using the default way of calling the function. This will be clearer by looking at the code example below. There are some rules while using User Defined Operators. They can only be defined as functions(functions defined at the file level). free The free functions should be pure. Can only be defined at global directive, i.e., it can not be inside a contract but at a file level. using for User-defined Operator can only be attached to the UDVTs and not to the underlying default value types. They can only be defined for a particular type, i.e., they won’t work with different UDVTs in the same function. At last, while attaching the operators to any UDVT, only these operator signs can be used: &, |, ^, ~, +, -, *, /, %, ==, !=, <, <=, >, >= . Let’s now look at a code example. // SPDX-License-Identifier: MIT
pragma solidity 0.8.19;

//The types are defined at the file level
type Float is uint256;
type unFloat is uint256;

//"using for" statements are written at the global directive
//not inside a contract
using {add as +} for Float global;
using {multiply as *} for Float global;
using {divide as /} for Float global;

//These are pure free functions, which is a requirement
///@notice Each function works with only one type. 
    function add(Float a, Float b) pure returns (Float) {
        return Float.wrap(Float.unwrap(a) + Float.unwrap(b));
    }

    function multiply(Float a, Float b) pure returns (Float) {
        return Float.wrap(Float.unwrap(a) * Float.unwrap(b));

    }

    function divide(Float a, Float b) pure returns (Float) {
        return Float.wrap(Float.unwrap(a) / Float.unwrap(b));

    }

//Using the attached operators inside a contract
contract UDO {
    
    Float cent = Float.wrap(100);
    Float decimal = Float.wrap(1e18);

 //The multiplication and division using operators is only possible
 // because we attached these particular operators' sign to the relevant functions
    function takePercent(Float _amount, Float totalAmount)
        external
        view
        returns (Float)
    {
        return (_amount * cent * decimal)/(totalAmount);

    }
} Attaching any function to any UDVT is independent of binding the same function to it. This means that we can’t call the free function with UDVTs in a similar fashion as a library function like or when we are binding them as an operator, but obviously, we can do so when they are attached as functions. Let’s look at the example below. add(a,b) a.add(b) // SPDX-License-Identifier: MIT
pragma solidity 0.8.19;

type Float is uint256;
type unFloat is uint256;

//      binding and attaching
using {multiply as *,multiply} for Float global;
using {divide as /} for Float global;

    function multiply(Float a, Float b) pure returns (Float) {
        return Float.wrap(Float.unwrap(a) * Float.unwrap(b));
    }

    function divide(Float a, Float b) pure returns (Float) {
      return Float.wrap(Float.unwrap(a) / Float.unwrap(b));
    }

contract UDO {
    
    Float cent = Float.wrap(100);
    Float decimal = Float.wrap(1e18)

    function takePercent(Float _amount, Float totalAmount)
        external
        view
        returns (Float)
    {
        // return (_amount * cent * decimal)/(totalAmount);
        return      (_amount.multiply(decimal.multiply(cent))).divide(totalAmount);
       //In this line Multiply will work but divide will throw an error, because 
       // we haven't bound the divide function to Float.    
}
} The signs we used for particular functions are not strictly needed; we could’ve used instead of with the add function, and the would work as the add function. However, that will cause unwanted confusion, so we won’t do that. / + / What are the use cases? As discussed earlier, the UDVTs can be used to prevent any kind of type mistakes and provide a better understanding of the logic. UDOs increase the usability of the same by making it more accessible and familiar. The best usage of these are math libraries, where we can have multiple types of floating numbers and much more. That’s it for this article. Join us with all your solidity questions/confusions . HERE Also published . here

Solidity 0.8.19: Diving Into User-Defined Operators for User-Defined Value Types

This is the official HackerNoon wiki for Wrapped BNB. As part of our , this living wiki displays on . If you’d like to suggest edits to our official Wrapped BNB wiki, please submit them in the comment field below, a real human editor will read and review your suggestions for accuracy and publication. coin price pages Wrapped BNB crypto price page Wrapped BNB is a wrapped version of the Binance native tokens on the Binance Smart Chain. A wrapped token is a cryptocurrency token whose value is pegged to the value of another asset. In the case of Wrapped BNB, every WBNB coin is backed 1:1 to a binance asset. Wrapped Binance allows for faster Binance transfers on different blockchains and provides the opportunity for Binance’s native cryptocurrency BNB to be used within different blockchains. BNB can easily be transferred to Wrapped BNB and Wrapped BNB to BNB. WBNB makes it possible for Binance’s liquidity to be used on different blockchains. History Wrapped BNB was announced by Changpeng Zhao. The cryptocurrency was to be part of the Binance platform. Biggest Claims to Fame Wrapped BNB allows users to carry out transactions within different blockchains. By using wrapped BNB, users can migrate from network to network and still be able to perform financial transactions. This cannot happen using the Binance platform or many of the exchanges currently available. Platforms such as Binance do not allow for exchange between some altcoins and a cryptocurrency such as Ethereum. Wrapped BNB comes in to fix this. Wrapped BNB helps lower the drain in liquidity of other cryptocurrencies when carrying out transactions. Cryptocurrencies such as Ethereum are expensive to transact due to its high cost. This cost can be reduced drastically by changing, for example, the value of Ethereum to Wrapped BNB and then carrying out a transaction. This transaction can then be reversed by the receiving party, changing the wrapped BNB into Ethereum. This can drastically reduce the transaction cost. Wrapped BNB is more secure than BNB. Though BNB is secure enough, the use of wrapped BNB ensures it. Once a cryptocurrency is wrapped, it acquires a separate private key that a user controls themselves. Hackers will leave an account with a private security key alone if they are going for speed, which is what most hackers these days focus on considering the speed with which hacks are caught up with and prevented. Wrapped BNB makes it possible for more cryptocurrencies to earn a profit on different cryptocurrency platforms. The currency allows for a bigger profit to be made during transactions and trades than platforms would make without the ability to run within different blockchains and with different cryptocurrencies. Wrapped BNB offers fast transaction services. Buying and selling Blockchain or Ethereum takes up a considerable amount of time on their own platform. By changing the currency into Wrapped BNB, the transaction can be carried out on another platform and then transferred back into the original currency at very low costs and much higher speeds than it would have otherwise. Biggest Criticism Wrapped BNB is highly centralized. Binance has heavy control over the coin. Over 80% of Wrapped BNB is owned by Binance. Though Binance in itself is a cryptocurrency market, the centralization of wrapped BNB puts them at odds with the founding principles of cryptocurrency which is that no central institution should have control over people’s finances. Despite Binance being a decentralized cryptocurrency, this is still an issue. Wrapping and unwrapping WBNB is expensive. That cost comes from paying for the gas to work on the wrapping and unwrapping of the tokens since users pay for the gas costs. This can cause a user to pay more than the original token cost. This means WBNB is only effective for large or high-value transactions, otherwise, it costs more to transact than the actual token may be worth. Wrapped BNB relies on custodians to wrap and unwrap cryptocurrency. These custodians could be smart contracts or a multi-signature wallet. In case the custodian is corrupted, it may end up not working as it should. In case the custodian is hacked, for example, it could drain the amount of cryptocurrency in a transaction instead of unwrapping it. Team Wrapped BNB was created by Changpeng Zhao. He is a Chinese Canadian. He is also the CEO and founder of the Binance platform. This is the official HackerNoon wiki for Wrapped BNB. As part of our , this living wiki displays on . If you’d like to suggest edits to our official Wrapped BNB wiki, please submit them in the comment field below, a real human editor will read and review your suggestions for accuracy and publication. coin price pages Wrapped BNB crypto price page

Wrapped BNB $wBNB Wiki: Coin History, Techstack, and Crypto News

Welcome! Happy to see you in the second part of my Vuejs Amsterdam Conference 2022 summary series, in which I share a summary of all the talks with you. You can read my JSWorld Conference 2022 Summary 2022 series (in four parts) , where I summarized all the talks of the first day. You can also find the . here first Talk where Evan You talks about the State of Vue in 2022 here (Recurring) Introduction After two and a half years, JSWorld and Vue Amsterdam Conference were back in Theater Amsterdam between 1 and 3 June, and I had the chance to attend this conference for the first time. I learned many things, met many wonderful people, spoke with great developers, and had a great time. On the first day the JSWorld Conference was held, and on the second and third days, the Vue Amsterdam. The conference was full of information with great speakers, each of whom taught me something valuable. They all wanted to share their knowledge and information with other developers. So I thought it would be great if I could continue to share it and help others use it. At first, I tried to share a few notes or slides, but I felt it was not good enough, at least not as good as what the speaker shared with me. so I decided to re-watch each speech, dive deeper into them, search, take notes and combine them with their slides and even their exact words in their speech and then share it with you so that what I share with you is at least at the same level as what I learned from them. A very important point Everything you read during these few articles is the result of the effort and time of the speaker itself, and I have only tried to learn them so that I can turn them into these articles. Even many of the sentences written in these articles are exactly what they said or what they wrote in Slides. This means if you learn something new, it is because of their efforts. (So if you see some misinformation blame them, not me, right? xD) Last but not least, I may not dig into every technical detail or live codings in some of the speeches. But if you are interested and need more information, let me know and I’ll try to write a more detailed article separately. Also, don’t forget to check out their Twitter/Linkedin. you can find the program of the conference. Here Getting more out of your Pinia Stores Pinia might be a light library with a simple API but it takes advantage of many Vue Reactivity concepts like Effect Scopes, which are unknown by most. In this talk we will go through some of the internals of Pinia, understanding them and discovering how to enhance our usage of Pinia. During the time I was creating Pinia, I had a lot of experimenting going on with the and and the whole reactivity system of Vue, which gave me a lot of insights on how to keep that one single source of truth that we love so much in Vue. Refs Reactives State Alchemy with Pinia Pinia is the successor of Vuex, without compromising all the developer experience that comes with Vuex. It is compatible with Vue 2 and Vue 3, and it’s lighter and Vuex. One of the advantages of Pinia is that it’s Fully (automatically) type-safe. This library is based on the Composition API, but you don’t need to use the Composition API to use Pinia. It has a testing library and a Nuxt module as well. Vuex vs Pinia In Vuex you have some important rules: You can only change the state in mutations. You have to shout in action if you want to do it! (That’s why we write it in uppercase!) Mutations have to be synchronous and only actions can be asynchronous // Vuex

import { createApp } from 'vue'
import { createStore } from 'vuex'

// Create the store instance
const store = createStore({
	state: () => ({ count: 0 })
	mutations: {
		INCREMENT: state => { state.count++ }
	},
	getters: {
		double: state => state.count * 2
	},
	actions: {
		async increment ({ commit }) {
			await someAsyncCall()
			commit('increment')
		}
	}
})
// You have to use it as an Application plugin
createApp(App).use(store).mount('#app') Now let’s take a look at Pinia: // Pinia

import { createApp } from 'vue'
import { defineStore, createPinia } from 'pinia'

const useStore = defineStore({
	state: () => ({ count: 0 })
	getters: {
		double: state => state.count * 2
	},
	actions: {
		async increment () {
			await someAsyncCall()
			// There is no mutation, you can access the state with this keyword
			this.state++
		}
	}
})

createApp(App).use(createPinia()).mount('#app') There aren’t many changes, except you no longer have to shout to change the state, and there is a function that is not creating a store, it’s defining a store. The difference is, that function is going to return another function that we call to get the actual store. The reason is to handle all the different ways we use the store to have an out of the box dynamic module registrations. In the end, the function creates the Pinia instance. CreatePinia() What does the Pinia instance really do? If you look at the Pinia instance you’re going to notice two things. A function which is for Pinia plugins. use() A state is just a of an initially empty object which gets populated after you call some stores. ref That state is instantiated inside its own . EffectScope To explain we can talk about components. When you have a component that is mounted, it’s going to create its own , which is going to collect all the reactivity variables like watchers, computed, etc. under its umbrella, and when the component is unmounted, this is disposed and all the variables go away. EffectScope EffectScope EffectScope It’s the same for Pinia, except it never disappears and is always there. Pinia Holds State The stores are never going to hold the state by themselves, they're going to transfer that to the Pinia instance. So you can access the state at any time with . pinia.state.value The first time you call the in your application, it’s going to put the initial state into the store using the id of the store as the key. useSomeStore() const authStore = useAuthStore()

// Here the id will be "auth"
pinia.state.value.auth = { /* ... */ }

// If we call another store, It will add another object
const cartStore = useCartStore()

pinia.state.value.cart = { /* ... */ } So as the user navigates through the application, the store keeps growing as needed. pinia.state.value = {
	auth: { /* ... */ },
	cart: { /* ... */ },
	// other stores' state
} Pinia connects state You can access the whole state of a store through . This variable is just a getter to access the store in Pinia. $state There are three different ways of accessing a state in the store. Through the Pinia instance: pinia.state.value.auth.user.login Through on the store instance: $state authStore.$state.user.login Directly through the store instance: authStore.user.login Any of these variables is going to yield the same result, and also if you write to any of these variables you are also going to write to the three of them, in fact, you are only writing to the Pinia state, because there is only one source of Truth. In Vue composition API there is a function that gives you a to a reactive object. So if you have something that is reactive, you can get a to any part of the object and it will be connected and if one of them changes, the other one will change as well (and you have only one single source of truth). toRef ref ref When we define the store with : defineStore const useAuthStore = defineStore('auth', {
	state: () => ({
		user: {
			login: 'alice',
		},
	}),
}),

// pinia.state.value.auth and when we instantiate the store with the function and pass an object to the state, effectively what is happening is that we are getting a out of the state. useAuthStore ref useAuthStore()

pinia.state.value.auth = {
	user: {
		login: 'alice',
	},
}

authStore.user = toRef(pinia.state.value.auth, 'user') We don’t have to write , we just read the property or write to it using which is called ref unwrapping. authStore.user.value.login .value is a reactive object so any passed inside is going to get unwrapped. authStore ref Ref Unwrapping When you create a reactive object, any passed inside at any level of that object gets automatically unwrapped, so you don’t need anywhere and is gonna be type-safe. ref .value 💡 You can avoid this behavior with and shallowRef() shallowReactive() pinia.state = ref({}) // or reactive({})
pinia.state.value.auth = {
	user: {
		login: ref('alice'), // Don't do this! 🙅🏻‍♂️
	},
}
pinia.state.value.auth.user.login // alice You should never write a inside a reactive object because there is no point in doing so, writing in the code above is the same as writing the string . ref ref(’alice’) ‘alice’ But what is interesting is not refs themselves, but refs with all their behaviors attached to them. Composables Composables are functions that have a stateful return. One of the common composables is which is from a library called , and it gives you a that is going to read from and write to local storage. useLocalStorage VueUse ref pinia.state = ref({}) // or reactive({})
pinia.state.value.auth = {
	user: {
		login: useLocalStorage('pinia/user/login', 'alice'),
	},
}
pinia.state.value.auth.user.login // alice This means that we can call that composable inside of the state function when we define a store: import { useLocalStorage } from '@vueuse/core'

const useAuthStore = defineStore('auth', {
	state: () => ({
		user: {
			login: useLocalStorage('pinia/user/login', 'alice'),
		},
	}),
}) So if you have composables that return a writable source of truth (like a ), you can put them inside state and they are going to get unwrapped. So the actual behavior that may be interesting for us becomes an implementation detail we don’t need to care about anymore because it is just going to work out of the box. For example or . ref useColorMode useRouteHash But if you have a read-only state — which is more like a computed property — or you have a function — which is more like an action — it’s going to be a little different and we will see later how to use them. When does this not work? If you are doing CSR it works fine. However, if you are doing SSR or SSG there will be some problems. The problem is the state function is only called once the first time we instantiate the store. In CSR, we start with an empty state, then we call the store with and that’s going to instantiate the state and become reactive, easy! useAuthStore() In SSR, we do the same, But the problem is when the page comes back to the client on the browser, although we have the Client Side Rendering again, on the server, the state was already executed and it was already instantiated once and we are not going to do that again on the client. That means we don’t get an empty object here and we get the object from the server. So when we call , is no longer called, and we no longer have that composable creating all the watchers, connecting all the event listeners to the window, it becomes just a string and probably the server is going to give us because there is no local storage. useAuthStore useLocalStorage ‘alice’ 💡 Fortunately VueUse is going to make the local storage function work on the server as well. 💡 Some composables require a little bit more work if you want to make them work on SSR. For example, you have to check your current instance or check if there is a window object that you can rely on. If you want to learn more, you can check the source code of VueUse. It’s very comfortable because in the documentation, at the very bottom of every function you see a link to the source in the Github repository. But what do we need to make this work on SSR? We need an extra function called that is going to create the watchers and event listeners on the client-side. This function is called if the initial state exists at store creation. hydrate() import { useLocalStorage } from '@vueuse/core'

const useAuthStore = defineStore('auth', {
	state: () => ({
		user: {
			login: useLocalStorage('pinia/user/login', 'alice'),
		},
	}),
	hydrate(state, initialState) {
		state.user.login = useLocalStorage('pinia/user/login', 'alice')
	},
}) So that state is set by is going to be replaced by the hydrate function. To recap: UseAuthStore On SSR: We have an initial state: pinia.state.value: {} We call useAuthStore() useAuthStore() We have the new state: pinia.state.value: {
	auth: { /* ... */ },
} and that is going to be sent to the client. Then on CSR: We start with that state pinia.state.value: {
	auth: { /* ... */ },
} We call useAuthStore() useAuthStore()
// does not call state() And then we have the function adding the little bit that we were missing from the state function again hydrate state.user.login = useLocalStorage('pinia/user/login', 'alice') Options Store vs Setup Store Options store which is pretty much like options API is what we talked about so far. Setup stores are stores that are defined with a function similar to the setup function in composition API. const useAuthStore = defineStore('auth', () => {
	const user = useLocalStorage(...)
	
	return { user }
}) So in this case we don’t have multiple properties like state, getters, and actions, we just have one function and it has to create reactive objects if you want a state and return them, and it’s going to have computed for getters and functions for actions. const useAuthStore = defineStore('auth', () => {
	const user = useLocalStorage(...)

	const isLoggedIn = computed(() => /* ... */)

	function login(user, password) { /* ... */ }
	function logout() { /* ... */ }
	
	return { user, login, logout, isLoggedIn }
}) In the end, you return anything you want to expose and you can keep anything you want to keep private. Because we have just one function that defines everything, we can just not call it! We have to call it both on the server and the client. We need to hint to Pinia that e.g. shouldn’t be hydrated. useLocalStorage import { defineStore, skipHydrate } from 'pinia'

const useAuthStore = defineStore('auth', () => {
	const user = skipHydrate(useLocalStorage(...))

	const isLoggedIn = computed(() => /* ... */)

	function login(user, password) { /* ... */ }
	function logout() { /* ... */ }
	
	return { user, login, logout, isLoggedIn }
}) What happens behind the scene is that normally when we’re on the client after the server has rendered the application, the store goes through all the different properties that have been put into the initial state, takes the values from the initial state, and put them into the store state; more exactly into the ref that we return in the function: user.value = pinia.state.value.auth.user // alice That ref created by the store is then transferred into the Pinia state so that we have one single source of truth: pinia.state.value.auth.user = user // 1 source of truth The thing is with skipHydrate, we are skipping the first line, so the that’s no longer happening. user.value = … We should not use everywhere. If we look at the for example: skipHydrate useEyeDropper import { defineStore, skipHydrate } from 'pinia'
import { useEyeDropper } from '@vueuse/core'

const useColorStore = defineStore('colors', () => {
	const { isSupported, open, sRGBHex } = useEyeDropper()
	// ...
	return {
		lastColor: sRGBHex, // Ref<string>
		open, // Function
		isSupported, // Boolean
	}
}) Among these three, only the is going to become a state. lastColor What is interesting is that we can stack these refs together. So we can pass the RGB hex ref to the local storage. import { defineStore, skipHydrate } from 'pinia'
import { useEyeDropper, useLocalStorage } from '@vueuse/core'

const useColorStore = defineStore('colors', () => {
	const { isSupported, open, sRGBHex } = useEyeDropper()
	const lastColor = useLocalStorage('lastColor', sRGBHex)
	// ...
	return {
		lastColor, // Ref<string>
		open, // Function
		isSupported, // Boolean
	}
}) In this scenario, we want to use , because the relies on what the browser is seeing and doesn’t care at all about the server response on the initial value for the . skipHydrate useLocalStorage lastColor If we were using only the , wouldn’t need the because most of the time we don’t care if we hydrate from the server-side response or not, because there is not a new value in the browser context that is interesting for us and that could get overwritten by what the server sent. useEyeDropper skipHydrate But if we use the local storage then we need to make sure that the one in the browser prevails and the server one is just ignored. So what you need is not to use on every single ref, just on the ones that you want to avoid setting the value from the initial state, and only on SSR of course. skipHydrate Summary Options Store Can use basic Composition API inside state() Can only return writable state Use for composables hydrate() Setup Store Use any Composable (like in ) setup() Automatically tells apart state from actions from getters Use to ignore values from the server skipHydrate() End of the second Talk I hope you enjoyed this part and it can be as valuable to you as it was to me. You can find the next talk about Histoire . here Also published . here

Vue Amsterdam 2022 - Part II: Getting More Out of Your Pinia Stores

Great Expectations: Chapter VII

What are Bitcoin and Ethereum? These are the two biggest and the most famous cryptocurrencies in the world, and it can’t be that you’ve never heard of them. But still, (ticker BTC) is a form of digital currency that meets the need of central authorities such as banks or governments. Instead, Bitcoin uses a peer-to-peer internet network to confirm purchases directly between users. Bitcoin Launched in 2009 by a mysterious developer known as Satoshi Nakamoto, Bitcoin (BTC) was the first and most valuable entrant in the emerging class of assets known as cryptocurrencies. is a decentralized blockchain with smart contract functionality. (ticker ETH or Ξ) is the native cryptocurrency of the platform. Among cryptocurrencies, Ether is second to Bitcoin in market capitalization. Ethereum was launched in 2013 by a programmer Vitalik Buterin. Ethereum Ether What is a wrapped coin/token? Wrapped Bitcoin (WBTC) brings Bitcoin (BTC) to the Ethereum (ETH) blockchain.  Why is that so crucial? One of the main points is that WBTC is in decentralized finance and it provides the owners of cryptocurrency with the freedom to explore other blockchains. If you want, it’s a kind of a bridge between a BTC coin and an Ethereum platform. Wrapped tokens are cryptocurrencies that are implemented in a different blockchain. The reason that wrapped tokens exist is for interoperability, which is the ability of a coin to work in a blockchain that normally does not support it. Benefits of wrapped tokens Wrapped cryptocurrencies boost the utility and liquidity of smart contract platforms and well-known decentralized finance (DeFi) apps. Other reasons to wrap cryptocurrencies may include ERC-20 token swapping or taking advantage of blockchain functions that a crypto asset might not have on its native chain. It’s faster and cheaper to make transactions using a wrapped version of BTC. The majority of blockchains have their own token standards and they sometimes can’t be used across multiple chains. Wrapped tokens allow non-native tokens to be used on a given blockchain. It’s quick. As for buying or selling Bitcoin, it could be quite time-consuming. But a wrapped Bitcoin (WBTC) in the Ethereum network is way quicker. When you wrap a token, you actually increase the security of your assets because you have control over private keys. Plus, intermediaries (DAO, smart contracts, or a wallet) focus on safe exchanges. And yet some drawbacks Custody Wrapped tokens still depend on a custodian to be minted (wrap) or burned (unwrap). If the custodian is somehow flawed, the wrapping or unwrapping process will be flawed as well. Expensive minting It’s quite evident that wrapping and unwrapping tokens are followed by gas fees, which can lead to slippage. Centralized The pivotal point of cryptocurrencies is to be a decentralized system. But wrapped tokens are issued by a custodian, and they tend to be centralized. According to Vitalik Buterin, wrapped tokens are “sensitive” to centralization because they’re created in a centralized manner. The matter is that wrapped tokens are minted through a central program, so they are an object of centralization.Good news, the benefits of wrapped tokens compensate for the negative sides though. How to wrap BTC? A wrapped BTC is a digital form of BTC blockchains that support smart contracts such as Ethereum, Solana, Polkadot, Binance Chain. Wrapped assets are just tokenized versions of Bitcoin that meet the token requirements of DeFi-supporting blockchains. Bitcoin wrapping techniques Here are three different options for tokenizing Bitcoin, all of them ask a user to lock BTC or other assets to get tokens pegged to the value of Bitcoin: Centralized This technique involves an intermediary. In this case, you need to send a necessary amount of BTC to a centralized custodial platform. After, this platform will lock your Bitcoin in a smart contract and mint an equal amount of tokenized Bitcoin on Ethereum or any other blockchain you need. Finally, the dealer will transfer the tokenized Bitcoin, WBTC, directly to your wallet. Trustless Using the following option, you do not need to trust a centralized side. You can send your Bitcoin to a smart contract adapted to mint tokenized Bitcoin quantity to the amount of locked BTC. Keep Network could be a good example of a system that uses a trustless technique. Synthetic The last Bitcoin wrapping option empowers users to get synthetic assets pegged to the Bitcoin value. Synthetic wrapping does not necessarily utilize BTC coin to mint a Bitcoin-pegged synthetic token. You can lock a combination of assets to mint synthetic Bitcoin. It really depends on the protocol you use. How to wrap Ether (ETH)? The process of generating WETH is fairly simple - you send your ETH to a smart contract that then sends WETH in return. This means that all WETH minted is backed up entirely by ETH reserves. To begin with, your ETH is locked in the smart contract and can be exchanged back at any time for WETH. When your ETH is returned, the contract burns the supplied WETH. To wrap Ether directly with the WETH smart contract, you need some ETHs and credit your wallet with WETH at a 1:1 proportion (you still need to pay transaction fees). Actually, it's much easier to swap another token for WETH using a crypto exchange. Where to store your WBTC and WETH? There are plenty of different options, of course, but we offer you something special, a . It was initially created for beginners, and the main aim was always to make all your crypto operations extremely safe. It supports 200+ currencies, and it’s just a promising beginning. The interface is intuitive and friendly, so you’ll never get lost within the wallet. You can have it as your favorite browser extension or as a mobile app. SimpleHold wallet Wrapping that up Wrapped tokens build a bridge between various blockchains. A wrapped token is, by nature, a tokenized version of an asset that natively operates on another blockchain. One of the biggest pros of wrapped tokens is that they provide greater scalability between different cryptocurrencies and blockchains and widen the opportunities for developers and traders.

What is Wrapped BTC and ETH (WBTC and WETH)?

Wrapping Allows To Seamlessly Move Crypto Across Multiple Blockchains That Would Otherwise Remain Isolated. When crypto just came into existence with the release of Bitcoin source code back in 2009, interoperability across blockchains was not a part of the initial plan. However, with the advancement of technology and the crypto market growth, the need to incorporate interoperability into blockchain protocols and networks arose. It has become essential to find a solution enabling users to carry on fast and seamless transactions across different blockchains at a low cost. That burst an idea of the possibility to use the same token on another blockchain. Bridging the interoperability gap by virtue of crypto assets wrapping was meant to make it all happen. Here we are gonna talk about what wrapped tokens are, look at their perks and limitations, and master some wrapping mechanics. With this knowledge, you can be better prepared for future innovations that might come knocking at the door tomorrow. What is a wrapped token? A is a digital replica of a crypto asset (let’s take BTC for example) that is created on another blockchain non-native for this asset. A well-known example here is Wrapped BTC (WBTC) — a Bitcoin equivalent that circulates on the Ethereum blockchain. wrapped token So a wrapped token is a kind of “mirror” of a digital asset that reflects its same amount (i.e., 1:1) and real-time price fluctuations. In comparison with the world of traditional finance, wrapped tokens at some point resemble — financial instruments representing a foreign company’s securities on international markets. Depository receipts (DRs) allow companies to trade their securities outside their home country. In that sense, DRs serve as a kind of bridge connecting a particular business with global capital. depository receipts Just an example here of how it works. Say, a gas company in Israel has met the New York Stock Exchange (NYSE) requirements and now wants to list its publicly traded shares on it. Unfortunately, the company can not just apply for the direct listing of its shares. The listing could be done only in the form of the American Depository Receipts (ADRs) that would proportionally represent its shares on the Exchange. For that, besides many other actions that should be taken, the company would have to deposit its shares with an authorized custodian bank. Once this is done, the bank would inform a US authorized depository bank that the shares are received and that the ADRs can now be issued in the US. Our Israeli company would be entitled to get listed on the NYSE from that moment. The ADRs would represent its original shares, held by the depository, and can be freely traded on the NYSE like any other shares. The ADRs investors would be entitled to the same rights (like voting and dividends) as the company’s direct shareholders. Voilà! This is how we just elegantly bridged the cross-international gap in the financial markets. 🎉 Now let’s get back to wrapped tokens. They are designed to bridge the fragmented pieces of the crypto market and solve the well-known problem of cross-chain interoperability. Wrapping one token into another makes it possible to utilize such token on blockchain networks that are non-native to it. Similar to depository receipts, wrapped tokens are equivalent representations of the original assets, unlocking for their holders the exposure to more markets and, therefore, more earning opportunities. The same as a depository receipt can be converted back to a stock it represents, so does a wrapped token. Its holder can it any time and get the underlying crypto asset. In that case, the wrapped tokens would be “ .” unwrap burnt What is not a wrapped token? There is a common misconception to extrapolate “wrapping” onto real-world assets tokenization and equate wrapped tokens to stable coins. This approach seems to bring unnecessary theoretical confusion in understanding the technologies that deal with the crypto interoperability problem. So let’s avoid messing it all up. The technology, processes, principles, and goals behind wrapped tokens are way too different from those of stable coins and tokenized assets. We are all soon-to-become crypto PHDs here, and such incorrect oversimplification of things is just not for us. 🧐 Why do we wrap tokens? So what’s exactly the point of going through the hassle of token wrapping? As we mentioned above, there is a substantial practical value in it. In short, it is a great way to make your assets more liquid. Let’s take it apart here. It’s no secret that . They are also isolated from each other. Cryptocurrencies cannot just “jump” from one chain to another. blockchains are entirely isolated from the external world Wrapping helps enhance the utility of a token and makes it applicable in more ecosystems and networks that are originally non-native. In other words, wrapping brings new use cases for your token outside of its original scope and therefore creates more revenue-generating potential. So a wrapped token is a kind of “tuned” version of your original crypto asset. For example, a significant amount of the DeFI ecosystem runs on the Ethereum blockchain. Therefore, it can be rather frustrating for bitcoin users, as they do not have access to these DeFi applications. By wrapping their Bitcoins into WBTC, users can easily tap this ecosystem and its applications. Also, since the liquidity of BTC is far greater than other blockchains, wrapping BTC converts this liquidity to Ethereum. With the help of wrapping, we would be able to lend our BTC out through smart contracts on DeFi platforms and earn interest on it. We can also deposit it into liquidity pools to facilitate crypto trading. Summing up Wrapped tokens help increase crypto liquidity and capital efficiency due to the facility to move the assets across multiple chains that would remain isolated otherwise. How do you wrap a crypto token? To wrap a crypto token, you deposit and lock your original tokens with a particular vault and get their crypto copies in return on another blockchain. However, as it always happens in crypto, there are multiple nuances and ways of doing it. Every particular project dealing with wrapping brings its own methods and techniques. You might be asking: We wrap because we want to beat the fragmentation problem in crypto and make it more unified and easy to use. But once again, we end up with multiple approaches and techniques that just add even more confusion! why again multiply entities here?! Well, fair point 👌 The thing is that wrapping is a pretty challenging task. Minting a copy of a token on another blockchain is not an issue. The real challenge comes from making that new-minted copy as accepted as the original token. This means coordinating several tasks simultaneously, such as: First, the value of the wrapped token must be the same as the original token, and the peg must be maintained over time. Second, the safety of the locked assets must be guaranteed, as well as the right to redeem the token at any time. Third, the wrapping of a token must be convenient and its utility greater than holding the original token in its native chain. So far, there are to provide these features: centralized, decentralized, hybrid, and synthetic. Let’s look at them closer. four main designs of the wrapping process This method relies on one or more trusted intermediaries — custodian and merchant — to maintain the wrapped token’s value. These guys are in charge of providing the so-called proof of assets (PoA). The PoA proves that the locked underlying assets are safely stored, not used in any other applications, and can be returned to a user at any time upon their “burn” request. (i) Centralized (custodial). The most used and accepted centralized wrapped token is Wrapped Bitcoin (WBTC) — . If a user wants to wrap their BTC into WBTC, they first need to reach out to the merchant (for example, Republic Protocol) and provide it with the collateral (i.e., BTC). Then the merchant will execute KYC, deliver the collateral to a custodian (for example, BitGo), request it to mint WBTC for a user, and then provide the user with these new-minted tokens. So in the wrapping process, a merchant acts as an intermediary between a user and a custodian. an ERC-20 token representing Bitcoin (BTC) on the Ethereum blockchain A user has to pay fees to both merchant and custodian each time they want their assets wrapped or unwrapped. This is why centralized wrapping solutions are more expensive than their alternatives. In this case, wrapped tokens minting is entirely automated and handled by a decentralized entity — a decentralized autonomous organization (DAO) that should always ensure a transparent and censorship-resistant proof of assets. The custody of tokens is solely managed by smart contracts without third-party intervention and KYC requests. (ii) Trustless (non-custodial). An example of a fully decentralized wrapped token is Wrapped Ether (WETH). This is actually the first wrapped token ever created. WETH is a token pegged to Ether (ETH), which is, however, not available outside of the Ethereum ecosystem. You might be wondering: what’s the point of wrapping ETH for harnessing it only on the ETH blockchain? Since decentralized platforms running on Ethereum use smart contracts to facilitate trades, every asset should conform to the same standardized format. This format is recognized as ERC-20. Since Ether was issued before the ERC-20 format, it is not suitable for DeFi smart contracts, and for this reason. Therefore its wrapped ERC-20 modification (i.e., WETH) was perceived as necessary. This method uses both a centralized entity and smart contracts to issue wrapped tokens. A centralized entity is usually required to perform KYC functions and ensure that the smart contracts are correctly executed. (iii) Hybrid. The best example of a hybrid wrapped token is RenBTC. Compared to centralized and trustless wraps, the most significant advantage of hybrid ones is that they might be interoperable upon multiple chains. Likewise, RenBTC can be available on BSC, Polygon, Solana, and Avalanche. However, hybrids are less accepted in DeFi protocols. Main DeFi projects such as Aave, Maker, and Compound do not support tokens wrapped on RenVM. Minting synthetic tokens slightly differs from the previous ones, as it does not require the lock of the original asset in a trusted vault or a smart contract. To mint a synthetic token, a user needs to lock assets of the equivalent value (or more) of the represented asset (e.g., lock USD 200 worth of SNX to mint sBTC of equivalent value). Intuitively, when users wish to burn synthetic tokens, they will not receive the represented token back but the provided assets instead. (iv) Synthetic. So as we see here, a synthetic token is conceptually different from a wrapped token, although it may have the same standard (ERC-20) and generally the same price. Unlike wrapped tokens, synthetics cannot be redeemed for the original token since no original token was locked to mint the synthetic version. However, the mechanism to issue a synthetic token, such as sBTC, is similar to wrapped tokens. This is why we give it here as an example, though their acceptance is pretty scarce. Here is the summary of the main technical differences between wrapped tokens types. Limitations and risks of wrapped tokens The main limitations of wraps arise out of the process of their minting. Reliance on a trusted third party As we discussed earlier, in the case of centralized solutions, a a third-party — custodian that is in charge of the user’s original assets’ safety. In the case of unwrapping, a user also strongly depends on the custodian’s discretion. The latter has to approve the user’s request to “burn” the wrapped tokens and return the original assets back. user has to trust Actually, the utilization of custodians is a very debated concept in the crypto space. As a matter of fact, the whole idea of decentralization and DeFi should involve the ability of users to have complete control of their assets without involving trusted third parties and without KYC requirements. However, custodians of crypto assets are obliged (through merchants) to request KYC from users depositing collateral. As centralized entities, custodial activity is subject to regulation and may also be ceased or censored. Thus acquiring a centralized wrapped token like WBTC means giving up the pseudonymity of BTC and its uncensorship features while operating under different security standards. If a bitcoin belonging to a black-listed user is frozen or censored by the custodian service upon request of the authority, its corresponding avatar would probably lose its value. Decentralized projects and some hybrid ones do not require KYC for wrapping. However, their terms and conditions usually state that the projects may change their requirements to comply with the applicable laws and regulations. Pricy The minting process of wraps is usually expensive. Each time wrapping and unwrapping, a user has to pay fees. Other cons of wrapping tokens Among other demerits of wrapping crypto tokens are: Wrapped tokens application is limited by particular ecosystems and networks, supporting them. As wrapping is a type of bridging, it carries the same risks. In particular, (i) Smart contract risk — the risk of a bug in the code that can cause user funds to be lost. (ii) Technology risk — software failure, buggy code, human error, spam, and malicious attacks can possibly disrupt user operations. (iii) Censorship risk — bridge operators can theoretically prevent users from transferring their assets for whatever reason. (iv) The underlying blockchain is hacked. This is not to scare or prevent you from using wrapped tokens. It’s just useful when making an investment decision — to have a comprehensive picture of what you are dealing with in mind. Fairly saying, if to look closer at traditional finance, one can find comparable amounts of risks of different nature, as in crypto. Nothing is 100% safe. Where there are opportunities, so too do risks exist. This is life. How does a user benefit from wrapped tokens? As we already discussed, the biggest value of wrapped tokens is that they create interoperability between non-compatible cryptocurrencies and blockchains. They enable users to use their assets in more blockchain networks and ecosystems, which means greater exposure to diverse revenue-generating streams. The particular set of perks offered by wrapped tokens can vary depending on the project. Some common ones include discounted access to a project’s services, rewards for professional help with improving an ecosystem’s functioning, and community building and evangelism incentives. Let’s take as an example. Yellow Network Yellow Network is a Web3 finance ecosystem that interconnects multiple stand-alone crypto exchanges in one automated non-custodial trading hub. Yellow provides a user with the aggregated crypto liquidity and infrastructure for seamless high-speed cross-chain transactions at minimal fees. In the ecosystem of Yellow Network, along with the access to diverse crypto assets, wrapped tokens are also used for: getting discounts on trading fees creating liquidity pools and staking opening a state channel and getting access to the aggregated order book incentivizing developers for contributing to the Network’s functionality improvement rewarding human talent for content creation, influencing activities, etc. The complete list of the $YELLOW tokens’ perks is given on . Yellow Network website So as we see, the benefits of wrapped tokens can go far beyond just transactional. The sky’s the limit to how they could benefit users and the crypto industry as a whole. Want to learn more about Yellow Network and cross-chain trading technology? Check out OpenDAX v4 stack GitHub: https://github.com/openware/opendax Follow Yellow Twitter: https://twitter.com/Yellow Join the public Yellow Network Telegram: https://t.me/yellow_org Read Yellow Network Medium blog: https://medium.com/yellow-blog Stay tuned as Yellow Network unveils the developer tools behind Yellow Network, brokerage nodes stack, and community liquidity mining software!

Crossing Chains With Wrapped Tokens

Eventually, all projects end up with a need to speed up service responses or some heavy calculations. The fast and easy solution is to use cache. Usually, there is Redis or Memcached but we don’t really need them in single instance microservices. Sometimes it’s better to use a simple in-memory cache in your Go app and today I want to show you the main ways to implement it. Simple map The first way is a simple explicit implementation of cache. Usually, it uses map and stores structs there. Also, there is a need to watch the expirations of keys and the cache size. I put all the implementations in . a GitHub repository package go_cache

import (
	"errors"
	"sync"
	"time"
)

type user struct {
	Id    int64  `json:"id"`
	Email string `json:"email"`
}

type cachedUser struct {
	user
	expireAtTimestamp int64
}

type localCache struct {
	stop chan struct{}

	wg    sync.WaitGroup
	mu    sync.RWMutex
	users map[int64]cachedUser
}

func newLocalCache(cleanupInterval time.Duration) *localCache {
	lc := &localCache{
		users: make(map[int64]cachedUser),
		stop:  make(chan struct{}),
	}

	lc.wg.Add(1)
	go func(cleanupInterval time.Duration) {
		defer lc.wg.Done()
		lc.cleanupLoop(cleanupInterval)
	}(cleanupInterval)

	return lc
}

func (lc *localCache) cleanupLoop(interval time.Duration) {
	t := time.NewTicker(interval)
	defer t.Stop()

	for {
		select {
		case <-lc.stop:
			return
		case <-t.C:
			lc.mu.Lock()
			for uid, cu := range lc.users {
				if cu.expireAtTimestamp <= time.Now().Unix() {
					delete(lc.users, uid)
				}
			}
			lc.mu.Unlock()
		}
	}
}

func (lc *localCache) stopCleanup() {
	close(lc.stop)
	lc.wg.Wait()
}

func (lc *localCache) update(u user, expireAtTimestamp int64) {
	lc.mu.Lock()
	defer lc.mu.Unlock()

	lc.users[u.Id] = cachedUser{
		user:              u,
		expireAtTimestamp: expireAtTimestamp,
	}
}

var (
	errUserNotInCache = errors.New("the user isn't in cache")
)

func (lc *localCache) read(id int64) (user, error) {
	lc.mu.RLock()
	defer lc.mu.RUnlock()

	cu, ok := lc.users[id]
	if !ok {
		return user{}, errUserNotInCache
	}

	return cu.user, nil
}

func (lc *localCache) delete(id int64) {
	lc.mu.Lock()
	defer lc.mu.Unlock()

	delete(lc.users, id)
} We use a user’s ID as the key of a cached item. Since there is a map, all updates/reads/deletes take O(1) time. Pros explicit implementation good performance Cons extra time to implement a cache for each data struct extra time to test the cache logic extra time to fix bugs gCache Library abstracts away the cache management and includes various configurations. For instance, you can simply set up the cache eviction rules, max size, expiration TTL, etc. The gCache library package go_cache

import (
	"errors"
	"fmt"
	"github.com/bluele/gcache"
	"time"
)

type gCache struct {
	users gcache.Cache
}

const (
	cacheSize = 1_000_000
	cacheTTL  = 1 * time.Hour // default expiration
)

func newGCache() *gCache {
	return &gCache{
		users: gcache.New(cacheSize).Expiration(cacheTTL).ARC().Build(),
	}
}

func (gc *gCache) update(u user, expireIn time.Duration) error {
	return gc.users.SetWithExpire(u.Id, u, expireIn)
}

func (gc *gCache) read(id int64) (user, error) {
	val, err := gc.users.Get(id)
	if err != nil {
		if errors.Is(err, gcache.KeyNotFoundError) {
			return user{}, errUserNotInCache
		}

		return user{}, fmt.Errorf("get: %w", err)
	}

	return val.(user), nil
}

func (gc *gCache) delete(id int64) {
	gc.users.Remove(id)
} Pros production-ready cache management single interface that works with any data type different cache eviction policies: LRU, LFU, ARC Cons need to manually cast a cache value on each read that leads to poor performance the library hasn’t been maintained for a while BigCache Library is fast, concurrent, evicting in-memory cache written to keep an enormous number of entries without impacting performance. BigCache holds entries on the heap but omits GC for them. BigCache library package go_cache

import (
	"encoding/json"
	"errors"
	"fmt"
	"github.com/allegro/bigcache"
	"strconv"
	"time"
)

type bigCache struct {
	users *bigcache.BigCache
}

func newBigCache() (*bigCache, error) {
	bCache, err := bigcache.NewBigCache(bigcache.Config{
		// number of shards (must be a power of 2)
		Shards: 1024,

		// time after which entry can be evicted
		LifeWindow: 1 * time.Hour,

		// Interval between removing expired entries (clean up).
		// If set to <= 0 then no action is performed.
		// Setting to < 1 second is counterproductive — bigcache has a one second resolution.
		CleanWindow: 5 * time.Minute,

		// rps * lifeWindow, used only in initial memory allocation
		MaxEntriesInWindow: 1000 * 10 * 60,

		// max entry size in bytes, used only in initial memory allocation
		MaxEntrySize: 500,

		// prints information about additional memory allocation
		Verbose: false,

		// cache will not allocate more memory than this limit, value in MB
		// if value is reached then the oldest entries can be overridden for the new ones
		// 0 value means no size limit
		HardMaxCacheSize: 256,

		// callback fired when the oldest entry is removed because of its expiration time or no space left
		// for the new entry, or because delete was called. A bitmask representing the reason will be returned.
		// Default value is nil which means no callback and it prevents from unwrapping the oldest entry.
		OnRemove: nil,

		// OnRemoveWithReason is a callback fired when the oldest entry is removed because of its expiration time or no space left
		// for the new entry, or because delete was called. A constant representing the reason will be passed through.
		// Default value is nil which means no callback and it prevents from unwrapping the oldest entry.
		// Ignored if OnRemove is specified.
		OnRemoveWithReason: nil,
	})
	if err != nil {
		return nil, fmt.Errorf("new big cache: %w", err)
	}

	return &bigCache{
		users: bCache,
	}, nil
}

func (bc *bigCache) update(u user) error {
	bs, err := json.Marshal(&u)
	if err != nil {
		return fmt.Errorf("marshal: %w", err)
	}

	return bc.users.Set(userKey(u.Id), bs)
}

func userKey(id int64) string {
	return strconv.FormatInt(id, 10)
}

func (bc *bigCache) read(id int64) (user, error) {
	bs, err := bc.users.Get(userKey(id))
	if err != nil {
		if errors.Is(err, bigcache.ErrEntryNotFound) {
			return user{}, errUserNotInCache
		}

		return user{}, fmt.Errorf("get: %w", err)
	}

	var u user
	err = json.Unmarshal(bs, &u)
	if err != nil {
		return user{}, fmt.Errorf("unmarshal: %w", err)
	}

	return u, nil
}

func (bc *bigCache) delete(id int64) {
	bc.users.Delete(userKey(id))
} We used JSON to encode/decode values, but there is an opportunity to use any data format. For instance, one of the binary formats — Protobuf, can boost performance significantly. Pros production-ready cache management the rich configuration of cache maintained the cache does not trigger GC, therefore excellent performance on big cache size Cons need to implement your encoder/decoder of values Benchmarks goos: darwin
goarch: amd64
pkg: go-cache
cpu: Intel(R) Core(TM) i5-8257U CPU @ 1.40GHz
Benchmark_bigCache
Benchmark_bigCache-8     	 1751281	       688.0 ns/op	     390 B/op	       6 allocs/op
Benchmark_gCache
Benchmark_gCache-8       	  772846	      1699 ns/op	     373 B/op	       8 allocs/op
Benchmark_localCache
Benchmark_localCache-8   	 1534795	       756.6 ns/op	     135 B/op	       0 allocs/op
PASS
ok  	go-cache	6.044s BigCache is the fastest cache. gCache loses in performance because of the need to cast values from interface{} Conclusion We researched different ways of in-memory cache in Golang. Remember that there is no best solution, and it depends from case to case. Use the article to compare the solutions and decide which one fits the needs of your project.

In-Memory Caching in Golang

Almacenamiento en caché en memoria en Golang

As blockchains flourish on their way to pollinating the world economy with the power of distributed ledgers, interoperability between networks becomes essential to sustaining this paradigm shift. Cross-chain trading is a challenge. Blockchains do not, in general, talk to each other very well - or at all - unless bridge mechanisms are implemented. As more value is created on different blockchains due to the various utility, security and operational capacities on offer, being able to trade across these gated economies creates a more inclusive space that fosters growth. You can liken it to the advent of globalization, when nation-states began to actively trade with one another, bringing propulsive economic growth in the 20th century. An interconnected world is a rich one, and the same is true for blockchain space. This article will dive deep into the technical processes used to move assets from one chain to another. How Custodial Exchanges Circumvent the Bridge Problem If blockchains can’t talk to each other easily due to their monolithic architecture, then how do such fluid asset swaps work on Binance, Coinbase and other CEXs? How come you can deposit ERC-20 USDT onto Binance and Withdraw BEP 20 USDT? Well, it’s due to the exchange functioning as something of a mirage about what’s really going on. In essence, sending your keys to an exchange is giving control of it to them, and they can choose what they are happy to honor out of their own asset pools reserve. It creates fluidity, but it comes at a cost; especially in terms of trading fees. There are also limits, just like a bank might restrict your withdrawal. If holding your assets on a centralized exchange, your asset is more fungible because it’s not your asset, it’s just another entity juggling its own position to accommodate your requests - with formal identification and KYC requirements for them to maintain your account. Clearly then, for the on-chain economy to mature, more efficient cross-chain communication needs to occur, to avoid innovation being stifled by simply a new set of gatekeepers. Wrapping Digital Assets Chief amongst the methods of inter-chain trading is the act of “wrapping” your cryptocurrency. Wrapping an asset essentially means exchanging the “true” version of the asset for a nominative token that represents it on a different chain. A simple example would be wrapped Bitcoin, or wBTC. wBTC is an ERC-20 token that can be deployed and traded in the Ethereum network. You can use it in DeFi protocols, swap it on DEXs like Uniswap, or lock it up as collateral for lending purposes. In all practical senses, your BTC asset is now live on Ethereum. Yet how do you get wBTC, or other wrapped tokens? Essentially, by giving a real BTC to a protocol or group like , wrapped wBTC is issued in exchange. The real BTC is locked inside with them while the wBTC plays in the green fields of the Ethereum ecosystem. BitGo that promises to keep it safe for you Bitcoin does not support smart contracts, so in this specific case, it is not locked within a smart contract as is the case with other compatible assets. Rather, it is kept by a custodian, and a smart contract is only used for the issuance and burn of ERC-20 compatible wBTC. Thus, after the wBTC has fulfilled its purpose, and if the original owner wants to regain his ‘locked’ BTC, a contract function is called, and the governing protocol now has to burn the wBTC and replace your BTC back in circulation. Of course, this comes with several risks, the main one being centralized control over the original BTC. The safer alternative here is to simply purchase wBTC without locking your own BTC. Under this method, the two tokens are never in circulation simultaneously, and therefore the integrity of the asset theoretically remains sound. How Wrapping Bridges are Secured MultiSig Wallets - The Not-So-Gold Standard Protocols that wrap BTC, and many other third-party custodial bridges like it that wrap other tokens, are governed by a multisig (multi-signature) wallet to increase security. These wallets require multiple cryptographic keys to open. Think of it like a bank vault that requires two or more keys to open. Usually, not every member of a network who is party to the wallet needs to provide a key for every transaction, but rather a set ratio, say 2/3rds. Once the requisite amount of keys have been input from the custodian, the funds can be moved. This has been, for a long time, one of the more secure methods of guaranteeing security over a pool of funds. Yet it has significant problems. One obvious one is that, should a large enough of the custodians seek to steal the funds, they simply can – as they have enough keys. The same is true if a hacker acquires enough keys to open the wallet. Another typical problem faced by multisig solutions is that sometimes keyholders can go the proverbial “AFK”, as users of the OKEx found out when one of its keyholders fell “out of touch”, leaving funds in limbo. As Vitalik Buterin commented in 2020, he hopes that “these wrapped BTC bridges are trusted” and that they can “at least move to a decently sized multisig” – implying that many of them are chronically undersecure. The issue with this, is that a more pervasive problem is that because each wallet or smart contract needs to have its number of keyholders and cryptographic access set up in advance, then it’s extremely difficult to adapt to new blockchain protocols as they arise. Therefore, multisig bridges, although they can be a decent protection of funds placed in a bridge, are still susceptible to the same issues as a standard centralized exchange, but also struggle to adapt to new blockchain protocols – as ground up cryptographic key distribution is required each time a new wrapping bridge is created. Wrapped BTC was all well and good when Bitcoin was the only cryptocurrency, and Ethereum the only smart contract platform. However, times have very much changed.  Hundreds of blockchains are now being deployed, with the inter-chain economy destined to witness exponential growth. SSSS Methods One workaround to this has been SSSS (Shamir Secret Sharing Schemes) cryptographic strategies. In this case, one private key is split into shares. These shares then need to be assembled to reconstruct it. Then, a single private key is created which can then access the protocol. This is significantly safer than multisig solutions, but has a problematic single point of failure – and that is the machine on which the final key is assembled, and the single turning of the lock (by a single, perhaps malicious entity) to activate the function. MPC - Benefits and Drawbacks MPC (multi-party computation) is a more recently developed cryptographic principle to combat some of these issues. MPC is a method whereby, rather than several private keys being necessary to activate a function, rather a single private key is subdivided into multiple parts that need to be assembled simultaneously (as opposed to SSSS which operates in a final state) in order for a contract’s function to be executed. Moreover, each party does not have to reveal its individual input. The idea has been around since the 1970s, and recently blockchain bridge protocols, like WAN, have begun using it. One excellent advantage of MPC is that it is ledger-agnostic, whereas multisig solutions are ledger dependent and tied to a single blockchain as keys need to be generated depending on the blockchain accessed. MPC is then able to be agile and adaptable as it is built on a . single standardised signature algorithm (ECDSA) While Multi Sigs need to be hardcoded, MPCs do not. MPCs also allow for privacy, as it’s not possible to determine which user is providing which part of the key, whereas in traditional multisig transactions, it is possible to determine which keyholders have supplied the code. Furthermore, Multisig transactions have one, or several, points of failure – the machines in which the keys are imputed. Having one part of a MPC key, however, is useless to any would-be attacker. Finally, MPCs are far faster to transact, as Multisig transactions need manual verification, or turning of the keys, by each responsible party. There is one massive drawback, however, and that’s accountability. MPC’s privacy is also an issue. Should a portion of the keyholders required in the transaction elect to collude and steal funds, it would be impossible to verify who of the pool was responsible for the attack. MPC, being so new, is also problematic by dint of that very newness. “Anyone, from the most clueless amateur to the best cryptographer, can create an algorithm he himself can’t break”, as . Scheiner said Losing Peg With Wrapping There is an emotional issue too. When you send a token to be wrapped, you no longer own the token either. You just own a facsimile of the token that can redeem the real one when required. Where this can lead to other problems when it comes to these tokens keeping their peg. If there is a sudden mass unwrapping of wrapped BTC, in the case of a prominent DeFi protocol dropping interest rates on it for example, then suddenly the value of wBTC within the Ethereum ecosystem can drop, and your wBTC token may lose its peg - although the unmooring is likely to be brief, as wBTC and BTC are still held at a 1:1 ratio and, save for total failure or hack of the bridge, your asset is secure. Yet there is still risk associated with the wrapping of assets which, when combined with its cost to do so, can stunt fluidity, speculation and “hot-money” moving effectively through the market. This friction is what mitigates some of the value of these assets being deployed effectively, and can act as a generalised collar on the growth of the market as a whole. Improving Cross-Chain Communication Custodial bridges, even legitimate and secure ones, have issues. There are other routes being taken to link up the blockchain economy, however. Let’s dive deeper! Cross-Chain Atomic Swaps Atomic swaps are an excellent peer-to-peer method of exchanging cryptocurrencies that make use of to work. These are smart contracts that do not allow trades to complete until both parties verify that it has occurred. If the verification does not complete, then the assets are returned to their original owners. The time frame is fixed, and immutable, and guarantees that trades can complete. Because you are swapping assets directly for one another – then all assets can be swapped at whatever price is agreed in the contract, and there is no need for complex multi-pair transactions to get the asset you want in exchange for the asset you have. Hash Timelock Contracts (HTLC) So far, so good – but what’s the issue? Well, each HTLC needs to be set up individually between two parties every single time. Although atomic swaps offer a great chance to trade assets interchain, this necessity to look for a single counterparty every single time, and set up a contract governing the trade, makes them obscenely cumbersome for most cryptocurrency trades. Layer 2 Asset Transfers with ZK Rollups (for Ethereum) Layer 2 refers to the suite of solutions designed to help scale apps by doing transactions off the main layer of the Ethereum. These off-chain aggregators, such as Polygun, Arbitrum and Optimism, maintain a transactions record of asset-transfers and then bundle them up and send them to the main chain for verification. With ZK Rollups, as only a single cryptographic proof is required (called a SNARK) to validate all the transfers on the Layer 2, then it allows for significantly greater volume of cross-chain transfers to be enacted and processed in one fell swoop. The issue is, of course, that despite the ability to transfer assets across many smaller blockchains and sidechains using this method, they are still exclusively built for the Ethereum umbrella – which means ultimately asset transfers will run into the same problems. Solana’s Wormhole Solana’s wormhole is similar to a classic Mint and Burn protocol bridge. The difference between the wormhole and other asset bridges is that, rather than having its own governance inside the protocol, the bridge is overseen by “guardians” who borrow authority from Solana main chain to transfer assets cross-chain. In short, Solana nodes pick up the slack of validating consensus but also have to act as the guarantors of that trust, so this method is reliant on Solana’s continued promise as an emerging blockchain and on their ability to scale up and run out bridges between them and every other blockchain they wish to connect. Sidechains A sidechain bridge is one where, instead of connecting two completely different blockchains, connects just one blockchain to a designated parent bridge. For example, that helped the main AXS chain communicate fast enough with Ethereum for the game to work as intended. Axie Infinity created a sidechain called Ronin works by creating secondary chains or parachains that have specific use-cases depending on the type of interoperable bridge needed between two blockchains. These parachains are these overseen by the central Polkadot relay chain that acts as the validator for all actions that are occurring on these parachains. It’s an ambitious model, but Polkdadot’s generic bridge to allow all chains to connect is still being worked on. Polkadot Intermediary Asset Swaps Some projects have opted for continuous lending pools, where to exchange one asset to another, you require a third token serving as intermediary. Under this model, to swap token A for token B cross-chain, A will be swapped for C (the intermediary asset), then C will be swapped for B. Under this non-custodial and decentralized framework, swaps require wallets associated with multiple blockchains, but there are some concerns surrounding the additional friction of having to conduct two swaps in the back-end for a single swap that reflects in users’ wallets. One example of this model is THORChain. Built using the Cosmos SDK, , RUNE, to help facilitate asset swaps between any other two tokens using an AMM model. THORChain uses its intermediary token The Cosmos Inter Blockchain Communication Network The most promising long-term solution to interoperability seems to be the creation of blockchains like Cosmos, whose express aim is to connect other blockchains together. This is a generic protocol that can be used by the majority of other blockchains regardless of the architecture or programming language they use. As long as a blockchain meets a few basic requirements, including having a module system, a key-value store, a consensus state introspection, timestamp access, a port system and an exception/rollback system, as well as eventual data availability – then they can connect to the IBC protocol. Cosmos uses a bespoke version of the IBC protocol. In . When it wants to communicate its data, it sends packets over the IBC, and Cosmos’s Hub maintains a multi-token ledger of token-balances of all connecting zones. Each zone must use a deterministic finality algorithm, such as the one provided by Tendermint, in order to use the Hub. Cosmos’s Tendermint model, each blockchain (or zone) maintains its own state and has its own validating community Cosmos Tendermint is Byzantine-Fault Tolerant. That means that it can tolerate 1/3rd of the machines within it failing completely, even through outright malicious behaviour. It also uses state machine replication, methodically updating the central state across its machines. This means computers from far flung corners of the globe operating on different programming languages and using their own application logic, can connect to its secure consensus algorithm through its application interface, the ABCI. Any distributed system, from currencies, voting systems and more can take advantage of its network. It is therefore an off-the-shelf, stable, working consensus engine for any blockchain software that does away with the problematic monolithic design that is used by popular blockchains like Ethereum. Building on Cosmos and plugging into the IBC, projects like are taking inter-chain communication a step further by creating their own bi-directional bridges with blockchains not currently supported by the IBC. Some of the announced blockchains to be supported include all IBC-enabled networks, as well as Ethereum, Avalanche, Near, Polkadot, Cardano, OKChain, Binance Smart Chain, and other EVM-compatible chains, with non-custodial key management available via a single wallet, rather than multiple browser extensions. As portrayed, this form of multi-dimensional support unlocks cross-chain trading free of intermediaries or wrapped asset counterparts, bolstering the cross-chain future of the DeFi realm. Onomy Protocol Interoperability - The Missing Link With the market no longer having a singular blockchain ecosystem that can single handedly serve all purposes and with the blockchain network constellation continuing to expand before our very eyes, all signs point towards a shared system of cosmic travel, able to sustain the transfer of significant volume between distant stars. Adoption resides in making true interoperability real, with the importance of intuitive user interface being just as powerful.

Blockchain Bridges: How Do They Even Work?

Blockchain networks depend on transaction fees in order to incentivize the nodes and miners that make the entire network operate. These transaction fees also serve to protect their networks against DDoS attacks by malicious hackers — it’s not so easy to cripple a network with an unmanageable burst of transaction activity if each transaction costs some amount of money. But there are certain ways to send transactions in Polkadot at a cost of zero dollars. Let’s discuss the cases where a zero-fee transaction makes sense, as well as how to actually implement them while protecting yourself against cyberattacks. Why would I want to send zero-fee transactions on Polkadot? There are two main instances where killing the transaction fee makes sense. First is for onboarding new users, second is for taking technical action to maintain the system’s business logic. When a new user already has tokens attributed to him and wants to claim them, they face the problem of not having an account from which to pay transaction fees. Whether those tokens were distributed via initial offering, lockdrop, or any other related mechanism, a zero-fee transaction solves the problem of delivering that user their token allocation. These kinds of transactions also serve some behind-the-scenes technical purposes, like determining staking reward distribution, for example. It’s critical that a DeFi system stays up to date by getting relevant prices from oracles and holding liquidation auctions that are held instantly. But these kinds of actions in standard blockchains are just ordinary transactions that require transaction fees. Someone has to pay these fees to support the system, and it can get quite expensive to keep prices current from many sources. It’s also not profitable to pay off the debt in auctions if the profit is less than the network’s transaction cost. Thankfully, substrate blockchains let us make these kinds of critical transactions for free, making the system cheaper and more stable for customers. So how do I actually do this while staying safe from DDoS attacks? Let’s get into the three types of no-fee transactions that exist, as well as cover how effectively they prevent cyberattacks. These transactions are the signed paid refund transaction, free signed transaction, and the unsigned transactions with a signed payload. Signed paid refund transactions This is probably the easiest way to implement free transactions. It’s best for those cases when an existing user wants to take a technical action without paying for it, like using the sudo pallet in the substrate repository. #[pallet::weight({
            let dispatch_info = call.get_dispatch_info();
            (dispatch_info.weight.saturating_add(10_000), dispatch_info.class)
        })]
        pub fn sudo(
            origin: OriginFor<T>,
            call: Box<<T as Config>::Call>,
        ) -> DispatchResultWithPostInfo {
            // This is a public call, so we ensure that the origin is some signed account.
            let sender = ensure_signed(origin)?;
            ensure!(sender == Self::key(), Error::<T>::RequireSudo);
 
            let res = call.dispatch_bypass_filter(frame_system::RawOrigin::Root.into());
            Self::deposit_event(Event::Sudid(res.map(|_| ()).map_err(|e| e.error)));
            // Sudo user does not pay a fee.
            Ok(Pays::No.into())
        } The main idea here is that a fee is actually taken from the user at the beginning of the transaction, but those funds are returned right back to them at the end of a successful transaction. This means only a potential attacker who sends invalid transactions will actually pay fees. Free signed transactions Consider the example of getting GENS tokens in exchange for locking EQ tokens in the network: Equilibrium #[pallet::weight((10_000 + T::DbWeight::get().writes(1), Pays::No))]
        pub fn claim(origin: OriginFor<T>) -> DispatchResultWithPostInfo {
            let who = ensure_signed(origin)?;
 
            Self::do_claim(who)?;
 
            Ok(().into())
        } This method of free transactions is suitable when the calling account is new and doesn’t have assets to pay for transaction fees. (This is usually a request to receive tokens for a new account.) Here the DDoS vulnerability is most noticeable — any newly generated account can saturate the entire block with its transactions without paying anything for them. To avoid this problem, we need to create a SignedExtension of the following type: pub struct CheckAllocation<T: Config + Send + Sync>(PhantomData<T>);
impl<T: Config + Send + Sync> SignedExtension for CheckAllocation<T>
where
    T::Call: IsSubType<Call<T>>,
{
    type AccountId = T::AccountId;
    type Call = T::Call;
    type AdditionalSigned = ();
    type Pre = ();
    const IDENTIFIER: &'static str = "CheckAllocation";
 
    fn additional_signed(&self) -> sp_std::result::Result<(), TransactionValidityError> {
        Ok(())
    }
 
    fn validate(
        &self,
        who: &Self::AccountId,
        call: &Self::Call,
        _info: &DispatchInfoOf<Self::Call>,
        _len: usize,
    ) -> TransactionValidity {
        match call.is_sub_type() {
            Some(Call::claim(..)) => {
                if !Allocations::<T>::contains_key(&who) || 
                    ClaimStart::<T>::get().is_none() {
                    InvalidTransaction::Call.into()
                } else {
                    Ok(Default::default())
                }
            }
            _ => Ok(Default::default())
        }
    }
} Now when a transaction is added to the transaction pool, the transaction’s validity gets checked. In our case, we check that the account indeed has an allocation. The validate method should contain exactly the same checks found in the runtime method itself. Other calls should be default — see the code above. Unsigned transactions with a signed payload This is the most flexible way to create free transactions, but it is also the most difficult to implement. Here’s how it works. The account sending the request may not have any funds, which is very convenient for technical nodes as there’s no danger of those funds being stolen. There is a possibility to optimally process technical actions independently of the sender. For example, it doesn't matter to us who sent the margin call request for the client's position. It is only important that the request is valid, and that there is exactly one request. If we used free signed transactions, then several margin calls for one client sent by different accounts could end up in the transaction pool. It is possible to arrange transactions in the desired order or priority. For example, we want all margin call transactions to be the first in the block. But each one of these opportunities comes with some potential risks and vulnerabilities. As with free signed transactions, it is important to duplicate all checks from runtime when validating a transaction. Because a transaction is not signed, then the nonces function is not available to us. We have to do the checks for "replaying" identical transactions and building the necessary transaction sequences ourselves. And if you make a mistake with your transaction prioritization, it is then possible to spam the entire transaction pool with only technical actions, clogging the rest of the functionality for everyone else. Let’s take a deeper look at our oracle implementation: impl<T: Config> frame_support::unsigned::ValidateUnsigned for Pallet<T> {
    type Call = Call<T>;
 
    fn validate_unsigned(_source: TransactionSource, call: &Self::Call) -> TransactionValidity {
        if let Call::set_price_unsigned(payload, signature) = call {
            let signature_valid =
                SignedPayload::<T>::verify::<T::AuthorityId>(payload, signature.clone());
            if !signature_valid {
                return InvalidTransaction::BadProof.into();
            }
 
            let current_block = <frame_system::Pallet<T>>::block_number();
 
            if payload.block_number > current_block {
                // transaction in future?
                return InvalidTransaction::Stale.into();
            } else if payload.block_number + 5u32.into() < current_block {
                // transaction was in pool for 5 blocks
                return InvalidTransaction::Stale.into();
            }
 
            let account = payload.public.clone().into_account();
 
            Self::validate_params(account, payload.asset, payload.price)
                .map_err(|_| InvalidTransaction::Call)?;
            
            let priority = T::UnsignedPriority::get()
                .saturating_add(
                    // BlockNumber is less than u64::MAX, so it is never default value on unwrapping
                    TryInto::<u64>::try_into(payload.block_number).unwrap_or(0)); 
 
            ValidTransaction::with_tag_prefix("EqPrice")
                .priority(priority)
                .and_provides((payload.public.clone(), payload.asset))
                .longevity(5) 
                .propagate(true)
                .build()
        } else {
            InvalidTransaction::Call.into()
        }
    }
} We need to ensure in the validation method that we allow unsigned transactions only for a single method, and immediately send an error to the rest. We also need to check that the signature is valid. This verification is necessary if the transaction is only allowed for certain types of accounts, like PoS or PoA systems. We allow transactions to live in the pool for no more than five blocks — after that, we determine that the price is outdated. This gets rid of cases where a transaction can be added to the pool an infinite number of times. (This check is not necessary if all other checks are performed correctly, but it is always better to double-check.) It is necessary to validate a transaction the same way it will be validated in runtime. In our case, all checks are moved to a separate method validate_params so that the checks are 100% identical.
Lastly, you need to configure tags and priorities. This is the biggest difference from previous implementations. In our case, we don’t want more than one transaction from one account for one currency in the pool. This is achieved by setting and_provides with unique values ​​for the pool (these parameters will have their own values for each pallet). We also want to take the latest price from transactions if there are several transactions within the pool with an identical and_provides property. We achieve this by setting the correct priority. In our case, the higher the block the transaction was included in, the higher its priority. Here’s the bottom line: you have to carefully think about the correct implementation for each pallet, which affects development time and increases the chances of making a mistake. This approach should be used only when the first two approaches described above fall short. Free transactions in Substrate are a powerful tool for maintaining system stability and onboarding new customers, but it is very important to choose the right way to implement them. Otherwise, one small mistake can leave you vulnerable to would-be DDoS attackers.

Zero-Cost Blockchain Transactions Are A Reality on Polkadot

Crypto exchanges evolution A few years ago, I used to have an account on the crypto exchanges such as . They were all hacked back then and none of them works anymore. Their user experience wasn’t great and as we know to this date, they had several security gaps that have been broken. „ancient“ Mt.Gox, Cryptopia or Cryptsy I also tried the first decentralized exchange . The user experience was horrible, the wrapping/unwrapping process was a tough one and lengthy loading was annoying. The crashes of the web interface were very frequent. IDEX worked on the order book principle, which turned out to be not ideal for a DEX because each bid and ask was updated into the blockchain and kept there. IDEX After the bull run in 2017, the industry evolved by a huge step, but still, compared to human evolution, it moved from infancy into adolescence. But from the last two years, I can feel that the exchange business really matured. New and new features took place both for centralized and decentralized exchanges. And from a user perspective…that matters! Centralized exchanges Let’s take a look at centralized exchanges first. What is a centralized system in comparison to decentralized exchange? What are its advantages? Centralized exchanges are trading platforms that function like traditional brokerage or stock markets. A CCE is owned and operated by a company that maintains total control over all transactions. Users of CCEs do not have access to the private keys of their exchange account’s wallets. This puts all of user’s trust in the hands of the exchange operators, as transactions can only be made through the mechanisms provided and approved by a central authority. Source: https://hacken.io/education/decentralized-and-centralized-exchanges-advantages-vs-disadvantages-aa9a27da4584/ The way centralized exchanges handle trades is the orderbook system, where buyers meet sellers and the matching engine of CEX connects those two together. Most of the well-known centralized exchanges improved their technology and added several functionalities. Simple exchanging of tokens is not enough to attract users nowadays. And it is good for the end-user and for the whole industry as well, because the newbie can be encouraged to use the exchange by its great UX and UI. Usually, CEXes allow users staking of their PoS coins, savings opportunity, margin trading or some trading functionalities such as stop-limit orders or trailing stop-loss and trailing take-profit. goes even further and offers their clients products such as Launchpool for receiving newly listed tokens or Launchpad, kind of IEO or listing of new coins. Crypto exchange did for their clients , similar to the upcoming with real crypto and real crowdloan rewards. Binance KuCoin a bidding simulation Kusama parachain auctions Free tokens, staking opportunities and lending are products that attract new users and they have their justification on the exchanges. Decentralized exchanges But let’s have a closer look at the comparison between decentralized exchange vs centralized exchange. DEXes went very popular last year, , did you know that?! even overtook Coinbase by the volume of trades Uniswap DEX is an alternative to CEX without a central point of failure, no company is in charge of the assets. In comparison with traditional CEX, the transactions and trades are automated by using smart contracts and decentralized applications. This way is much more secure because there is no possibility of a security breach if the smart contract is well written of course. Source https://www.soft-fx.com/blog/types-of-cryptocurrency-exchanges/ Two main ways to create a price on DEX are (automated market-maker) and . While the orderbook is mainly a tool of CEXes, because it matches buy and sell orders together, AMM serves DEXes very well, because it can manage huge financial volumes that fit into a relatively small number of transactions. AMM an orderbook But there are also problems with present solutions. Let’s have a look at the biggest DEX of today by volume. takes 2 coins and stocks them into one pool, while the price is automatically calculated. But when the liquidity of the 2 coins in the pool is low, there arises a slippage problem. Simply put, the large orders get filled at an inefficient rate. Uniswap One of the exchanges that prepares to run and solves the slippage problem is , which is based on Substrate and will run in the Polkadot ecosystem. HydraDX Frontrunning and flash-loans Two problems of today’s DEXes are frontrunning and flash-loans. Frontrunning can be made because of the mempool sorting of transactions on Ethereum. Because blockchain is open and transparent, some big transactions in mempool can be visible to sophisticated programmers or let’s say, speculators. They can frontrun the transaction/trade by using a higher network fee and enjoy the advantage of that kind of information. One of the newly built projects within the Polkadot ecosystem is , a DEX that will, later on, connect not just Polkadot world, but also Ethereum with all the ERC-based tokens. will have no network fees so there will be no user’s competition. And no-overtaking as well, that on Ethereum leads into absurd increases of gas fees. And because only DEX will run on Mangata Finance and no other kind of smart contracts, there won’t be possible to get attacked via flash-loans as well. Mangata Finance Mangata Mangata will be connected to the Polkadot network as a Parachain, so it will take advantage of its interoperability. Slippage Large orders can heavily affect the price of the asset being bought. Imagine you want to buy 100 ETH for 100,000 DAI — while the order executes, the price of ETH goes higher and higher and you can actually end up with only 80 ETH (or less) for your 100,000 DAI. This is simply how the algorithm works and it can easily cause a slippage even with small orders if the liquidity is low. Source: https://polkadotters.medium.com/hydradx-the-uniswap-killer-450da81dca5c is having dual pools (pools with 2 cryptocurrencies), so the slippage could be a big problem when the liquidity of those pairs is low. Kind of a solution is to have multiple pools, for example, uses up to 8 cryptocurrencies in the pool. Uniswap Balancer will solve the slippage problem in an innovative way that goes even further beyond the solution of Balancer. There will be just one single pool called the Omnipol, but this pool will serve all the assets in the exchange! Omnipol will have two sides. The first half will be filled by liquidity providers and various assets including DOT, KSM, DAI and others. The second half represents their base asset HDX and the 1:1 ratio will be kept algorithmically. More assets will be added during the time, the more HDX tokens will be minted and burned in the other way when the asset will be removed from the Omnipol. HydraDX Omnipol solves the slippage problem, because it will have enormous liquidity even for the huge orders. has one more tool to prevent slippage and that is order matching by the oracle. Because of that feature, asks and bids can be matched within the same block. HydraDX A new trend in crypto According to on-chain analysis, the new trend is obviously moving crypto from centralized exchanges such as or to DeFi protocols, where the crypto-assets can be used for lending or providing liquidity. Thus, they make a passive income or an additional profit to their cryptocurrencies. Glassnode's Binance Huobi Source https://insights.glassnode.com/content/images/size/w1600/2021/03/03_exchbal.png This trend of wrapping Bitcoin into smart contracts and using it in DeFi is obvious also from this chart from DeFi Llama, which indicates the increasing number of wrapped BTC into WBTC. In the last 50 days or so, the number of WBTC almost doubled! Source: https://defillama.com/protocol/wbtc Conclusion Centralized crypto exchanges aren’t unhackable. Handling decentralized protocols can’t be done without the possibility of human error leading to loss of funds or a bug in the smart contract. But still, the crypto exchange business evolved a lot since the Wild West of the last decade. Even when some funds might be stolen from a crypto exchange, the majority of them are well prepared for those kinds of unpredictable events and have some extra funds to cover the losses. CZ would tell you that “Funds are SAFU”. The application and features of both DEXes and CEXes make this field more attractive than it was before. And surely it is even more for those, who recently realized, that their dollar or euro isn’t preserved enough in the bank for 1% sitting on the savings account, while the inflation rate could reach 3%-10% with all those stimulus checks and liquidity injections. Improvements in user experience and interface both in centralized platforms and decentralized exchanges make me think that this is a good way for mass adoption in the near future. And I am glad to say that I see the exchange business finally matured. Used photos: Pixabay.com References: - - https://hacken.io/education/decentralized-and-centralized-exchanges-advantages-vs-disadvantages-aa9a27da4584/ https://www.soft-fx.com/blog/types-of-cryptocurrency-exchanges/ - https://polkadotters.medium.com/hydradx-the-uniswap-killer-450da81dca5c - https://insights.glassnode.com/content/images/size/w1600/2021/03/03_exchbal.png - https://defillama.com/protocol/wbtc

Evolution of Crypto-Exchanges From CEXs to DEXs: The Journey From Mt. Gox to Uniswap

It's no secret people love to collect: shoes, watches, cards, cars, tinder matches? In some cases, countries. This year, Covid turned some of us into toilet paper collectors. Nearly all of us have some kind of collection. Most notably for me growing up, were cards, Football, Pokémon, Digimon, Yu-Gi-Oh, Magic: the Gathering. Trading in the playground was a daily routine. Some of the earliest recorded collected cards were baseball cards found in cigarette packets! Intended initially for advertisement, smokers quickly began collecting them. Below is considered to be one of the rarest and most valuable baseball cards ever produced. It depicts Honus Wagner, one of the era's greats. The card was issued by American Tobacco Company from 1909 to 1911 as part of the T206 series. He refused further production, either because he wanted more compensation, or didn't want children buying cigarettes to access his card, I'd like to think the latter. The Resurgence of Pokémon Cards In the last 90 days, the world has seen a huge resurgence in interest in Pokémon cards. Perhaps because we're bored at home, or perhaps a mania led by influential YouTubers and Superstars, maybe a mix of both. Google Trends shows that just last week, we reached an almost 5-year high in worldwide interest in Pokémon Cards. Cards have made headlines, as YouTube and Music stars race to "open packs" on stream and on video - hoping for a valuable card. This drives further speculation, especially amongst young people, but adults are no strangers to collecting as we've explored above. The record for the most expensive Pokémon card to be auctioned, an Illustrator Pikachu, went for $233,000. It's a big part of all of our lives at some stage, it just evolves. Now we are witnessing a change in the way that we collect. Collecting is (slowly) going digital. Portals to New Worlds (VR)? Or Just Windows (AR)? With the evolution of technology we've seen many attempts to break through to Digital Collectibles. Digital Collectible was estimated as a$1.3bn market back in 2013. But they never really took off. People seem to prefer physical cards. But Digital Collectibles? Or 'Digibles' show more potential with the emergence of Augmented Reality. Card Games Augmented Reality (AR) collecting saw it's first real boom in 2017 when Pokémon Go, an AR collecting game took the world by storm. Reaching 60 million monthly users soon after launch in June 2017, 12 million of which were using the app daily. But numbers definitely dropped off slowly. A slow release of Pokémon meant it was hard or even impossible to fill your Pokédex, and you had to play consistently over a long time. As player numbers reduced, it became harder to find groups for "legendary raids" and therefore numbers fell more aggressively. The most popular region remains extremely active in the world of Pokémon Go - Asia Pacific. Seeing year on year growth since 2016, with over 310 million users at present. AR Collecting is alive and well, but Virtual Reality (VR) is lagging behind. Likely due to the fact VR is for the few rather than the many and we're very early in the technology. It's more immersive, but more expensive, and has a bigger learning curve. We'll dive more into VR later as we go down the technology rabbit hole. 'Digibles' in Deep Tech & Distributed Ledger Technology (DLT) Blockchains and other Distributed Ledger Technologies (DLTs) - like Ethereum - set precedent for a new way of collecting and also tracking digital assets, they offer tools to create scarcity, prove authenticity, and offer the foundations for fair and effective collecting systems, and as we move forward, systems too. displaying & sharing CryptoKitties are Ethereum based collectibles that you can breed. The below, named 'Dragon', sold for a record breaking $170,000, which, if you recall from earlier, isn't far off the the Illustrator Pikachu. Assets like CryptoKitties that are issued on a blockchain are paired with a token that represents the item's uniqueness. This token stores important data like history of ownership, also known as provenance. Traditional collectibles don't benefit from this. These particular tokens, and in the following case, Kitties, are called Non-Fungible Tokens (NFT's). CryptoKitties was likely an onset of the Bitcoin Mania and Cryptocurrency Bullrun of 2017, but we shouldn't ignore it. It had all the elements of a great collectibles game; a mix of chance & luck, and driven by a cost requirement. People love "unboxing" and "unwrapping" - and this is why breeding made the winning combo. Unfortunately for Cryptokitties, Ethereum just wasn't mature enough - and the barriers to entry into cryptocurrency are still covered with razorwire.  It was good for people comfortable paying a lot of money just to interact with Ethereum, and people who already understood cryptocurrency, but absolutely nobody else. As improvements are made to Ethereum, and onboarding and user experience becomes easier, we can expect another resurgence in CryptoKitties - but we're a way off. Horse Racing, Anyone? Zed Run is another notable collectible ecosystem that recently migrated to NEAR Protocol (a protocol similar to Ethereum, with much cheaper and faster transactions) to ensure that when users do come, they aren't put off by a clunky experience. Zed still sits into that niche crypto-collector community, but I do expect it'll have its upside one day. Zed allows the breeding and of digital horses. It's a game likely aimed at an older generation of players and gamblers alike, that offers large prize pools ($80,000 at the time of writing) and rare horse coats that can fetch tens of thousands of dollars, particularly during peaks in speculative cycles. racing Collecting 'on-chain' isn't just a fad. We've explored collectibles like cards today, but there are many other use cases for digital collectibles and NFT's. If you understand even at a very high level of how a blockchain works, and I did a half good job of explaining what an NFT is, you should now understand that merely copy and pasting an image of the famous CryptoKitty, Dragon, (or any other image) does absolutely not give you ownership... ...Just like reprinting the Illustrator Pikachu card doesn't mean you can sell it for $233,000. People love Scarcity. Certification. Clout. We explored that earlier, and it's at the heart of human history, since 12,000 years ago when we formed our first settlements, we've been collectors. With the parabolic growth and evolution of the internet, there are new ways to provably track, exchange and monitor both physical and digital assets. This is proved by industry leading auction houses that now use blockchain to verify provenance of luxury goods, like jewellery and art. And it sets precedent for more blurred lines between the real world and the digital world... The Evolution of Web and The Metaverse - And How Collecting Will Finally Go Digital Spaces Something that you should find interesting is the emergence of the Metaverse. all That's where you'll be collecting things soon, if you aren't already. The Metaverse is a collective virtual shared space, created by the convergence of virtually enhanced physical reality and physically persistent virtual space, including the sum of all virtual worlds, augmented reality, and the Internet. Nevermind websites, we're quickly entering a world full of . I wrote about that . "Fortnite, Animal Crossing, and the Metaverse." webspaces here Web spaces, areas that make up the open metaverse, can be any area of the internet we connect digitally that might resemble the real world, or encourage behaviour similar to the real world. In the article above, I used the example of Animal Crossing & Fortnite. These are areas of the metaverse because they allow human like interaction and encourage us to behave similarly to how we would in real life. You collect skins to show off, instead of clothes. Some webspaces are likely to replace websites - areas we can browse freely, and even purchase real & digital items while we do so. If you wrap in other areas of technology, like augmented and virtual reality, you create a really interesting way for people to connect with brands, artists, and eachother. A remarkably successful example of a digital webspace built on Blockchain technology is . The first ever world owned entirely by its users. When you buy land in Decentraland, you really do own it. The native currency to the virtual world is called MANA. A plot of land named "The Secret of Satoshis Tea Garden" was sold for over $80,000 equivalent in MANA tokens. Decentraland I hopped into Decentraland to explore, after heading over to the Museum District, I was naturally drawn toward this exhibition, for some reason. Decentraland is by any standard, a breathtaking example of decentralisation in action - owned by its users, and highly immersive, It shows great potential in the ability to buy and monetise a world through NFTs. After raising $24m for it's native Ethereum based token, MANA, back in 2017, it's had an impressive climb and built a cult like crypto userbase. It's extremely easy to log in and get started if you have a Metamask wallet (a web based wallet for interacting with the Ethereum blockchain) and very easy to move around in, but it feels overwhelming and lacks the tools to direct the users to the right place - but perhaps that's the idea? A vast, open, decentralised world to explore for the first time. Where it falls short, however, is that it feels massively ahead of its time. While I expect it has the ability to mature like a fine wine, particularly graphically, it just doesn't get the love or recognition it deserves. Decentraland is also yet to support VR, and is failing to draw the real user numbers it needs to hit the mainstream. Decentraland sits at that niche intersection between Virtual Reality and Blockchain, and will probably remain there, and there is nothing wrong with that. The Evolution of Augmented & Virtual Reality is right now at a turning point - and largely accelerated by Covid19. It's also complimented exceptionally by other areas of deep tech that we've explored, like Blockchains and NFTs. So where do all these concepts come together? Terra Virtua's Web Spaces offer some examples; a highly-immersive platform for Licensed Digital Collectibles. (beta) is a Mobile, PC, & Web based Platform & Ecosystem for Digital Collectibles that supports Virtual & Augmented Reality. They're not the first digital collectibles platform to use DLT, or NFTs, but the way they uniquely combine elements of collecting, trading, fandom and merch with unique webspaces makes the potential for them to emerge as the global standard of digital collectibles very possible. Terra Virtua The Ecosystem itself is made up of a number of areas. A marketplace for buying and selling licensed assets, an art gallery, "fancaves" (that resemble a house for displaying your collections), the Terradome (that resembles an exhibition centre)  and an AR mobile app that is not yet released. The Terra Virtua team exhibit a deep understanding of the emerging Metaverse and virtual shared spaces; they've bought together collect, share display, but in a way that funnels the users to the right environment. It also encourages mass market participation through standard dollar pricing models (rather than in cryptocurrency), and partnerships with big licensed brands. and Terra Virtua is built on Unreal Engine and operates in its current form as a Desktop Application. It feels smooth, offers a high definition viewing experience and feels like an immersive, first person game. The Marketplace is a little bare in its current state, particularly on the collectibles side. That said, there are plans to add many more digital collectibles, and that is demonstrated by the awarded partnerships and licenses. For me to really want to build collections in Terra Virtua, there need to be more assets that really resonate with me, and I expect this is the key to winning the mass market. One thing I did find, was a beautiful piece from , which I bought to display in my Terra Art Gallery (bottom right) Amrita Sethi The Art Gallery does what it intends. It feels (and sounds) like a real life gallery, minus the glass of champagne. Soon, you'll be able to go and visit other galleries, and in the not so distant future, I expect to be showcasing digital versions of their art in webspaces like Terra Virtua.  I'm looking forward to lending out this piece. real-world museums The Fancave (pictured above) looks and feels like a house. You can decorate it with assets purchased in the Marketplace, when I entered, a movie trailer for Top Gun was playing on the Television - likely an indication of some upcoming Top Gun collectibles and memorabilia, I was a little disappointed I couldn't go upstairs, but I am sure that will be added in the future. The Terradome is unique in that it's a much wider, open space, ideal for showing off your larger collectibles, that won't fit in the house (fancave). Think spaceships, aliens, and even sculptures. The AR mobile app isn't live yet, but I'll make sure I report back when I can use it. I expect it to work similarly to Pokémon Go in some respects, but replicable for any brand, artist or asset. A world where you can collect on the move, unlock discounts, even secret flash sales. The Fancave even had records on the wall, and I can't help but imagine myself rushing to buy a limited edition Kendrick Lamar album to play in the Metaverse. As the world moves more online, so do all elements of our day to day lives. From movies to music, the world, and our collections, are going digital. Now, you can even try shoes on in AR. How long before you can wear them in shared web spaces? , and I have no shortage of ideas on how it can scale. Terra Virtua feels like a unification of most of the technologies I've been exploring since I entered the DLT wormhole back in 2016 The trick, of course, will be educating the mass market to this emerging asset class, and doing so by speaking to that part of us that creates, collects, and shares with others. It's a tall order, but one I can get behind. Disclaimer: I am the owner of Pokémon Cards, CryptoKitties, Zed Horses, MANA tokens, and most recently a proud advisor to the Terra Virtua team.

Stories, News & Mentions about UNWRAPAI

Unwrapai’s Stories on HackerNoon