WeeConnect

weeconnect

Startups of The Year 2023 Winners: North America 

Social media usage is imperative for businesses to grow and stay competitive in today’s digital age. And when it comes to B2B marketing and sales, there’s no powerful social network than LinkedIn to make an impact, connect with your prospects, and boost your overall outreach. While you can use the traditional approaches to find leads on LinkedIn if you operate your business on a small scale, if you want to grow your business or are already operating on a large scale, it makes sense to use powerful and . best LinkedIn automation tools in 2021 These tools improve your productivity and efficiency while allowing you to focus on the most critical aspect of the sales funnel. Automation and Lead Generation Tools tools allow you to shed the redundant sales prospecting tasks off your shoulders. Growth in digital outreach signals an automatic increase in sales; therefore, having the best LinkedIn automation at your disposal can help our business take the leap forward. LinkedIn automation Automation tools provide you with the convenience to focus on other vital aspects of your work, such as interacting with potential clientele. The expenses involved in purchasing the best LinkedIn automation tools are very measly compared to the potential revenue they’re bound to generate. LinkedIn automation tools are designed differently. As such, it is essential to do your research before choosing a tool that suits your business needs. What is LinkedIn Automation? Get the Most With LinkedIn Autopilot LinkedIn automation means using tools to automatically send out connection requests, respond to messages, do endorsements, and more that you would otherwise be required to perform manually. These tools make LinkedIn prospecting and lead generation a breeze. Use the best LinkedIn automation software to put your lead generation and associated outreach campaigns on LinkedIn autopilot mode, which gives you the freedom to focus on other aspects of your business. Here’re some reasons why you must consider using Top LinkedIn automation tools They save time because manually searching for leads and sending connection requests is time-consuming They give your mass outreach campaign a personal touch, making your interactions seem more natural They generate reports for your outreach campaigns by tracking lead responses and conversions They make A/B testing easier, giving you more room to experiment with strategy, templates, etc. They integrate with other marketing and lead generation tools By making LinkedIn automation and marketing tools a part of your outreach, you can introduce an omnichannel approach to your marketing game. Best LinkedIn Automation Tools If you are new to LinkedIn automation platforms, finding a reliable tool can be challenging given the many different options out there. The good news is that we sliced and diced the top LinkedIn automation platforms to come up with a rundown of the 7 leading tools: Without further ado, let’s go straight to our list. 1. Octopus CRM If you’re looking for an inexpensive yet powerful and features-rich LinkedIn automation tool, has you covered. Octopus CRM Octopus CRM is a leading automation tool that helps you perform LinkedIn networking and prospecting with ease and in a secure environment. Using this tool, you can automate sending out bulk connection requests, viewing profiles, endorsing skills, sending personalized messages, and more. It allows you to build your own marketing funnel on LinkedIn by personalizing interactions with connections. Octopus CRM also allows you to monitor your outreach campaign by providing you with the relevant statistics and overall trends. On top of that, it helps you control your LinkedIn activity besides allowing Zapier and Hubspot integration. Moreover, Octopus CRM is compatible with all LinkedIn account types. Octopus CRM offers four different pricing packages. The starter package is priced at $6.99 per month, the pro package is $9.99 per month, and the advanced package costs $14.99 a month. Finally, the unlimited package comes at $24.9 per month if paid annually. 2. LinkedIn Sales Navigator is yet another excellent automation tool. It comes with an advanced lead and company searching feature that helps you find the right businesses and companies with more relevant prospects. LinkedIn Sales Navigator This automation tool also provides you with lead recommendations that help you discover the right people by customizing your suggestions. Moreover, LinkedIn Sales Navigator comes with advanced filtering, CRM integration, and more. It helps you automatically save the leads you are reaching out to, log any sales activities, add customized notes, and connect to your CRM. This automation tool is designed for B2B sales professionals who wish to gain access to advanced features to boost their productivity. If you want to increase your leads and enhance results, LinkedIn Sales Navigator has your back. But remember that it is best to get this tool only if you know your way around LinkedIn and wish to take things up a notch to obtain better outcomes. LinkedIn Sales Navigator comes with three pricing options. For professional users, LinkedIn Sales Navigator offers a package of $64.99 per month. Team user packages are charged at $103.33 per month. Finally, LinkedIn Sales Navigator brings you an Enterprise package that is completely customized as per your individual needs and is priced accordingly. While LinkedIn Sales Navigator may be on the pricier side of the spectrum, the tool pays for itself in the form of new leads and deals. If you wish to test the waters first, then try LinkedIn Sales Navigator’s month-long free trial that you can withdraw from at any time. 3. Expandi is one of the leading LinkedIn automation tools out there. Easy to set up and super convenient, Expandi features many standout features that contribute to its success and popularity. Expandi Expandi introduces webhooks, making it easier to link the tool with another marketing or LinkedIn lead generation tool, such as Zapier, to create a solid omnichannel approach with hyper-personalization. This automation tool comes with an intelligent inbox feature that helps manage your inbox with ease. Expandi’s smart inbox helps boost customer engagement and ensures that . none of your messages go unnoticed Also, Expandi’s dynamic personalization feature allows you to message people based on a custom variable beyond their first name and work affiliations. Unlike many other automation tools, this automation tool provides you with a local and dedicated IP address, thereby ensuring your business security. Most LinkedIn tools provide you with a different IP address with every log in, compromising your account safety. That’s not the case with Expandi. Expandi is an excellent LinkedIn tool for B2B sales professionals, agency owners, growth hackers, and people managing . It features a user-friendly dashboard that allows quick account switching, making LinkedIn account management super convenient and efficient. multiple LinkedIn accounts Priced at $99 per month, Expandi comes with a free week-long trial. 4. Dux-Soup is yet another popular LinkedIn automation tool out there. This tool makes connecting and engaging with prospects and leads much more effortless. It is also available in the form of a Chrome extension. Dux-Soup In order to ensure that the automation tool is running, you are required to have your LinkedIn open the whole time in your browser. Despite this minor drawback, Dux-Soup is a simple tool that is of particular help to new LinkedIn users. Dux-Soup’s primary focus is lead generation and outreach. The integrated automatic lead tools help you manage your prospects by automatically leaving tags and notes directly on the user profiles you wish to target and reach out to! You can also use this tool to download LinkedIn profile details and upload them to your CRM for easier lead management. Furthermore, you can use it to automate the process of finding LinkedIn profiles and sending connecting requests and personalized messages. What makes Dux-Soup particularly remarkable, however, is their super responsive customer support team. Dux-Soup is primarily designed for sales teams, but it also helps individuals who wish to work with an easy-to-use and user-friendly automation tool. The platform regularly publishes new guides to assist its users with automation management. While this tool does not offer many advanced outreach and safety features, it is a good platform for beginners who wish to try their hand at LinkedIn automation. Dux-Soup offers three pricing models depending on their service, namely free, professional at $11.25 per user per month, and turbo at $41.25 per user per month. 5. Phantombuster is a data extraction and code-free LinkedIn bot that helps you generate leads, effectively target your audiences, and automate growth. In fact, Phantombuster can automate most of your web actions, such as chain automation, task scheduling, and more. Phantombuster Phantombuster, as the name suggests, is based around phantoms that can perform automated actions and extract data. It is an excellent LinkedIn network booster that helps you connect with relevant LinkedIn users. Phantombuster also serves as a LinkedIn profile scraper that collects relevant data, including name, job title, position, and more, from a list of profiles. You can even use it to send personalized messages to your connections. This automation tool also facilitates engagement by automatically commenting and liking posts. Offering you a plethora of features and automation tips, Phantombuster works best when used with another LinkedIn automation tool of your choice. If you wish to explore new growth hacks and save your time searching for relevant profiles, Phantombuster can help you speed up the process and get you ahead of your competitors. Phantombuster can cost $30.00 per feature per month. The cost can go as high as $900 per month, depending on the features you choose. You can use this tool’s free trial to determine if it works for you. 6. WeConnect is a cloud-based LinkedIn automation tool that focuses on finding, cultivating, and finalizing more deals. WeConnect promises better user security as compared to other browser tools simply by being cloud-based. WeConnect This platform helps with a personalized approach. It serves as a powerful campaign manager that you can use to run multiple campaigns depending on your campaign preferences and target audience profiles. automate LinkedIn networking WeConnect also offers intelligent reply management that visualizes and interacts with potential connections. It helps discover new opportunities and endorse new skills as well. The user management of this tool is very friendly. It allows you to add more users to your account, track your LinkedIn campaign reports, and monitor everything conveniently using a single dashboard. This LinkedIn automation platform is best for everyone, including B2B salespersons, marketers, sales teams, and recruiters. Promising simple usability paired with a clean interface, WeConnect brings you an array of advanced features to supercharge your business growth. This tool is priced at $49 per month, and you pay as you go, depending on the number of users you are managing. 7. Zopto focuses on helping sales teams improve their lead generation efforts. It allows you to filter your target customers and conduct customized searches. It is a good tool for B2B sales professionals looking for automation tools to improve sales and conversions. Zopto The best part is that Zopto allows you to filter your customers by location, title, industry, company size, seniority level, and more. It also allows you to monitor your prospects’ desired level of engagement by customizing relevant features, such as invites, messages, etc. Zopto takes automation to the next level by allowing you to manage your leads by tracking them on your live dashboard. This live dashboard provides you with detailed stats and other information related to your LinkedIn outreach campaign. All in all, Zopto provides users with all the essential LinkedIn automation software features along with additional new features, such as advanced reporting, , Twitter engagement, etc. InMail messages This tool works best for startups and sales teams who wish to improve their lead generation and outreach game. Zopto offers three plans: Personal priced at $215 per month, Grow at $395 per month, and Agency at $895 per month. Best LinkedIn Automation Software: Parting Thoughts No matter what automation tool you opt for, it is critical to keep LinkedIn automation safety practices in mind. Your automation tool must be optimized not only for growth but also for security. And the platform you choose must meet your business needs and requirements. Do not subscribe to platforms only based on their popularity or ratings because what suits another business will not necessarily suit yours. It is all about generating results at the end of the day. Find a connect automation tool that is user-friendly, easy, and convenient if you are just getting started. Use our list to make your final selection.

7 LinkedIn Automation Tools for B2B Digital Marketers to Generate Leads

Unity Realtime Multiplayer, Part 2: TCP, UDP, WebSocket Protocols

ইউনিটি রিয়েলটাইম মাল্টিপ্লেয়ার, পার্ট 2: টিসিপি, ইউডিপি, ওয়েবসকেট প্রোটোকল

Unity Realtime Multiplayer, Teil 2: TCP-, UDP- und WebSocket-Protokolle

Multijugador en tiempo real de Unity, Parte 2: Protocolos TCP, UDP y WebSocket

Unity Realtime Multiplayer, partie 2 : TCP, UDP, protocoles WebSocket

यूनिटी रीयलटाइम मल्टीप्लेयर, भाग 2: टीसीपी, यूडीपी, वेबसॉकेट प्रोटोकॉल

Unity リアルタイム マルチプレイヤー、パート 2: TCP、UDP、WebSocket プロトコル

Unity 실시간 멀티플레이어, 2부: TCP, UDP, WebSocket 프로토콜

Unity Realtime Multiplayer, Parte 2: Protocolos TCP, UDP, WebSocket

Unity Gerçek Zamanlı Çok Oyunculu, Bölüm 2: TCP, UDP, WebSocket Protokolleri

Unity Realtime Multiplayer, Phần 2: Giao thức TCP, UDP, WebSocket

Unity 实时多人游戏，第 2 部分：TCP、UDP、WebSocket 协议

Implementing a Single Neuron in Python from Scratch In the last decade, Artificial Intelligence (AI) has stepped firmly into the public spotlight, in large part owing to advances in (ML) and Artificial Neural Networks (ANNs). Machine Learning But with promising new technologies comes a whole lot of buzz, and there is now an overwhelming amount of noise in the field. That’s why I thought it would be useful to get back to basics and actually using Python. implement a single neuron from scratch The Artificial Neuron Before we dive in, I just wanted to quickly talk about what a neuron in the first place. Early proponents of artificial intelligence noticed that the biological neuron was capable of conceptualizing and learning from large volumes of data, and postulated that modelling this neuron in a machine might allow for a similar capability.¹ To that end, the neuron was abstracted into a model of inputs, outputs, and weights. is Figure 1: Simple neuron model. In machine learning terminology, each input to the neuron (x1, x2, … xn) is known as a , and each feature is weighted with a number to represent the strength of that input (w1j, w2j, … wnj). The weighted sum of inputs (netj) then passes through an , whose general purpose is to model the “firing rate” of a biological neuron by converting the weighted sum into a new number according to a formula. Although we don’t need to go into the mechanics of the activation function just yet, here is some by for those who are curious. feature activation function reading material Avinash Sharma V So if that’s how a neuron , let’s look at how it . In simple terms, a neuron refers to iteratively updating the weights associated with each of its inputs so that it can progressively approximate the underlying relationship in the dataset it’s been given. Once properly trained, a neuron can be used to do things like correctly sort entirely new samples — say, images of cats and dogs — into separate buckets, just like people can. In machine learning terminology, this is known as . works learns training classification Training To train a simple classifier, let’s use the publicly available , which has the following properties: sklearn breast cancer dataset +---------------+-----+| Classes       |   2 |+---------------+-----+| Num Samples   | 569 |+---------------+-----+| Num Benign    | 357 |+---------------+-----+| Num Malignant | 212 |+---------------+-----+ Each sample in the dataset is an image of a breast mass that has been translated into a set of 30 numbers (features). Using a portion of samples to train our neuron, we will see if it is able to categorize the portion of breast masses as either malignant or benign. In other words, we need to perform a learning task, using explicitly labelled data points as teachers for the neuron to learn relevant patterns. unseen supervised To run and modify the below code below, check out the script here: single-layer-perceptron.py First we load the dataset and randomly shuffle the malignant and benign samples together while keeping each individual sample labelled. This is because we do not want our neuron to draw conclusions based on the order of samples it sees—only on the features of each individual sample. To train our neuron, we basically need to do three things: 1. Ask the neuron to classify a sample.2. Update the neuron’s weights based on how wrong the prediction is. 3. Repeat. Since a neuron is essentially just a collection of weights, we can use Python’s matrix manipulation package to randomly initialize a vector of weights.² The number of weights initialized corresponds to the number of features (inputs) to the neuron, as each feature is weighted before being summed. The activation is a static function, and so does not need a specific representation in software. numpy Forward Pass In the first step of training, we ask the neuron to make a prediction about the training samples. This is known as a , and it involves taking a weighted sum of the input features and passing that sum through the activation function. forward pass in the above code snippet is a matrix of features with the shape (n_samples * n_features). The weights representing our single neuron are of shape (n_features * 1). Therefore, a matrix multiplication between these two matrices will provide a weighted sum of all features for each sample. (If you try this out by hand, you’ll see it’s not as complicated as it sounds.) l0 When passed through an activation function, these weighted sums will effectively become class predictions for each training sample. The Sigmoid Function The function is a special case of the logistic function, and is chosen here as our activation function for a few reasons: it is , , and , with the following shape and definition: sigmoid easily differentiable non-linear bounded Figure 2: Sigmoid function shape. Figure 3: Sigmoid function definition. The function is implemented with a single line as follows: Conveniently, a standard logistic function has an of the form easily calculated derivative Figure 4: Derivative of a Sigmoid Function where f(x) represents the logistic function. As we will see shortly, this property is extremely useful when trying to minimize the error in our neuron’s predictions. The derivative of the sigmoid function is implemented as follows: Gradient Descent Now here comes the fun (and tricky) part — actually having our neuron learn the underlying relationship in the dataset. Now that we have bounded predictions for each of the training samples, we can calculate the / in these predictions and update our neuron weights proportional to this error. error loss We will use the for this weight update. In order to use this algorithm, we need an error function to represent the gap between our neuron’s predictions and ground truth. This error function is defined to be a scaled version of mean squared error (scaling makes differentiation easy). gradient descent optimization algorithm Figure 5: Mean-squared-error function. In code, this mean-squared-error function is implemented as follows: A gradient, in mathematics, is the derivative of a function that is dependent on more than one variable. Recall that vectors have both a magnitude and a direction. Our neuron’s error is dependent on all of the weights feeding into it. So, the gradient is the set of partial derivatives of error with respect of each of the weights. vector As a vector, the gradient points in the direction of the greatest rate of increase of a function. Moving in the opposite direction to the gradient, therefore, minimizes the function. Think of the error function as a surface with ridges and valleys. By descending opposite to the gradient, we are moving into the valley where error is lower. If we are able to calculate the gradient of the error function of our neuron relative to each of its weights, we can update the weights proportionally to minimize the error. Below is a simple derivation of the gradient of the error function using the chain rule. A more rigorous derivation can be found . here Figure 6: Partial derivative of error with respect to each neuron weight. Here, is the error function, is one particular weight, is the output of a neuron, and is the weighted sum of inputs to a neuron. Indices and correspond to the weight and the neuron, respectively. We will calculate each of the factors of the partial derivative separately. E wij oj netj i j The first factor is simple, and is the derivative of error with respect to the neuron’s output: Figure 7: Derivative of output error with respect to neuron output. The second factor is also straightforward, and is the derivative of the sigmoid function we described above in Figure 4. Figure 8: Derivative of neuron output with respect to the weighted sum. The third and final factor simplifies to equal the inputs to a particular neuron. Figure 9: Partial derivative of the weighted sum of inputs with respect to each weight. In Figure 9, is the vector of inputs to that neuron, which in our case are the features from our training set. oi Weight Update Rule Tying the partial derivatives we just saw together with descent gives us a rule for updating the weights representing our neuron: Figure 10: Weight update rule. Figure 10 shows that each weight will be updated in the negative direction of the gradient, proportional to an additional term, . A scaling factor, n determines how large a step we take when updating neuron weights, effectively controlling the rate at which the neuron learns. We call this the . n learning rate Implementing Weight Updates Below is the implementation of the gradient calculation and weight update for our single neuron. You can follow the comments to find each step of the derivatives required for the weight update rule. While training neural networks, the same training data is run through the many times, with each full pass being referred to as an . ( explains well why we use the same data many times with neural networks in .) With each epoch, the weights update further to try and lower the error. For our simple example, the number of epochs and the learning rate are selected through trial and error, observing mse loss decrease and converge. network epoch SAGAR SHARMA this post Results Figure 11: Training results. Figure 11 shows that over hundreds of epochs, loss decreases and accuracy increases on both training and test datasets. Next, we check if this training process is repeatable by training 10 different randomly initialized neurons on the same dataset. At the end of 10 training runs, average test accuracy is 90.49% (s=2.40%) and the average total accuracy is 90.33% (s=0.304%). If we had seen a large discrepancy in training and test accuracy, or if the test loss had increased while the training loss decreased, we would have reason to believe that the neuron was not learning the pattern hidden in the dataset. Although this level of validation is not nearly enough to put this neuron into a production environment, signs indicate that the neuron has learned a pattern in the dataset. Conclusion We looked here at the simplest form of an artificial neural network, namely one with a single neuron powered by gradient descent. Networks can be made of many neurons or other trainable filters/units, and use a variety of loss and activation functions based on their purpose. All of these extensions allow ANNs to perform a broad range of tasks such as object detection, language translation, time-series forecasting, and more. In our next post, we will explore the limitations of a single neuron and dig deeper into the flow of error backwards through a chain of neurons, or . The backward flow of error through a neural network is what allows a collection of neurons to converge on a solution together. Consequently, we will be able to pass much larger and much more complex datasets through our neural networks. layers Author’s Remarks I wanted to give a huge shoutout to , , , and for helping proofread and edit this article through multiple revisions. Eli Burnstein William Wen Guy Tonye Thomas Aston As always, leave comments and call out any mistakes you find here. I will work to fix them as quickly as possible! Footnotes , by Frank Rosenblatt. The Perceptron, A Perceiving and Recognizing Automaton In our very simple example, we centred the weights around a mean of zero. However, there are better ways to initialize weights for larger models. is a great introduction to best practices for weight initialization by . Here Neerja Doshi Dhruv is an AI Software Engineer at Connected Lab , a product development firm that works with clients to drive impact through software-powered products. www.connectedlab.com

A Hands-On Introduction to Neural Networks

The Open Home Lab Stack

Authors:
(1) Yuxin Meng;
(2) Feng Gao;
(3) Eric Rigall;
(4) Ran Dong;
(5) Junyu Dong;
(6) Qian Du. Table of Links Abstract and Intro
Background
Proposed Method
Experimental Results and Analysis
Conclusions and Future Work
References III. PROPOSED METHOD Numerical model can predict the spatial distribution of SST and its global teleconnections together. It performs well at short-leads for SST prediction. Nevertheless, we argue that transfer the physical knowledge from the observed data can further improve the performance of numerical model for SST prediction. To this end, we adopt GANs to learn the physical knowledge in the observed data. Zhu et al. [53] proposed a GAN inversion method that not only faithfully reconstructs the input data, but also ensures that the inverted latent code is semantically meaningful. They demonstrated that learning the pixel values of the target image alone is insufficient, and that the learned features are unable to represent the image at the semantic level. Inspired by this work, we design an encoder in GAN to learn physical knowledge from the observed data, referred to as the prior network. This prior network not only learns the pixel values of the target observed data, but also captures the physical information. It effectively improves the SST prediction accuracy. Next, we present the proposed method as follows: 1) Overview of the method, 2) Prior network, 3) SST prediction with enhanced data. A. Overview of the Method In this subsection, we summarize the proposed SST prediction method and describe the input and output of each stage in detail. As illustrated in Fig. 2, the proposed SST prediction method consists of two stages: Prior network training and SST prediction with enhanced data. 1) Prior network training. This stage consists of three steps. In the first step, the observed SST (GHRST data) is used for GAN model training. In the second step, the pretrained generator and GHRSST data are used to train the encoder. In the third step, the pretrained generator and encoder are combined into the prior network. The prior network is used to transfer the physical knowledge from the observed data to the numerical model. The numerical model SST (HYCOM data) is then fed into the prior network to enhance its feature representations. 2) SST prediction with enhanced data. The physics-enhanced data are fed into ConvLSTM model for SST prediction. The SST of the next day, next 3 days, and next 7 days are predicted separately. It should be noted that most existing works [26] [27] only use the observed data for ConvLSTM training. By contrast, our method takes advantage of physics-enhanced data for ConvLSTM training. Next, we describe prior network training and SST prediction with enhanced data in details. B. Stage 1: Prior Network Training We construct a prior network to learn the physical knowledge in the observed data and keep its semantic/physical information constant after training. As illustrated in Fig. 2, the prior network training is comprised of three steps: GAN model training, encoder training, and physics-enhanced data generation. Next we provide detailed descriptions of each step. GAN Model Training. The GAN model is used to learning the data distribution from the observed SST. The objective function is as follows: The training process of the GAN model is summarized in Algorithm 1. We train the model over the observed SST until the generator G captures the physical features from the observed SST data. where F(·) represents feature extraction via the VGG network. VGG network stands for the network proposed by Visual Geometry Group [54], and it is a classical deep convolutional neural network. The encoder training is described in Algorithm 2. The parameters of the generator G are fixed, while the parameters of encoder E and discriminator D are updated based on Eq. 2 and Eq. 3, respectively. The motivation of Stage 1 is to construct a prior network which can rectify the incorrect components in the numerical model data. To this end, we firstly devise a GAN model which captures the data distribution from the observed SST and can generate high-quality SST data. Subsequently, the encoder is trained to guarantee that the generated latent codes preserve the semantic/physical information in the observed SST. We argue that through adversarial learning, the prior network (consisting of the encoder and generator) can rectify the incorrect parts in the input data, since the physical knowledge has been embedded in the prior network. Consequently, in the third step, when the numerical model data are fed into the prior network, the embedded physical knowledge can correct the incorrect components in the numerical model data. C. Stage 2: SST Prediction with Enhanced Data ConvLSTM is an effective tool for predicting spatialtemporal data. It is a recurrent neural network that incorporates convolutional blocks in both the input-to-state and state-tostate transitions. Unlike the traditional LSTM layer, ConvLSTM not only preserves the sequential relationship but also extracts spatial features from the data. In this way, we can leverage it to capture robust spatial-temporal features. The objective function of ConvLSTM is formulated as follows: The physics-enhanced SST data are fed into the ConvLSTM model for SST prediction as follows: The weights obtained by the generator are reused in Algorithm 2, where only the generator weights are fixed. The introduced encoder and the discriminator go through another training process over the observed SST. Their weights are updated based on Eq. 2 and Eq. 3, respectively. After training, the code generated by the encoder would embody the learned physical knowledge. Finally, we acquire the data reinforced based on physical knowledge using the above pre-trained model. The weights of the generator and the encoder from Algorithm 2 are reused and the numerical model SST is exploited to produce physics-reinforced numerical model data. In Algorithm 3, the physical knowledge-enhanced data are leveraged to train a spatial-temporal ConvLSTM model for SST prediction. In this paper, the SST of the next day, the next 3 days and the next 7 days are predicted separately. For this part, we conducted an ablation study to make use of the reinforced data effectively. This paper is available on arxiv under CC 4.0 license. Authors: (1) Yuxin Meng; (2) Feng Gao; (3) Eric Rigall; (4) Ran Dong; (5) Junyu Dong; (6) Qian Du. Authors: Authors: (1) Yuxin Meng; (2) Feng Gao; (3) Eric Rigall; (4) Ran Dong; (5) Junyu Dong; (6) Qian Du. Table of Links Abstract and Intro Background Proposed Method Experimental Results and Analysis Conclusions and Future Work References Abstract and Intro Abstract and Intro Background Background Proposed Method Proposed Method Experimental Results and Analysis Experimental Results and Analysis Conclusions and Future Work Conclusions and Future Work References References III. PROPOSED METHOD Numerical model can predict the spatial distribution of SST and its global teleconnections together. It performs well at short-leads for SST prediction. Nevertheless, we argue that transfer the physical knowledge from the observed data can further improve the performance of numerical model for SST prediction. To this end, we adopt GANs to learn the physical knowledge in the observed data. Zhu et al. [53] proposed a GAN inversion method that not only faithfully reconstructs the input data, but also ensures that the inverted latent code is semantically meaningful. They demonstrated that learning the pixel values of the target image alone is insufficient, and that the learned features are unable to represent the image at the semantic level. Inspired by this work, we design an encoder in GAN to learn physical knowledge from the observed data, referred to as the prior network. This prior network not only learns the pixel values of the target observed data, but also captures the physical information. It effectively improves the SST prediction accuracy. et al. Next, we present the proposed method as follows: 1) Overview of the method, 2) Prior network, 3) SST prediction with enhanced data. A. Overview of the Method A. Overview of the Method In this subsection, we summarize the proposed SST prediction method and describe the input and output of each stage in detail. As illustrated in Fig. 2, the proposed SST prediction method consists of two stages: Prior network training and SST prediction with enhanced data. 1) Prior network training. This stage consists of three steps. In the first step, the observed SST (GHRST data) is used for GAN model training. In the second step, the pretrained generator and GHRSST data are used to train the encoder. In the third step, the pretrained generator and encoder are combined into the prior network. The prior network is used to transfer the physical knowledge from the observed data to the numerical model. The numerical model SST (HYCOM data) is then fed into the prior network to enhance its feature representations. 1) Prior network training. 2) SST prediction with enhanced data. The physics-enhanced data are fed into ConvLSTM model for SST prediction. The SST of the next day, next 3 days, and next 7 days are predicted separately. 2) SST prediction with enhanced data. It should be noted that most existing works [26] [27] only use the observed data for ConvLSTM training. By contrast, our method takes advantage of physics-enhanced data for ConvLSTM training. Next, we describe prior network training and SST prediction with enhanced data in details. B. Stage 1: Prior Network Training B. Stage 1: Prior Network Training We construct a prior network to learn the physical knowledge in the observed data and keep its semantic/physical information constant after training. As illustrated in Fig. 2, the prior network training is comprised of three steps: GAN model training, encoder training, and physics-enhanced data generation. Next we provide detailed descriptions of each step. GAN Model Training. The GAN model is used to learning the data distribution from the observed SST. The objective function is as follows: GAN Model Training. The training process of the GAN model is summarized in Algorithm 1. We train the model over the observed SST until the generator G captures the physical features from the observed SST data. where F(·) represents feature extraction via the VGG network. VGG network stands for the network proposed by Visual Geometry Group [54], and it is a classical deep convolutional neural network. The encoder training is described in Algorithm 2. The parameters of the generator G are fixed, while the parameters of encoder E and discriminator D are updated based on Eq. 2 and Eq. 3, respectively. The motivation of Stage 1 is to construct a prior network which can rectify the incorrect components in the numerical model data. To this end, we firstly devise a GAN model which captures the data distribution from the observed SST and can generate high-quality SST data. Subsequently, the encoder is trained to guarantee that the generated latent codes preserve the semantic/physical information in the observed SST. We argue that through adversarial learning, the prior network (consisting of the encoder and generator) can rectify the incorrect parts in the input data, since the physical knowledge has been embedded in the prior network. Consequently, in the third step, when the numerical model data are fed into the prior network, the embedded physical knowledge can correct the incorrect components in the numerical model data. C. Stage 2: SST Prediction with Enhanced Data C. Stage 2: SST Prediction with Enhanced Data ConvLSTM is an effective tool for predicting spatialtemporal data. It is a recurrent neural network that incorporates convolutional blocks in both the input-to-state and state-tostate transitions. Unlike the traditional LSTM layer, ConvLSTM not only preserves the sequential relationship but also extracts spatial features from the data. In this way, we can leverage it to capture robust spatial-temporal features. The objective function of ConvLSTM is formulated as follows: The physics-enhanced SST data are fed into the ConvLSTM model for SST prediction as follows: The weights obtained by the generator are reused in Algorithm 2, where only the generator weights are fixed. The introduced encoder and the discriminator go through another training process over the observed SST. Their weights are updated based on Eq. 2 and Eq. 3, respectively. After training, the code generated by the encoder would embody the learned physical knowledge. Finally, we acquire the data reinforced based on physical knowledge using the above pre-trained model. The weights of the generator and the encoder from Algorithm 2 are reused and the numerical model SST is exploited to produce physics-reinforced numerical model data. In Algorithm 3, the physical knowledge-enhanced data are leveraged to train a spatial-temporal ConvLSTM model for SST prediction. In this paper, the SST of the next day, the next 3 days and the next 7 days are predicted separately. For this part, we conducted an ablation study to make use of the reinforced data effectively. This paper is available on arxiv under CC 4.0 license. This paper is available on arxiv under CC 4.0 license. available on arxiv

Deep Neural Network for Sea Surface Temperature Prediction: Proposed Method

সমুদ্র পৃষ্ঠের তাপমাত্রা পূর্বাভাসের জন্য গভীর নিউরাল নেটওয়ার্ক: প্রস্তাবিত পদ্ধতি

Tiefes neuronales Netzwerk zur Vorhersage der Meeresoberflächentemperatur: Vorgeschlagene Methode

Red neuronal profunda para la predicción de la temperatura de la superficie del mar: método propuesto

Réseau neuronal profond pour la prévision de la température de la surface de la mer : méthode proposée

समुद्र सतह के तापमान की भविष्यवाणी के लिए डीप न्यूरल नेटवर्क: प्रस्तावित विधि

海面温度予測のためのディープニューラルネットワーク：提案手法

해수면 온도 예측을 위한 심층 신경망: 제안된 방법

Rede Neural Profunda para Previsão da Temperatura da Superfície do Mar: Método Proposto

Глубокая нейронная сеть для прогнозирования температуры поверхности моря: предлагаемый метод

Deniz Yüzeyi Sıcaklığı Tahmini için Derin Sinir Ağı: Önerilen Yöntem

Mạng lưới thần kinh sâu để dự đoán nhiệt độ bề mặt biển: Phương pháp đề xuất

用于海面温度预测的深度神经网络：提出的方法

How to Build DApp on Rootstock with Next.js, Typescript, and Solidity

In an ideal scenario, A Dapp should not have any backend server, everything should be on-chain. centralized Then why Backend? With a fully on-chain approach, we need to (at least right now) compromise on user experience Not everything needs to be on a chain, it just doesn’t make sense. Wouldn’t will it be great if we can make our apps sufficiently decentralized? There is a great By on Sufficient Decentralization which everyone should give read Article Varun Srinivasan Better scalability: A backend can help a Dapp scale more easily by handling tasks that might otherwise slow down the blockchain or consume a large amount of gas. Off-chain computation: Some tasks, such as image or video processing, can be resource-intensive and may not be practical to perform on the blockchain. A backend can handle these tasks and communicate with the Dapp as needed. For this or any reason you might need to have the backend connected to your Dapp, but how? let’s get started with it So, what are we building Deep? 👀 A Dapp which connects to your backend maintains a session and connects with the Database. Watch a demonstration . here What is SIWE (Sign-In with Ethereum)? Sign-In with Ethereum describes how Ethereum accounts to authenticate with off-chain services by signing a standard message format parameterized by scope, session details, and security mechanisms (e.g., a nonce). This specification aims to provide a self-custodied alternative to centralized identity providers, improve interoperability across off-chain services for Ethereum-based authentication, and provide wallet vendors with a consistent machine-readable message format to achieve enhanced user experiences and consent management. More details can be found . here Here are some steps we will be following Connect wallet Sign SIWE message with the nonce generated by the backend Verify the submitted SIWE message and signature via the POST request Add validated SIWE fields to the session (via JWT, cookie, etc.) Store user details(eg: name) in MongoDB Update user information Maintaining sessions b/w page refreshes Tools We are going to use: — Component library, of course, I hate CSS and I’m not going to write any of it NextUI — React Hooks for Ethereum Wagmi Iron Session Clone the code from the , to follow through GitHub repo Step1: Let’s create some API routes first under create a file nonce.ts with the following content pages/api pages/api/nonce.ts import { withIronSessionApiRoute } from 'iron-session/next'
import { sessionOptions } from 'lib/session'
import { NextApiRequest, NextApiResponse } from 'next'
import { generateNonce } from 'siwe'

const handler = async (req: NextApiRequest, res: NextApiResponse) => {
  const { method } = req
  switch (method) {
    case 'GET':
      req.session.nonce = generateNonce()
      await req.session.save()
      res.setHeader('Content-Type', 'text/plain')
      res.send(req.session.nonce)
      break
    default:
      res.setHeader('Allow', ['GET'])
      res.status(405).end(`Method ${method} Not Allowed`)
  }
}

export default withIronSessionApiRoute(handler, sessionOptions) Next, add an API route to verify a SIWE message and make the user session. pages/api/verify.ts import { handleLoginOrSignup } from 'core/services/user.service'
import { withIronSessionApiRoute } from 'iron-session/next'
import dbConnect from 'lib/dbConnect'
import { sessionOptions } from 'lib/session'
import { NextApiRequest, NextApiResponse } from 'next'
import { SiweMessage } from 'siwe'

const handler = async (req: NextApiRequest, res: NextApiResponse) => {
    const { method } = req
    switch (method) {
        case 'POST':
            try {
                await dbConnect();
                const { message, signature } = req.body
                const siweMessage = new SiweMessage(message)
                const fields = await siweMessage.validate(signature)

                if (fields.nonce !== req.session.nonce) {
                    return res.status(422).json({ message: 'Invalid nonce.' })
                }

                req.session.siwe = fields;
		// maintaining users details in MongoDB from below line
	        // we will get backto this later ignore for now
                const user = await handleLoginOrSignup(fields.address);
                req.session.user = user;
                await req.session.save()
                res.json({ ok: true })
            } catch (_error) {
                console.log('error -> verify', _error)
                res.json({ ok: false, error: _error })
            }
            break
        default:
            res.setHeader('Allow', ['POST'])
            res.status(405).end(`Method ${method} Not Allowed`)
    }
}

export default withIronSessionApiRoute(handler, sessionOptions) const { message, signature } = req.body
const siweMessage = new SiweMessage(message)
const fields = await siweMessage.validate(signature) We will be passing a message and signature done by the user's wallet from the Frontend, on the API side we are verifying it and the nonce, nonce will prevent the replay attacks. our iron session config file is going to look something like // this file is a wrapper with defaults to be used in both API routes and `getServerSideProps` functions
import type { IronSessionOptions } from "iron-session";
import { IUser } from "models/User";

export const sessionOptions: IronSessionOptions = {
  password: 'passowrd_cookie',
  cookieName: "iron-session/examples/next.js",
  cookieOptions: {
    secure: process.env.NODE_ENV === "production",
  },
};

// This is where we specify the typings of req.session.*
declare module "iron-session" {
  interface IronSessionData {
    siwe: any;
    nonce: any;
    user: IUser | undefined; // users details from DB
  }
} Now, let’s create an API for checking user’s sessions and returning users details if a user is already logged in Note: is a helper method that is getting user's details from MongoDB, you can check out the code from GitHub, to explore this helper method pages/api/me.ts findUserByAddress import { findUserByAddress } from 'core/services/user.service'
import { ReasonPhrases, StatusCodes } from 'http-status-codes'
import { withIronSessionApiRoute } from 'iron-session/next'
import { sessionOptions } from 'lib/session'
import { NextApiRequest, NextApiResponse } from 'next'

const handler = async (req: NextApiRequest, res: NextApiResponse) => {
  const { method } = req
  switch (method) {
    case 'GET':
      const address = req.session.siwe?.address
      if (address) {
        const user = await findUserByAddress(address)
        res.json({ address: req.session.siwe?.address, user })
        return
      }
      res.status(StatusCodes.UNAUTHORIZED).json({
        message: ReasonPhrases.UNAUTHORIZED,
      })
      break
    default:
      res.setHeader('Allow', ['GET'])
      res.status(405).end(`Method ${method} Not Allowed`)
  }
}

export default withIronSessionApiRoute(handler, sessionOptions) And lastly route, where we are destroying the session logout import { withIronSessionApiRoute } from 'iron-session/next'
import { sessionOptions } from 'lib/session'
import { NextApiRequest, NextApiResponse } from 'next'

const handler = async (req: NextApiRequest, res: NextApiResponse) => {
  const { method } = req
  switch (method) {
    case 'POST':
      await req.session.destroy()
      res.send({ ok: true })
      break
    default:
      res.setHeader('Allow', ['POST'])
      res.status(405).end(`Method ${method} Not Allowed`)
  }
}

export default withIronSessionApiRoute(handler, sessionOptions) Now, let’s create a state file for maintaining all user data and related methods we are going to use context API for this import { IUser } from 'models/User'
import React, { createContext, useContext, useState } from 'react'
import { SiweMessage } from 'siwe'
import { Connector, useAccount, useConnect } from 'wagmi'
import axios from 'axios'
import { useRouter } from 'next/router'
import { toast } from 'react-toastify'

export interface IUserState {
  user: IUser | undefined
  loadingUser: boolean
  setUser: React.Dispatch<React.SetStateAction<undefined>>
  handleSignOut: () => void
  handleSignIn: (connector: Connector) => Promise<void>
}

const UserContext = createContext<IUserState>({
  user: undefined,
  setUser: () => {},
  loadingUser: false,
  handleSignOut: () => {},
  handleSignIn: async () => {},
})

export function UserState({ children }: { children: JSX.Element }) {
  const router = useRouter()
  const [user, setUser] = useState(undefined)
  const [, connect] = useConnect()
  const [loadingUser, setLoadingUser] = useState(false)
  const [, disconnect] = useAccount({
    fetchEns: true,
  })

  const handleSignOut = async () => {
    disconnect()
    await axios.post('/api/logout')
    setUser(undefined)
    router.replace('/')
  }

  const handleSignIn = async (connector: Connector) => {
    try {
      const res = await connect(connector) // connect from useConnect
      if (!res.data) throw res.error ?? new Error('Something went wrong')

      setLoadingUser(true)
      const nonceRes = await axios('/api/nonce')
      const message = new SiweMessage({
        domain: window.location.host,
        address: res.data.account,
        statement: 'Sign in with Ethereum to the app.',
        uri: window.location.origin,
        version: '1',
        chainId: res.data.chain?.id,
        nonce: nonceRes.data,
      })

      const signer = await connector.getSigner()
      const signature = await signer.signMessage(message.prepareMessage())
      // console.log('message', message, { signature })
      await axios.post('/api/verify', {
        message,
        signature,
      })
      const me = await axios('/api/me')
      setUser(me.data.user)
      // It worked! User is signed in with Ethereum
    } catch (error) {
      // Do something with the error
      toast.error('Something went wrong!')
      handleSignOut()
      console.log('error', error)
    } finally {
      setLoadingUser(false)
    }
  }

  return (
    <UserContext.Provider
      value={{ user, setUser, handleSignOut, handleSignIn, loadingUser }}
    >
      {children}
    </UserContext.Provider>
  )
}

export function useUserContext() {
  return useContext(UserContext)
} Breaking down method handleSignIn const res = await connect(connector) // connect from useConnect
if (!res.data) throw res.error ?? new Error('Something went wrong') we are connected to the wallet here Once the user is connected we generate a random nonce using the API we created earlier const nonceRes = await axios('/api/nonce')
      const message = new SiweMessage({
        domain: window.location.host,
        address: res.data.account, // users waller address
        statement: 'Sign in with Ethereum to the app.',
        uri: window.location.origin,
        version: '1',
        chainId: res.data.chain?.id,
        nonce: nonceRes.data,
      })

const signer = await connector.getSigner()
const signature = await signer.signMessage(message.prepareMessage()) then we ask the user to sign a message, using constructor exposed by SIWE and creates a signature SiweMessage await axios.post('/api/verify', {
        message,
        signature,
      })
const me = await axios('/api/me')
setUser(me.data.user) Verifying users, and getting logged in user’s data using API we created earlier, then set the user's data to state me Now let’s make the API for updating user details in the Database, import withAuth from 'core/middleware/withAuth'
import { findUserById, updateUser } from 'core/services/user.service'
import { ReasonPhrases, StatusCodes } from 'http-status-codes'
import { withIronSessionApiRoute } from 'iron-session/next'
import { sessionOptions } from 'lib/session'
import { isValidObjectId } from 'mongoose'
import { NextApiRequest, NextApiResponse } from 'next'

const handler = async (req: NextApiRequest, res: NextApiResponse) => {
    const { method, query } = req
    const queryId = query.id;

    if (!queryId || !isValidObjectId(queryId)) {
        res.status(StatusCodes.BAD_REQUEST).json({
            message: "Valid id is required"
        })
        return;
    }
    switch (method) {
        case 'PUT':
            return await handlePatchUser();
        default:
            res.setHeader('Allow', ['PUT'])
            res.status(405).end(`Method ${method} Not Allowed`)
    };

    async function handlePatchUser() {
        if (req.session.user?._id !== queryId) {
            res.status(StatusCodes.FORBIDDEN).json({
                message: ReasonPhrases.FORBIDDEN
            });
            return;
        }
        const user = await updateUser(queryId, req.body);
        if (!user) {
            res.status(StatusCodes.BAD_REQUEST).json({
                message: "User not found with requested id"
            })
        }
        res.json({
            user
        })
    }
}

export default withIronSessionApiRoute(withAuth(handler), sessionOptions) Notice we are using here it is a we have created, so only authorized users can access our API routes withAuth middleware Link to code Now let’s create a profile in pages/profile.ts import type { NextPage } from 'next'
import Head from 'next/head'
import { BaseLayout } from 'components/ui/Layout/BaseLayout'
import { ComponentWithLayout } from '../_app'
import { useFormik } from 'formik'
import axios from 'axios'
import { useUserContext } from 'core/state/user.state'
import { useState } from 'react'
import { Button, Loading } from '@nextui-org/react'
import { toast } from 'react-toastify'

const Profile: NextPage = () => {
  const { user } = useUserContext()
  const [loading, setLoading] = useState(false)
  const formik = useFormik({
    enableReinitialize: true,
    initialValues: {
      ...user,
    },
    onSubmit: async (values) => {
      try {
        setLoading(true)
        await axios.put(`/api/users/${user?._id}`, values)
        toast.success('Data saved successfully')
      } catch (error: any) {
        toast.error(error.message)
      } finally {
        setLoading(false)
      }
    },
  })

  return (
    <div className="flex flex-col items-center justify-center py-2">
      <Head>
        <title>Profile</title>
        <link rel="icon" href="/favicon.ico" />
      </Head>
      <section className="bg-blueGray-100 rounded-b-10xl">
        <div className="container mx-auto px-4">
          <div className="-mx-4 flex flex-wrap">
            <div className="w-full px-4">
              <div className="mx-auto max-w-xl rounded-xl bg-white py-14 px-8 md:px-20 md:pt-16 md:pb-20">
                <h3 className="font-heading mb-12 text-4xl font-medium">
                  Profile Details
                </h3>
                <input
                  className="placeholder-darkBlueGray-400 mb-5 w-full rounded-xl border px-12 py-5 text-xl focus:bottom-2 focus:outline-none focus:ring-2 focus:ring-blue-500 focus:ring-opacity-50"
                  type="text"
                  placeholder="Your Name"
                  name="name"
                  onChange={formik.handleChange}
                  value={formik.values.name}
                />

                <div className="text-right">
                  <Button
                    clickable={!loading}
                    color="primary"
                    className="inline-block w-full  text-center text-xl font-medium tracking-tighter md:w-auto"
                    onClick={formik.submitForm}
                    size="lg"
                    icon={
                      loading && (
                        <Loading type="spinner" color="white" size="md" />
                      )
                    }
                  >
                    Save
                  </Button>
                </div>
              </div>
            </div>
          </div>
        </div>
      </section>
    </div>
  )
}

export default Profile
;(Profile as ComponentWithLayout).Layout = BaseLayout And that’s a wrap! Also published . here

A Step-by-Step Guide to Authenticating Users in Your DApp with 'Sign in with Ethereum'

Web3 represents an exciting chapter in the development of the internet. The primitives that the blockchain provides will lead to an infinite number of applications and use cases. We’ve seen the explosion of ICOs, DeFi, NFTs, and peer-to-peer payment systems. However, we still have a long way to go before reaching the mass adoption of this new technology. User experience is one area where things still lack. As web3 developers, how are we supposed to onboard the next wave of users when the average person doesn’t understand concepts such as non-custodial crypto wallets or signed transactions? This article will explore the issue and offer a solution to help create a better user experience. We’ll look at a real-world example of how we can use the to create a seamless onboarding experience for new users. Coinbase Wallet SDK Real-World Problems One of the concepts that is most intriguing in web3 is the intersection of healthcare and blockchain technology. HIPAA compliance means that patient records probably shouldn’t be put on a public blockchain. However, there are hundreds of other ways we can use the blockchain to revolutionize the healthcare sector. Healthcare Workers (HCW) have to spend in excess of six weeks being vetted and verified before working at any healthcare institution. The loss of time and income by hospital systems is huge. A trusted third party conducts certification verifications, background checks, et al. for weeks on end while an HCW isn’t paid, and the hospital system has to find a temporary worker to fill the gap. This is a problem that the blockchain can solve. With blockchain immutability, once a certification is verified, it never has to happen again. Web3 Solutions To solve this problem, I want to build a Certification Verification dapp called Health Verify (HV) that mints an NFT if a HCW certificate is successfully verified. There are many different paths this solution can take: to guarantee anonymity, using or as a schelling point for all verified certificates, and so on. ZK proofs Arweave Ceramic In my view, everything rises and falls on the quality of the onboarding for first-time crypto users. Since a user requires a wallet browser extension in order to interact with web3 applications, there should be considerations for someone unfamiliar with the technology. Just seeing a “Connect Wallet” button with little context can be an intimidating first impression, so we want to make things as smooth as possible. is one of the few wallets that offers an onboarding experience if the user doesn't already have a wallet extension installed. It makes sense to use this wallet because Coinbase is a trusted name in web3 and provides a secure on-ramp for new users while allowing existing users to easily connect to my dapp. Coinbase wallet For the rest of this article, we’ll focus on building the first part of the Health Verify dapp. We’ll create the onboarding page and integrate the Coinbase Wallet SDK to make it easy for users to either connect an existing wallet or create a new one. The Project So, let’s start pulling everything together. React is the library de jour when building dapps, my preferred libraries for Health Verify include: - ideal React framework for production Next.js - a collection of React Hooks containing everything you need to start working with Ethereum Wagmi Hooks - highly available Ethereum API Infura RPC provider - Coinbase Wallet SDK (formerly WalletLink) allows developers to connect their dapps to Coinbase Wallet on both mobile web (for iOS and Android) and desktop Coinbase Wallet SDK - a simple, modular, and accessible component library that gives you the building blocks you need to build your React application Chakra UI As for features, here is the scope of this article: Onboarding: Allows HCW to sign up if they don’t have a wallet. Verification: HCW selects from a list of supported certifications, submits some information, and then sends it to a server for manual verification. After verification is complete, an NFT is issued. For this article, we’ll just build a simple interface for the submission portion of this workflow, including the Coinbase Wallet onboarding flow. Implementation If you want to, you can view the codebase . Note: here Okay, BUIDL time! Next.js has been a darling of the React ecosystem since it came out. Personally, I enjoy not dealing with React Router, so it’s a go-to of mine when starting any React project. For Health Verify, we’ll start by installing Next.js and Chakra UI. I use Typescript in this article, but you can use Javascript and everything should be the same, sans all the typing boilerplate. Step 1: Install Next.js Go to your terminal and type the following command: npx create-next-app@latest --typescript Follow the prompts and enter an app name. If all goes well, then you should have a fresh Next.js install. Step 2: Install and Configure Chakra UI I’ve used a number of different UI libraries over the years, but I haven’t found anything that is as un-opinionated about UI element design while having such an amazing developer experience. Therefore, I highly recommend the Chakra UI library. Navigate to the project folder that you created in Step 1 in your terminal and run the following: yarn add @chakra-ui/react @emotion/react@^11 @emotion/styled@^11 framer-motion@^6 Import the Chakra UI provider, and add it to the file. At this stage, the should look as below: _app.tsx _app.tsx import type { AppProps } from "next/app"
import { ChakraProvider } from "@chakra-ui/react"

function MyApp({ Component, pageProps }: AppProps) {
    return (
        <ChakraProvider>
            <Component {...pageProps} />
        </ChakraProvider>
    );
}

export default MyApp; Step 3: Install Coinbase Wallet SDK and Wagmi Hooks Install the Coinbase Wallet SDK and Wagmi Hooks by running the following command: yarn add @coinbase/wallet-sdk wagmi ethers : Ethers is a Wagmi dependency. Note Step 4: Get an Infura ID Infura’s high availability API for Ethereum will help us get started with Health Verify. We are configuring a backup provider for the Coinbase Wallet to use for requests that won’t use the Injected Provider. This step is optional. You can follow guide to get up and running with an Infura project. this Once you have your Infura ID, edit the by adding the following key: .env.local REACT_APP_INFURA_ID=xxxxxxIDHERE******* Step 5: Configure Wagmi and Coinbase SDK We can achieve the integration between Coinbase Wallet SDK and Wagmi primarily via connectors. Connectors are wrappers for providers that can either be injected from custodial or non-custodial wallets. Wagmi has built-in support for Coinbase Wallet and that makes integration a piece of cake. Create a file in the root of the project and call it . This can be located anywhere really. I put mine in a folder at the root of the project. connectors.ts utils I choose to support Metamask as well for Health Verify as it helps with my testing and also provides an alternative for some users. Connectors.ts import { CoinbaseWalletConnector } from 'wagmi/connectors/coinbaseWallet'
import { MetaMaskConnector } from 'wagmi/connectors/metaMask'
import { chain } from 'wagmi'

const APP_NAME = 'Health Verify'
const APP_LOGO_URL = 'https://ethereum.org/static/a110735dade3f354a46fc2446cd52476/f3a29/eth-home-iconwebp'

export const connectors = [
    new CoinbaseWalletConnector({
        chains: [chain.mainnet],
        options: {
            appName: APP_NAME,
            appLogoURL: APP_LOGO_URL,
    }}),
    new MetaMaskConnector({
        chains: [chain.mainnet],
        options: {
            shimChainChangedDisconnect: false,
        },
    }),
] Step 6: Configure Wagmi Hooks I love the Wagmi Hooks library for its simplicity. All you need to do is wrap your app in the component and you can use React Hooks on your dapp. That’s it. For Health Verify, I have to edit in the following ways: WagmiConfig _app.tsx Import the Wagmi Hooks provider, , , and chain objects from the Wagmi library. You can read up on what they all do in the Wagmi documentation . createClient configureChains here Initialize a variable with your Infura ID that you created in Step 4. Use to create a provider. At this stage, you can also pass an array of supported chains. I’m using mainnet and polygon. Note: You can configure supported chains in the object you created in Step 5. configureChains Connector At the end of this step, your file should look like this: _app.tsx _app.tsx import type { AppProps } from 'next/app'
import { providers } from 'ethers'
import {ChakraProvider } from '@chakra-ui/react'
import { WagmiConfig, createClient, configureChains, chain } from 'wagmi'
import { connectors } from '../utils/connectors'
import { infuraProvider } from 'wagmi/providers/infura'

const infuraId = process.env.REACT_APP_INFURA_ID
const { provider } = configureChains(
    [chain.mainnet, chain.polygon],
    [infuraProvider({ infuraId })],
)

const client = createClient({
    connectors,
    provider,
})

function MyApp({ Component, pageProps }: AppProps) {
    return (
        <ChakraProvider>
            <WagmiConfig client={client}>
                <Component {...pageProps} />
            </WagmiConfig>
        </ChakraProvider>
    )
}

export default MyApp After this, you could fire up your Next.js instance by running . However, if you do, you’ll see the boilerplate Next.js home page. Let’s fix that. yarn dev Step 7: Connect Wallet Modal And now for the fun part. I won’t focus on the specific Chakra UI elements that I will use,  but I will bring attention to several cool Wagmi hooks that we need to use in order to build a dynamic UI that responds to the wallet connection status. - used to access the connected account. We can toggle UI states based on this binary value. useAccount - used to access the account using the configured connectors. useConnect For the Connect Wallet Modal, we are loading the connectors that we configured earlier and are showing the user the supported wallet options. It’s all coming together—wax on, wax off. SelectWalletModal.tsx import {
    VStack,
    HStack,
    Modal,
    ModalOverlay,
    ModalContent,
    ModalHeader,
    ModalBody,
    ModalCloseButton,
    Button,
    Text,
    Image,
} from '@chakra-ui/react'
import { useConnect } from 'wagmi'

export type SelectWalletModalProps = {
    isOpen: boolean;
    closeModal: () => coid;
}

export default function SelectWalletModal({
    isopen,
    closeModal,
}: SelectWalletModalProps) {
    const { data } = useConnect();
    const {
        activeConnector,
        connect,
        connectors,
        error,
        isConnecting,
        pendingConnector,
    } = uesConnect();

    return (
        <Modal isOpen={isOpen} onClose={closeModal} isCentered>
            <ModalOverlay />
            <ModalContent w='300px'>
                <ModalHeader>Select Wallet</ModalHeader>
                <ModalCloseButton
                    _focus={{
                        boxShadow: 'none',
                    }}
                />
                <ModalBody paddingBottom='1.5rem'>
                    <VStack>
                        {activateConnector && <div>Connected to {activeConnector.name}</div>}
                        {connectors.map((connector) => (
                            <Button
                                variant='outline'
                                key={connector.id}
                                disabled={!connector.ready}
                                onClick={() => {
                                    connect(connector);
                                    closeModal();
                                }}
                                w='100%'
                            >
                                <HStack w='100%' justifyContent='center'>
                                  <Image
                                    width={26}
                                    height={26}
                                    borderRadius="3px"
                                    src={walletIcons(connector.name)}
                                    alt={"Wallet"}
                                    ></Image>
                                  <Text>
                                    {connector.name}{" "}
                                    {isConnecting &&
                                    pendingConnector?.id === connector.id &&
                                    " (connecting)"}
                                   </Text>
                             </Button>
                        ))}
                        {error && <Text>(error.message)</Text>}
                    </VStack>
                </ModalBody>
            </ModalContent>
        </Modal>
    );
} Step 8: Home Page UI For Health Verify, my desired UX is that the user visits the home page, sees some copy, and a call-to-action that prompts the user to select a wallet. If they don’t have a wallet, then they can quickly and easily create one. The best part about using the Coinbase Wallet SDK is that if the user doesn’t have a wallet, he or she still gets a seamless onboarding experience and is green pilled. We have done a lot of the work already. so let’s bring it home by putting together a nice UI. index.tsx import {
    Flex,
    Box,
    Text,
    Button,
    Container,
    Heading,
    Stack,
    ListItem,
    UnorderedList,
    useDisclosure, } from '@chakra-ui/react'
import type { NextPage } from 'next'
import Head from 'next/head'

import { useAccount, useConnect } from 'wagmi'
import SelectWalletModal from '../components/SelectWalletModal'
import { Certifications } from '../components/certifications'

const Home: NextPage = () => {
    const { data: account } = useAccount()
    const { isOpen, onOpen, onClose } = useDisclosure()

    return (
        <>
            <Head>
                <title>Health Verify</title>
                <meta
                    name='Health Verify'
                    content='Health Verify remembers your certifications'
                />
                <link rel='icon' href='/facivon.ico' />
            </Head>
            <Flex alignItems='center' justifyContent='center'>
                {account ? <Certifications/> : (
                    <Container maxW={'3x1'}>
                        <Stack
                            as={Box}
                            textAlign={'center'}
                            spacing={{ base: 8, md: 14 }}
                            py={{ base: 20, md: 36 }}
                        >
                        <Heading
                            fontWeight={600}
                            fontSize={{ base: '2x1', sm: '4x1', md: '6x1' }}
                            lineHeight={'110%'}
                        >
                            Never verify your health certifications <br />
                            <Text as={'span'} color={'green.400'}>
                                AGAIN
                            </Text>
                        </Heading>
                        <Text fontSize={'2x1'}>
                            With Health Verify, you can easily verify your health certifications by following the steps below.
                        </Text>
                        <UnorderedList listStyleType='none'>
                            <ListItem>{`Click 'Start' to connect your wallet.`}</ListItem>
                <ListItem>{`If you don't have a wallet, create a Coinbase Wallet by selecting Coinbase Wallet`}</ListItem>
                            <ListItem>Select a certification to verify</ListItem>
                            <ListItem>Enter your Certification ID</ListItem>
                            <ListItem>
                                Wait for our team to verify your certification
                            </ListItem>
                        </UnorderedList>
                        <Stack
                            direction={'column'}
                            spacing={3}
                            align={'center'}
                            position={'relative'}
                        >
                            <Button
                                colorScheme={'green'}
                                bg={'green.400'}
                                rounded={'full'}
                                onClick={onOpen}
                                px={6}
                                _hover={{
                                    bg: 'green.500',
                                }}
                            >
                                Start
                            </Button>
                        </Stack>
                        </Stack>
                    </Container>
                )}
            </Flex>
            <SelectWalletModal isopen={isOpen} closeModal={onClose} />
        </>
    );
} Now, if you’re keen, you’ll notice that we only need one hook to make everything work smoothly. This is another reason why Wagmi is so awesome. We can get started with hooks really easily without writing tons of boilerplate for RPC or Contract interactions. Wagmi has many more hooks that I’d encourage anyone to check out. So, now that we have our UI, we can bring everything together. Let’s start the app and see what our rendered app looks like. If you have everything configured correctly, then your home page should look like the image below: When you click on “ ”, the following Connect Wallet modal should pop up: Start Select “ ” and if you configured everything correctly, it should show the Coinbase Wallet SDK “ ” dialog that allows a user to either sign up with their mobile phone or install Coinbase Wallet. Coinbase Wallet Install If the user selects " ", then they will be prompted to install the Coinbase Wallet browser extension and be guided through the final setup. This is exactly the user experience we want for users new to crypto. Now that we can onboard brand new users, we can continue to build out Health Verify. Install Conclusion Web3 introduces technology that will undoubtedly enhance many areas of our digital lives. We are only at the early stages of development, but already the use cases and applications are growing. However, in order to reach wider adoption, the user experience needs to improve. In this article, we reviewed how to build a dapp using Next.js, Typescript, Wagmi, and the Coinbase Wallet SDK. With a little configuration, we were able to deliver a great user experience to new crypto users. Now, we can build out Health Verify even further.

How to Onboard New Users With Coinbase Wallet

I was reading up on PostgreSQL when I noticed an interesting feature called . The documentation explains that logical replication is: logical replication A method of replicating data objects and their changes, based upon their replication identity (usually a primary key)“. In other words, it’s a way of ensuring copies of the database are always in sync by having the database publish logical data changes in real-time to subscriber nodes. A replication subscriber would typically be another database that is serving as a copy of the master, but it’s not limited to it and could be anything. What if we make that to be a web service? The service can then push those changes to multiple clients of a web application, so they can always have their data synchronized in real-time. There’s actually another PostgreSQL feature, the NOTIFY command, that is intended to generate notifications, but we will need to write database triggers for each table we’re interested in, and the string payload size has a limit of 8000 bytes. Logical replication has no such limit and can listen to all tables in the database, which makes it more scalable. So I wrote a small open-source library that combines with PostgreSQL logical replication. You can use it to build a web application with ASP.NET 5 that can react to all the inserts, updates, and deletes that any user of the app commits to a PostgreSQL database. dotNetify With this library that I named ( ), your project won’t involve polling the database, setting up a complicated pub/subsystem, or take much code at all. The rest of the blog will take you through building a demo app. DotNetify.Postgres source code PostgreSQL Setup To enable logical replication in your PostgreSQL database, find configuration file, change the parameter wal_level to logical, and both max_wal_senders and max_replication_slots to at least 1. Changes will take effect after the service restarts. postgresql.conf You can also change them with SQL commands: ALTER SYSTEM SET wal_level='logical';
ALTER SYSTEM SET max_wal_senders='10';
ALTER SYSTEM SET max_replication_slots='10'; The next step is to create a publication: CREATE PUBLICATION my_pub FOR ALL TABLES; We set it to publish data changes for all tables, but you can restrict it to just a specific table if you want. When PostgreSQL is publishing replication records (also known as write-ahead logs or WAL), it uses something called replication slots to ensure that the records do not get deleted until the subscribers receive them. Replication slots are great because they allow a subscriber to go temporarily offline and, on reconnect, to simply pick up where it left off. But there’s a caveat: the WAL records can pile up in a prolonged disconnection event, to the point that it can run out of space and crash the database, and therefore, the slots need to be monitored. Here’s how we create a replication slot: SELECT * FROM pg_create_logical_replication_slot('my_slot', 'pgoutput'); The is PostgreSQL’s standard logical decoding plugin for transforming the changes from WAL to the logical replication protocol. pgoutput For the demo, let’s create a simple table. We will also create a new user that will be used by our web service to connect to the database: CREATE TABLE IF NOT EXISTS businesses (
   business_id serial PRIMARY KEY,
   business_name VARCHAR ( 50 ) UNIQUE NOT NULL,
   rating integer
);

CREATE USER my_user WITH PASSWORD 'my_pwd';
ALTER ROLE my_user WITH REPLICATION;
GRANT ALL PRIVILEGES ON ALL TABLES IN SCHEMA public TO my_user;
GRANT USAGE, SELECT ON ALL SEQUENCES IN SCHEMA public TO my_user; Notice that we give the REPLICATION role to the user. Having this role is required for subscribing to replication slots. The Postgres database is now configured for logical replication. The next step is to create a web service to subscribe to the replication slot we’ve created and push the changes to the website. Web Service Setup . This is an project with a React/Typescript front-end and Webpack. After installing the npm packages, you can run the project from either Visual Studio or dotnet CLI. You can download the source code from this Github repo ASP.NET The code has an entity class for the demo table: [Table("businesses")]
public class Business
{
   [Column("business_id")]
   [Key]
   public long Id { get; set; }

   [Column("business_name")]
   public string Name { get; set; }

   [Column("rating")]
   public int Rating { get; set; }
} There’s a simple React client to display the content of the table and the associated dotNetify view model. The view model subscribes to the PostgreSQL data change events on the table through an API that the DotNetify.Postgres library provides and pushes state updates to the client in real-time: public class BusinessesVM : BaseVM
{
    private IDisposable _subs;

    // Real-time list; see: https://dotnetify.net/core/api/crud.
    [ItemKey(nameof(Business.Id))]
    public List<Business> Businesses { get; set; }

    public BusinessesVM(IDbChangeObserver dbChangeObserver)
    {
        Businesses = new List<Business>();
        _subs = dbChangeObserver
          .Observe<Business>()
          .Subscribe(e =>
          {
              if (e is DbInsertEvent<Business>)
              {
                var row = (e as DbInsertEvent<Business>).Row;
                this.AddList(nameof(Businesses), row);
              }
              else if (e is DbUpdateEvent<Business>)
              {
                var row = (e as DbUpdateEvent<Business>).NewRow;
                this.UpdateList(nameof(Businesses), row);
              }
              else if (e is DbDeleteEvent<Business>)
              {
                var key = (e as DbDeleteEvent<Business>).Row.Id;
                this.RemoveList(nameof(Businesses), key);
              }
              PushUpdates();
        });
    }
    public override void Dispose() => _subs.Dispose();
} The connection string to our PostgreSQL database, along with the publication and replication slot names, are configured in the service startup class: public void ConfigureServices(IServiceCollection services)
{
    services.AddSignalR();
    services.AddDotNetify();
    services.AddDotNetifyPostgres(new PostgresConfiguration
    {
      ConnectionString = Configuration.GetConnectionString("Postgres"),
      PublicationName = "my_pub",
      ReplicationSlotName = "my_slot"
    });
} And that’s all there is to it! Here’s how the app’s reacting to data changes: Full CRUD with EF Core So far, we have a web page that’s only reacting to data changes on the database. Let’s take it a step further and make it capable of CRUD operations as well. For this, we’re going to use EF Core with library. Npgsql Let’s add a DbContext class for our demo table: public class BusinessDbContext : DbContext
{
  public DbSet<Business> Businesses { get; set; }
  public BusinessDbContext(DbContextOptions<BusinessDbContext> options)
    : base(options) {}
} DotNetify view models must use a factory to create a new DbContext because of the long lifetimes. So we configure the DbContextFactory service in the startup class: public void ConfigureServices(IServiceCollection services)
{
  ...
  services.AddDbContextFactory<BusinessDbContext>(options =>
    options.UseNpgsql(Configuration.GetConnectionString("Postgres")));
} The last step is implementing CRUD methods on the view model: public class BusinessesVM : BaseVM
{
  private readonly IDbContextFactory<BusinessDbContext> _contextFactory;

  [ItemKey(nameof(Business.Id))]
  public List<Business> Businesses { get; set; }

  public BusinessesVM(
    IDbContextFactory<BusinessDbContext> dbContextFactory,
    IDbChangeObserver dbChangeObserver)
  {
      _contextFactory = dbContextFactory;

      using var dbContext = _contextFactory.CreateDbContext();
      Businesses = dbContext.Businesses.OrderBy(x => x.Id).ToList();

      this.ObserveList<Business>(nameof(Businesses), dbChangeObserver);
  }

  public void Add(Business businessInfo)
  {
      using var dbContext = _contextFactory.CreateDbContext();
      dbContext.Businesses.Add(businessInfo);
      dbContext.SaveChanges();
  }

  public void Update(Business businessInfo)
  {
      using var dbContext = _contextFactory.CreateDbContext();
      var business = dbContext.Businesses.Find(businessInfo.Id);
      if (business != null)
      {
        business.Name = businessInfo.Name;
        business.Rating = businessInfo.Rating;
        dbContext.SaveChanges();
      }
  }

  public void Remove(Business businessInfo)
  {
      using var dbContext = _contextFactory.CreateDbContext();
      var business = dbContext.Businesses.Find(businessInfo.Id);
      if (business != null)
      {
        dbContext.Businesses.Remove(business);
        dbContext.SaveChanges();
      }
  }
} As you may notice, the previous code that does the subscription and data change event handling are simplified into a single call to the extension method. ObserveList Here’s an excerpt of the React client that invokes those CRUD methods: export const Businesses = () => {
  const { vm, state } = useConnect<State>("BusinessesVM");
  const [newName, setNewName] = useState<string>("");

  const addBusiness = (name: string) => {
    vm.$dispatch({ Add: new Business(0, name) });
    setNewName("");
  };

  const updateBusiness = (id: number, name: string, rating: number) => {
    vm.$dispatch({ Update: new Business(id, name, rating) });
  };

  const removeBusiness = (id: number) => {
    vm.$dispatch({ Remove: new Business(id) });
  };
... And with that, here’s the demo of two browser instances of the app keeping in sync with each other while we apply some CRUD operations: I hope this is useful to you! I’d be interested to hear what you think. and let me know. And feel free to retweet! Reply to my tweet Also published . here

Logical Replication: Real-time Web Updates From Your PostgreSQL Database

Stories, News & Mentions about WEECONNECT

Weeconnect’s Stories on HackerNoon