Kadence

kadence

for your online store becomes a tad easier with efficient template customizers. Businesses will be able to provide better email personalization and communicate with customers effortlessly. Email marketing You might need an email template customizer for your WooCommerce website to welcome customers, inform them about products, advertise promotional offers, display available discounts, and much more. Several email template customizer plugins for websites can offer mail testing to show you how customers see your messages. Other customizers also provide options to select pre-designed templates for instant communication with subscribers. WooCommerce 20+ WooCommerce email template customer plugins are available, but some of these tools might not have the best features. That’s why this guide gives you vital details about nine (9) of the best WooCommerce customizer plugins, their main features, and everything else they have to offer. All the information below makes it easy to choose and install the perfect email template customer plugins for your WooCommerce website. 9 Best WooCommerce Email Template Customizer Plugins See all the essential information about the best WooCommerce email template customizers and everything else they have to provide. 1. YayMail offers a comprehensive email customizer plugin designed to feature at least twenty (20) blocks. These blocks help you customize different aspects of your e-commerce notifications for better communication with your customers. YayMail YayMail allows its users to change the font style, alignment, background color, and other vital elements of an email layout. This customization features ensure every email you put out represents your brand and its signature style. The plugin also comes with an efficient visual builder designed to assist newbies determined to build email layouts from scratch. You can take advantage of this feature to track changes, see real-time previews, and manage edits of your email design. Main Features of YayMail Multiple templates: Supports multiple WooCommerce templates with easy email layout creation Third-party extension support: Works with other Yay! add-ons and third-party plugins installed on your WooCommerce site Test email function: Comes with a test mail function designed to show you how your email looks at the customer end Simple drag-and-drop builder: Features an easy-to-use mail builder created to support first-time users and aid simple email layout building : Free plan available; paid version from $59 to $999 (4 plans available with one-off and annual payment options) YayMail Pricing 2. Omnisend supports users with comprehensive templates users can take advantage of to create efficient emails. The WooCommerce email template customer comes with an easy integrator designed to link up with your e-commerce website conveniently. Omnisend It also comes with a set of pre-installed workflows and designed templates. These built-in features ensure beginners and experienced owners of an e-commerce websites can design appealing emails with ease. Omnisend also comes with a simple email builder designed to allow users add their own branding and other features to emails. Users can conveniently include brand images, available store products, recommended purchases, and other customization settings to emails. The Omnisend WooCommerce email customizer also comes with a mobile-friendly template built to assist marketers keen to attract mobile users. Main Features of Omnisend A/B testing: Provides users with tools to create email layouts and see how the design appears at the customer end Video integration: Supports email layout builders with simple integration tools to add images and videos to bulk marketing mail Relevant product recommendation: Gives users enough support to display their best products in created emails Product listing support: Storeowners can take advantage of the plugin to display top product categories in sent emails : Free plan; the paid version available at $16 per month Omnisend Pricing 3. Kadence WooCommerce Email Designer is a popular WooCommerce email template customizer designed to make impressive email layouts for businesses. It allows customers to create custom, stylish layouts with pre-designed templates. Kadence The plugin also provides different options designed to make emails appeal to customers. Its pre-built email templates also come in handy for customers who want instant layouts to connect with customers. Kadence allows users to import pre-designed layouts in supported extensions. The feature ensures all users get the support required to create and customize email templates with ease. Main Features of Kadence WooCommerce Email Designer Simple import/export feature: Allows customers to transfer templates to and from the designer for easier customization Inbox testing: Provides users support with tools to test emails and visualize how they appear at the customer end Preview feature: Supports real-time previews of your email layout creation Multi-column layout: Allows designers to create catching emails with different designs on multiple columns; ideal for emails designed to contain many messages : Free version is available; the Paid version is available for $129 (first year) and then $149 for renewals Kadence WooCommerce Email Designer Pricing 4. MailPoet The WooCommerce email template customizer is designed to help users send curated messages to customers. The customizer plugin for WooCommerce emails allows subscribers access to a comprehensive set of pre-built emails. MailPoet You can take advantage of MailPoet to send specific emails like welcome notes, purchase notifications, periodic newsletters, promotional messages, and so on. MailPoet also comes with a mail delivery system designed to ensure your messages are not flagged as spam. Main Features of MailPoet Email segmentation: Allows users to send smart custom emails with an all-in-one template to send targeted messages; ideal for marketing campaigns with more than one customer base on their mailing list Comprehensive marketing support: Provides users with tools to create email templates with an all-inclusive design; ideal for marketers determined to reach a wider audience with information about available products Different pre-built email templates: Comes with pre-designed and stylish email templates for instant customization Customer-end mail testing: Users can test emails to see how they appear on the customer side : Free starter plan for <1000 subscribers; the Paid version available between $10 and $30 per month (3 plans currently available) MailPoet Pricing 5. Decorator WooCommerce Email Template Customizer is an email template customizer plugin for WooCommerce with several handy options to create stylish emails. The plugin allows users to design new email templates from scratch with its easy-to-use builder. Decorator Users also gain access to tools that can change the content outlook, headings, logos, and other aspects of your email. Decorator also supports users with enough functions to include certain shortcodes from WooCommerce with ease. The feature ensures e-commerce storeowners can easily display extra information about orders. You can take advantage of this tool to display information about the recipient, shipping information, and other order details with ease. Main Features of Decorator WooCommerce Email Customizer Multimedia function: Users can include videos, pictures, and other media in emails Scheduling: Allows users to time the period when customizations take effect; an ideal tool to create unique emails across seasons Link socials: You can easily link your social media profiles with links in an email to spread your digital marketing effort Real-time previewer: Users can see the progress of each customization and see live previews of their email design layout : Free Decorator WooCommerce Email Customizer Pricing 6. VillaTheme Email Template Customizer for WooCommerce Online storeowners can take advantage of email template customizer to create captivating layouts from scratch. The editor comes with a set of tools designed to help newbies and expert creators build perfect email layouts. VillaTheme’s VillaTheme’s email customer also comes with a testing tool so creators can see how their emails appear on customers’ devices. You can see how your email layout will look on smartphones, tablets, PCs, and other devices. Main Features of VillaTheme Email Template Customizer for WooCommerce Email previews: Supports users with visualization tools to see how emails appear across devices before publishing Attachment support: Allows users to add file attachments to emails; an ideal feature to inform customers through PDF files, images, videos, etc. Rule setting for created templates: Supports creators to design emails along set standards; an ideal tool to retain your brand image across emails Mail testing: Allows users to create and test emails to see if all elements work correctly; ideal for teams keen to send emails to a large audience with multiple attachments : $32 one-time purchase with 6 months of full VillaTheme support VillaTheme Email Template Customizer for WooCommerce Pricing 7. MailChimp for WooCommerce Smart e-commerce marketers need automated email tools to drive their campaigns. provides online store owners with enough tools to synchronize available customer data automatically. The sync is possible only if you have a MailChimp account. MailChimp for WooCommerce You can take advantage of this sync to engage customers, follow up after purchases, deal with abandoned carts, recommend products, and do much more. Main Features of MailChimp for WooCommerce Customer tracking: Engage customers and follow their progress through your store from signing up to after checkout Automated communication: Talk with your customers using pre-scheduled emails Increased personalization: Create curated email campaigns to suit your audience Email segmentation: Smart email marketing to connect with a particular section of your subscriber base : Free MailChimp for WooCommerce Pricing 8. ThemeHigh Email Customizer for WooCommerce owns a customizer for WooCommerce with several handy features for email creators. The service provides tools users can rely on to create custom mails with the intent to reach a wide customer base. This customizer also comes with personalization options ideal to create bespoke emails for mailing list subscribers. ThemeHigh Main Features of ThemeHigh Email Customizer for WooCommerce Drag-and-drop creation: Allows users to create complete email layouts after a few clicks; an ideal tool for newbies and experienced email layout creators Simple mail builder: Straightforward template builder allows creators to design and use functional layouts in a matter of minutes Email testing: Comes with an advanced email tester so creators can see how their messages appear on all devices Live preview: Real-time previewer allows users to see their progress and track changes while creating email layouts : $38.99 to $128.99 per year (3 plans currently available) ThemeHigh Email Customizer for WooCommerce Pricing 9. YITH WooCommerce Email Templates The inject life into bland marketing campaigns with its easy-to-use layout builder. The service also provides tools to increase your market reach with elements to add social media icons inside emails. YITH WooCommerce email templates Main Features of YITH WooCommerce Email Templates Different email layouts: Comes with multiple mail layouts to ease instant marketing using existing templates Advanced styling tools: Create catchy email templates with high-end tools Mail testing: See how emails appear across devices after publishing Layout builder: Simple layout builder to create appealing email templates with easy-to-use settings : $86.99 annually YITH WooCommerce Email Templates Pricing What to Look For in WooCommerce Email Template Customizer Plugins? : Multi-extension compatibility You’ll likely need more than a WooCommerce email template customizer to run your marketing campaign. That’s why it’s vital to choose an email customizer that works with other plugins on your WooCommerce website. Such a feature ensures you can run your marketing campaign with all vital features. : Essential customizer tools You should look for a WooCommerce email template customizer that can include seasonal offers, discounts, and other promotional information in messages. Mail testing Your preferred WooCommerce email template customizer plugin should have comprehensive mail testing. The testing feature ensures users can see how designed emails appear on customers’ screens. Such a testing feature is essential when you plan to target a wide audience with your messages. Mail testing also ensures you get to see how these mails look on smartphones and larger screens. Conclusion WooCommerce email template customizers allow users to create stylish emails to communicate with customers. The best WooCommerce email template plugin also provides several customization options essential to inform your mailing list subscribers. You will be able to connect with customers, welcome them, deliver essential product information, advertising promotions, and do much more. Select the best WooCommerce email template customizer plugins and connect with members of your mailing list with ease!

9 Best WooCommerce Email Template Customizer Plugins 2023

Each eCommerce website needs to have pricing information, and displaying prices via table can be the most suitable and visually attractive way. In this article, I would like to cover the features you need for creating a WordPress pricing table the best WP pricing tables plugins. Also, I’ll try out to build a WP table without a plugin. Table of Contents: WordPress Pricing Table: Features We Need WordPress Pricing Table Plugins with Cases How to Create Pricing Table Without WordPress Plugin? TL;DR: Which WordPress Pricing Table Plugin to Choose? WordPress Pricing Table: What We Need? Before we check WordPress pricing table plugins available on the market, let’s figure out what do we need for the pricing page: : Create the pricing page structure following your pricing policy (or plans you have). For instance, a subscription-based pricing model with three plans. Structure : Allocate the main features of each pricing plan to help the user choose the most suitable one. Features : If you want to highlight one of the pricing models/plans, don’t forget to focus on it. Highlighted plan : Of course, the pricing page should follow your brand guidelines, so don’t forget to style your pricing page too. Styling WordPress Pricing Table Plugins with Cases 1. Elementor Pro Pricing Table Elementor team 🌟 Developer: Elementor Pro pricing table widget helps to stylish and build your pricing table. This plugin allows styling heading, pricing section, buttons, ribbons, etc. : ✔ Pros Styling options Editing without CSS or HTML Sale mode available ✘ Cons: High price No options to buy widgets separately The elementor pricing table is available only in Pro version, the prices start from $49 per year for one website, or you can opt for the Agency plan for $999 per year. 💰 Pricing plans: 🎨 Usage examples: Source 2. JetElements 🌟 Crocoblock team Developer: JetElements plugin is one of Elementor's best addons, which gives you flexibility and creativity for building pricing pages. ✔ Pros: Highlight each plan features Tooltips, CTA buttons, badges, tags 40+ Elementor widgets ✘ Cons: No pricing table templates 💰 The free version is available, and you can download it from the . JetElements premium costs $24 per year or goes such subscriptions: All-Inclusive ($130-$265), Lifetime ($750) Pricing plans: WordPress repository 🎨 Usage examples: Source Source 3. Responsive Pricing Table 🌟 WP Darko Developer: Responsive pricing table plugin is the free WordPress plugin created for simple pricing pages and has basic features. ✔ Pros: 11 fields available Highlight any plan Toggle, tooltips, skins in the Pro version ✘ Cons: Can be too basic for Devs 💰 This WordPress pricing table plugin is free and has Pro version plans: a single website for $19 per year or unlimited websites for $49 per year. Pricing plans: 🎨 Usage examples: Pricing table example Responsive table example 4. Pricing Table Plugin 🌟 Supsystic Developer: This WordPress pricing plugin allows creating a pricing table from the template with a drag and drop builder. ✔ Pros: Preset templates Custom header, features list, button Import or export pricing table ✘ Cons: Templates available only in the Pro version 💰 You can use the Lite version from the WordPress directory or proceed with six premium plans starting from $46 for one website / per year. Pricing plans: 🎨 Usage examples: Pricing table example Pricing page use case 5. Kadence Pricing Table 🌟 Kadence team Developer: The Kadence pricing table plugin helps to create a pricing table from a template or start from scratch. ✔ Pros: Table importer Animation effects Responsive design, translation-ready ✘ Cons: No free version is available 💰 Kadence pricing plugin costs $35 per year for unlimited websites. Also, Kadence's whole bundle for $219 includes the pricing plugin. Pricing plans: 🎨 Usage examples: Kadence pricing table example Pricing table case 6. AR Pricing Table Plugin 🌟 Repute Info Systems Developer: AR pricing table is a lightweight WordPress plugin with 300 table templates. ✔ Pros: Compatible with most popular WordPress page builders Live preview Custom CSS guidelines ✘ Cons: Limited free version 💰 Free version is accessible through , or the premium starts at $27 on codecanyon. Pricing plans: WordPress.org 🎨 Usage examples: Example Example 7. WP Table Builder 🌟 WP Table Builder team Developer: This plugin allows creating pricing tables, comparison tables, etc. The Wp Table Builder is built with this plugin, and it’s always a good tone to develop your pages with your plugins. pricing table ✔ Pros: Responsive tables 7 elements for creating simple tables Import & export tables ✘ Can be too simple for advanced pricing tables Cons: 💰 Among the free WP Table Builder plugin version, there are three plans available: Starter ($49), Pro ($99), Lifetime ($299). Pricing plans: 🎨 Usage examples: Source Source 8. Visualizer 🌟 Themeisle Developer: Visualizer is a handy tool for creating tables and charts, including pricing tables. ✔ Pros: Cross-browser compatibility Responsiveness Live editing ✘ More about creating charts than pricing tables Cons: 💰 vary from Personal ($99) to Agency ($399) options. Pricing plans: Visualizer Pro plans 9. Essential Addons for Elementor 🌟 WPDeveloper Developer: Essential Addons tool is one of the well-known Elementor plugins. This is not only a pricing table widget but includes more than 50+ free widgets, inclusively a pricing table widget. ✔ Pros: Lots of styling options Easy of use Lots of widgets ✘ Cons: Works only with Elementor page builder 💰 As the pricing table widget is available in the free version, I don’t want to stop in pricing plans. Essential Addons Pro starts from $40 for one website. Pricing plans: 🎨 Usage examples: Source Source 10. NinjaTables 🌟 WPManageNinja Developer: Ninja Tables plugin is one of the top WordPress plugins on the market. ✔ Pros: 100+ tables styles, frontend editing Responsiveness Easy-to-use ✘ Tables exporting is available only in the premium version. Cons: 💰 There are 6 pricing plans (wow!), so please check the to choose the fitting one. Pricing starts from $49 annually. Pricing plans: pricing page 🎨 Usage examples: Use Case How to Create Pricing Table Without WordPress Plugin? If you are not a plugin lover and think additional plugin affects your website speed, I want to create a pricing table with clean WordPress (5.9 version). To start with, I have deactivated all plugins I have and want to Add New page. So, go to : Pages > Add New Name your page as you wish: Press plus icon and search for table block: Then you’ll see two options available: Table block and Pricing table pattern: Let’s try each option. Creating a pricing table with a Table block Firstly, let’s choose Table block and configure how many columns and rows my table will have: I want three columns (pricing plans titles) and five rows (prices and features). Now I have the table created and want to turn on the heading section in the settings: Adding some text before proceeding: I also want to add the button with the email address so that the user can contact me for payment details: And add minimum styling to my table and button: So, my simple pricing table is ready: Creating pricing table with WordPress pattern Choose the pricing table pattern instead of the block to build a pricing table from the pattern. And you’ll see a ready-made pattern with columns and text. You can edit columns, text, buttons, delete unnecessary things, etc. I’ve changed the text, chose the gradient background, and my results were something like that :D Not encouraging, I suppose. The problem was in my WordPress theme, I was using Hello by Elementor (I forgot about this), so I think it’s just breaking my styling. It’s not a problem, I’ve changed the theme to Twenty Twenty-Two, and everything seems to look clean now: Final verdict: Creating the pricing table without plugins in WordPress is suitable for simple websites (maybe personal/blogging), but still, there is a lack of “no-coding” customization and styling. TL;DR: Which WordPress Pricing Table Plugin to Choose? Thank you for reading till the end. To sum up, I want to share my thoughts about which WordPress pricing table plugin to choose. From my point of view, the best options are: For newbies and those looking for a simple pricing table, the best options are , , Responsive pricing table Pricing table plugin Ninja Tables For creating attractive & creative pricing tables use , , . JetElements plugin Essential Addons Elementor Pro What do you think? I hope this pricing table plugins list was helpful for you, and you’ve decided which one you’d like to choose for your next project. Don’t hesitate to share any thoughts or suggestions with me.

10 WordPress Pricing Table Plugins that Rock

, I am a co-founder and security researcher from Cyfrin where we do smart contract audits. This is my opinionated take on top smart contract audit firms along with Cyfrin. The only way Web3 scales is if we increase our security, so I want to ensure that other top firms get the exposure they deserve. Auditors left off this list are not necessarily poor choices, I may have just missed them. What is a Smart Contract Audit A is a time-boxed security-based code review on your smart contract / Web3 system. An auditor’s goal is to find as many vulnerabilities as possible and educate the client on ways to improve the security of their codebase moving forward. smart contract audit Auditors use a combination of manual and automated tools to find these vulnerabilities. However, a smart contract audit does not guarantee your code is bug-free. At the end of the day, your protocol's security is yours and your auditor's responsibility, and sometimes multiple audits or another security tooling might be needed. A professional audit group can and will give you all the guidance you need to move forward on your security journey so you can feel confident deploying. You can learn more about what is a smart contract audit here. Why We Need Smart Contract Audits The image above represents the total dollar amount stolen from DeFi for the entire year of 2022, 80% of that value was exclusively in DeFi. According to , the current locked value of all DeFi is 50 billion dollars. DeFillama This means that over 6% of all DeFi value has been subject to a hack! If we want blockchain and DeFi to come to the masses, they cannot be worried that there is a 6% chance they will wake up to find their funds exploited. We have to do better than this. This is why audits are so important: Keep your protocol safe Help Web3 gain authority Educate your team on best practices That last bullet is what I call the Getting an audit and working with a group of security and smart contract experts can improve your team's skill in developing protocols. They should give you feedback on vulnerabilities educate your team on improving. They are security and developer experts, after all! hidden benefit of smart contract audits. and How to Choose a Smart Contract Auditor Understand the auditor skill set Understand your price point Understand their methodology Understand the auditor skill set You want to ensure the auditor has done work in the domain you’re looking for an audit on. If you want an audit on Solana and you work with an EVM specialist group, you’re going to have a bad time. Maybe you want a DeFi audit, and you’re working with a firm that only understands NFTs; this is also a recipe for disaster. An easy way to see what kinds of projects an auditor can do is to look at a list of their previous audits. Most auditors will have some publicly displayed audits as a showcase of work, and you can decide based on their past if they are right for you. Understand your price point Large firms will often cost more than smaller firms and independent auditors. Typically, you can find “cheaper” audits with smaller companies and independent auditors, but the quality can vary. I’ve seen a of fantastic solo auditors, though, so don’t discount a solo auditor who wants to audit your protocol. ton Pricing varies wildly depending on the auditors, so understand the next point to get the best idea for a price point. Understand their methodology https://www.youtube.com/watch?v=A-T9F0anN1E&embedable=true Before locking down any payment, you need to verify the following: Exactly which auditor(s) will conduct the audit What tools will they use (fuzzing, formal verification, etc) If they want a communication channel between your developers and the auditors are not machine auditable and often come from poor implementation of business logic. Because of this, auditors need as much context as possible in the form of: 80% of hacks Documentation Q&A Channel with Developers Code Natspec If an auditor doesn’t tell you who is doing the audit, what tools they are using, or doesn’t want to have a direct line of communication between your protocol devs and the auditors, there is a good chance they are going to do shoddy work. Additionally, I think auditors should try to improve your test suite with , but it’s not required. fuzzing/property/invariant tests How to Prepare for a Smart Contract Audit Imagine two random developers drop 5,000 lines of code you’ve never seen on your desk and tell you that the code needs to be cleaned up and spotless in two weeks. Developer A tells you what the code should do, it has a test suite, and they say, “feel free to ask me any questions you may have!” Developer B says, “Don’t talk to me till it’s done.” Your review of developer A’s code will be 100 times better than developer B. Be like developer A. To get the most out of an audit, you should: Have clear documentation Robust test suite (Ideally, including ) fuzz tests Code should be commented & readable Modern best practices followed A communication channel between developers and auditors You are prepared to do an initial video walkthrough of your code You want to think of you and your auditor as a team to get the best results out of your audit. One of the best ways to do this is to have a dedicated channel where auditors can ask questions to the developers. Additionally, the more context, documentation, and information they can read, the better. Be sure it’s easy for anyone to walk through your code and understand what it’s supposed to do. 80% of all bugs are due to business logic issues, so the auditors need to understand what the protocol should do more than they should understand the actual code! You can learn more about the . smart contract auditing process here Top Smart Contract Auditors I wanted to make sure you had all this context before giving you this list because I’ve seen protocols that want an audit for one of two reasons: Marketing Security & Marketing Be like #2. Getting “an” audit and treating all audits the same can be tempting but should be done. You want to treat an audit like you and your auditor are teaming up to secure your code. not Here it is, my list of top 7 auditors in no particular order, and why I think they are a top auditor. Cyfrin As someone who wants to see the success of Web3, I was furious with the state of security in Web3. $3.8B lost in 2022 is a horrifying statistic, so I felt compelled to jump in and help secure DeFi and blockchain. Please keep in mind I am the co-founder of . Cyfrin The Cyfrin team has some of the top engineers and auditors in the space, like: | #1 Ranked Auditor as of Writing on Code4rena Hans | Ex-Chainlink Labs Engineer in charge of $5B+ DeFi integrations Alex | Code4rena Top Finisher and Experienced FinTech Engineer 0Kage | Code4rena Top Finisher & Expert Solidity Engineer Carlos | Expert Solidity Engineer Gio | Patrick Most Watched Solidity Education Video(s) of All Time We thrive on finding as many bugs as possible and finding ways to and test suite. improve your codebase Web3 security needs a new narrative, and we are excited to push the security space forward. We are a smaller group at the time of writing as we only launched 2 months ago! You can find a , including the Beanstalk Wells integration and LinkPool. list of notable audits (and skillsets) for Cyfrin here Trail Of Bits I tell people to check out . They are one of the firms in Web3 security consistently pushing the bar in a practical sense. They don’t just give an audit, they give you all the tools you need to be successful in smart contract security as well. always Trail of Bits The Trail of Bits team builds some of the most popular and widely used tools like: Slither Manticore Echidna Properties And so many more. They are dedicated to educating the Web3 space as well with tons of free educational content and blogs. https://www.youtube.com/watch?v=3pWYvtx_sjA&embedable=true Trail of Bits is a large group consistently rated one of the top firms in Web3 for good reason, and I’d definitely classify myself as a fanboy. You can find a , like Uniswap, Yearn, and Compound. list of notable audits (and skillsets) for Trail Of Bits here OpenZeppelin is another group that constantly pushes the envelope by raising the state of Web3, which is why I’m a massive fan of their work. The is the standard library for solidity that 95% of the rest of Web3 uses and trusts to build their smart contracts. OpenZeppelin OpenZeppelin Contracts You should hold onto every report you read from the OpenZeppelin team like gold, as the information they give is some of the best in the business, and their team is constantly raising the bar for security. OpenZeppelin is a large group used by some of the top protocols in the space, like Aave, Optimism, and Compound. I really can’t speak highly enough about the skills of this team. You can find a list of notable audits (and skillsets) for OpenZeppelin here. Consensys Diligence Part of the team, one of the most well-known groups in Web3 behind projects like Metamask, Infura, and Truffle, their security team is also first-class. They are a large group with a great track record. Consensys The Diligence team is another team that values powerful fuzzing and recently came out with a product. To me, this signals that they not only understand security, but they understand trying to scale security throughout all of Web3. You can tell when a group cares when they make tooling & educational material that makes your life better instead of hoarding it all for themselves. fuzzer-as-a-service They additionally have tooling (similar to Trail of Bits) if you want to go the extra mile. formal verification You can see a , including Aragon, RocketPool, and Fei. list of Consensys Diligence audits here SpearbitDAO is a decentralized network of security experts that shakes the game up. Spearbit Unlike traditional auditing firms, which employ teams of full-time security researchers, Spearbit sources top talent from everywhere in the Web3 ecosystem to assemble the best possible team. Now you might be thinking, “wait, wouldn’t the quality vary if they have different auditors on different projects?”- however, this hasn’t stopped them from consistently being one of the best in the business. SpearbitDAO proves the decentralization ethos works, as many top auditors and researchers go solo — so periodically combining them into one group makes them all the better! You can see a list of , including SudoSwap, LooksRare, and ArtGobblers. SpearbitDAO audits here Dedaub A lesser-known group, I’ve only seen the team ship amazing reports, and it was a little confusing to me why so few people know about them. Dedaub They are another team that ships more than , with coding libraries and helpful alpha on social media. just security audits As an ex-Chainlink engineer myself (ex-DevRel technically), I’ve witnessed the good this team can do on an audit. You can see a list of projects , including Chainlink, Liquity, and Blur. they’ve worked with Trust is a solo auditor consistently at the top of the competitive audit leaderboards and has done fantastic work educating all of Web3. I especially wanted to highlight him to say you don’t always need to go with a firm! Solo auditors can often be cheaper, with as much skill or more than a massive firm. Trust He has , consistently gives , and has made a massive impact in keeping Web3 safe by himself! an auditor course beautiful write-ups I had the pleasure of interviewing him, and he gave me all the tips and tricks one would need to move forward and be a successful security engineer in Web3. https://www.youtube.com/watch?v=VRK2rLFPU0o&embedable=true You can see a list of including The Graph and Vagabond. Trust audits here, More I wanted to keep the list short because the algorithm likes it like that, but here are some more firms and solo auditors that do a fantastic job. Let me know if you think I’m missing any, and I’ll do an assessment. Firms Sigma Prime MixBytes WatchPug Halborn Code4rena Sherlock Runtime Verification Certora Paladin Dedaub Solo Pashov 0x52 obront.eth Romanboehr cccz Akshay Srivastav Kaden.eth Also published . here

Top 7 Smart Contract Auditors to Check For Your Smart Contract

We will walk you through all aspects of machine learning from simple linear regressions to the latest neural networks, and you will learn not only how to use them but also how to build them from scratch. Big part of this path is oriented on Computer Vision(CV), because it’s the fastest way to get global knowledge, and experience from CV can be simply transferred to any ML area. We will use as an ML framework, as it is the most promising and production ready. TensorFlow Learning will be better if you work on theoretical and practical materials at the same time to get practical experience on learned material. Also if you want to compete with other people solving real life problems I would recommend you register on , and it could be a good addition to your resume. Kaggle Python. You may not be a guru, basic knowledge will do. For anything else there are manuals) Requirement: 1. Courses: 1.1 Practical Machine Learning by Johns Hopkins University 1.2 These first two will teach you basic things about Data Science and machine learning and will prepare you for real hard stuff) Machine Learning by Stanford University 1.3 ( )That’s where the party’s starting, it’s one of the best courses that you can find on the Internet about ML & CV. It will not only show you how deep is the rabbit hole, but also will give you good base for further investigation. CS231n: Convolutional Neural Networks for Visual Recognition 2017 2016 1.4* Optional course. You can take only practical part from it. Deep Learning by Google 1.5* Optional course for those who want to work with Natural Language Processing. And yeah, it is also great) CS224d: Deep Learning for Natural Language Processing 1.6* Good handbook which covers many aspects of ML Deep Learning book 2. Practical part: This list consist of many tutorials and projects, that you should try, understand how they work, and think how you can improve them. This list is created to increase your expertise and interest in ML, so don’t be afraid if some of the tasks are hard for you, you can return to them when you are ready. 2.1. 2.1. 2.2. Simple practical course on Tensorflow from Kadenze Tensorflow cookbook Tensorflow-101 tutorial set 2.3. This will show how you can use neural network to transfer styles from famous paintings to any photo. Fast Style Transfer Network 2.4 Image segmentation 2.5 One of the fastest (and also simpler) models for object detection. Object detection with SSD 2.6 Fast Mask RCNN for object detection and segmentation 2.7 Very useful thing especially if you want to build a robot or next Dota AI) Reinforcement learning 2.8. Project that aims for creating compelling art and music with the help of neural networks. And results are remarkable. Magenta project from Google Brain team 2.9 New awesome algorithm of photo enhancement from Google Deep Bilateral Learning for Real-Time Image Enhancement 2.10 Want to make you car fully automatic? — that’s a good starting point) Self driving-car project 3. FAQ **What to do if you are stuck?**First you must understand that ML it not something that 100% precise — most of the cases are just a good guess and tons of tuning iterations. So to come up with some personal idea is very hard in most cases, because of the price of model training. So don’t try to figure out solution by yourself — search for papers, projects, people that can help you. The faster you get experience, the better.Some websites that can help you: , , http://www.gitxiv.com/ https://arxiv.org/ https://stackoverflow.com It’s pity to say, but not all tech guys want to open their work on public, but all of them need publications to get grants and fame. So some of them publish just a part of the material, or make mistakes in formulas. That’s why always better to search for the code and not for the paper. Better think about papers like evidence that this problem was solved. Why papers do not fully cover the problem or wrong in some places? **Where can I find fresh materials?**I use this two websites , . First one finds not only a paper, but also a code for it, so it is more practical. http://www.gitxiv.com/ https://arxiv.org/ **Should I use Cloud or PC/Laptop for computing?**Cloud is the best fit for intense computing of production models. For learning and tests it is much cheaper to use PC/Laptop with CUDA graphic card. For example, I train all models on my laptop with GTX GeForce 960M with 690 CUDA Cores.Of course, if you have grants for cloud or free money for it, you can use it. **How can I improve tuning of hyperparameters of the models?**The main problem in training is time. You can’t just sit and watch the training stats. For this reason I would recommend you to use Grid Search. Basically, just create the sets of hyperparameters and model architecture and then run them one after another in stream, saving results. Thus you can run training at night and compare results the next day, finding the most promising one.You can look how this was done in sklearn library: http://scikit-learn.org/stable/modules/grid_search.html Subscribe to get more interesting articles about Machine Learning and Computer vision. Next article will be about debugging.

How To Become A Machine Learning Engineer

Welcome to the final step in creating your Collectibles portal! (for part 1, see ) here In this part, we'll focus on building the frontend—the last piece of the puzzle. Here's what we'll achieve: Connect the Flow Wallet. Initialize your account and mint your NFT. Check the NFT ID in your Collection. View the NFT with the NFT ID you have in your Collection. We will be using to build the frontend. Next.js Let's get started! 1. Installation Setting Up Open your project directory. Then, run in the terminal and press . flow-collectible-portal npx create-next-app@latest frontend enter This will provide you with several options. In this tutorial, we will not use , ESLint, or , and we will use the directory and the App router at the time of this article. Typescript TailwindCSS src Now you have a fresh web app ready. This is how your frontend folder looks: 2. Configuration To interact with the we will use the Flow Client Library (FCL) to manage wallet connections, run scripts, and send transactions in our application. It will allow us to write complete Cadence functions and run them as Javascript functions. Flow blockchain To get started, let's install FCL for our app by running the following command: npm install @onflow/fcl --save After installing FCL, we need to configure it. Here's what you need to do: Inside the folder create a new folder named and add a file named . app flow config.js In this file, set up the configuration for the FCL, such as specifying the Access Node and wallet discovery endpoint. This helps you to choose between using a testnet or a local emulator. You will also want to specify the Collectibles contract address we deployed in Part 1. Add the following code to the file: config.js import { config } from "@onflow/fcl";

config({
 "app.detail.title": "Flow Name Service",
 "app.detail.icon": "https://placekitten.com/g/200/200",
 "accessNode.api": "https://rest-testnet.onflow.org",
 "discovery.wallet": "https://fcl-discovery.onflow.org/testnet/authn",
 "0xCollectibles": "ADD YOUR CONTRACT ACCOUNT ADDRESS",
 "0xNonFungibleToken": "0x631e88ae7f1d7c20",
}); Now you're all set up to use the FCL in your app. 3. Authentication To verify a user's identity in an app, you can use several functions: For logging in, call . fcl.logIn() For signing up, call . fcl.signUp() For logging out, call . fcl.unauthenticate() Let’s learn how we can implement these functions in your frontend. fcl First, we will add the following code to our file inside the app directory. This will import some dependencies, set up some initial for parts of our app, and build a basic UI. page.js useState To make sure it looks nice, delete the file inside the app directory and instead make a file called page.css. Then paste the contents of inside of it. Now we can write out our initial page. page.module.css this file "use client";
import React, { useState, useEffect, useRef } from "react";
import * as fcl from "@onflow/fcl";
import "./page.css";
import "./flow/config";

export default function Page() {
  const [currentUser, setCurrentUser] = useState({
    loggedIn: false,
    addr: undefined,
  });

  const urlInputRef = useRef();
  const nameInputRef = useRef();
  const idInputRef = useRef();
  const [isInitialized, setIsInitialized] = useState();
  const [collectiblesList, setCollectiblesList] = useState([]);
  const [loading, setLoading] = useState(false);
  const [ids, setIds] = useState([]);
  const [nft, setNFT] = useState({});

  useEffect(() => fcl.currentUser.subscribe(setCurrentUser), []);

  function handleInputChange(event) {
    const inputValue = event.target.value;

    if (/^\d+$/.test(inputValue)) {
      idInputRef.current = +inputValue;
    } else {
      console.error("Invalid input. Please enter a valid integer.");
    }
  }

  return (
    <div>
      <div className="navbar">
        <h1>Flow Collectibles Portal</h1>
        <span>Address: {currentUser?.addr ?? "NO Address"}</span>
        <button onClick={currentUser.addr ? fcl.unauthenticate : fcl.logIn}>
          {currentUser.addr ? "Log Out" : "Connect Wallet"}
        </button>
      </div>

      {currentUser.loggedIn ? (
        <div className="main">
          <div className="mutate">
            <h1>Mutate Flow Blockchain</h1>
            <form
              onSubmit={(event) => {
                event.preventDefault();
              }}
            >
              <input
                type="text"
                placeholder="enter name of the NFT"
                ref={nameInputRef}
              />
              <input type="text" placeholder="enter a url" ref={urlInputRef} />
              <button type="submit">Mint</button>
            </form>
            <mark>Your Collection will be initialized while minting NFT.</mark>
          </div>
          <div className="query">
            <h1>Query Flow Blockchain</h1>
            <mark>Click below button to check 👇</mark>
            <button>Check Collection</button>
            <p>
              Is your collection initialized: {isInitialized ? "Yes" : "No"}
            </p>
            <button onClick={viewIds}>
              View NFT IDs you hold in your collection
            </button>
            <p>NFT Id: </p>
          </div>
          <div className="view">
            <h1>View Your NFT</h1>
            <input
              type="text"
              placeholder="enter your NFT ID"
              onChange={handleInputChange}
            />
            <button>View NFT</button>
            <div className="nft-card">
              <p>NFT id: </p>
              <p>NFT name: </p>
              <img src="" alt="" />
            </div>
          </div>
        </div>
      ) : (
        <div className="main-2">
          <h1>Connect Wallet to mint NFT!!</h1>
        </div>
      )}
    </div>
  );
} After adding this code, run to make sure everything loads correctly. npm run dev 4. Querying the Flow blockchain Before getting a deep dive into how we can use to query the Flow blockchain, add these Cadence script codes after the function in the file. fcl handleInput page.js const CHECK_COLLECTION = `
import NonFungibleToken from 0xNonFungibleToken
import Collectibles from 0xCollectibles

pub fun main(address: Address): Bool? {
    		return Collectibles.checkCollection(_addr: address)
}`

const GET_NFT_ID = `
import NonFungibleToken from 0xNonFungibleToken
import Collectibles from 0xCollectibles

pub fun main(user: Address): [UInt64] {
    	let collectionCap = 
getAccount(user).capabilities.get
<&{Collectibles.CollectionPublic}>(/public/NFTCollection) 
?? panic("This public capability does not exist.")
    	let collectionRef = collectionCap.borrow()!
    	return collectionRef.getIDs()
}
`

const GET_NFT = `
import NonFungibleToken from 0xNonFungibleToken
import Collectibles from 0xCollectibles

pub fun main(user: Address, id: UInt64): &NonFungibleToken.NFT? {
  		let collectionCap= 
getAccount(user).capabilities.get<&{Collectibles.CollectionPublic}>(/public/NFTCollection) ?? panic("This public capability does not exist.")

  	let collectionRef = collectionCap.borrow()!
return collectionRef.borrowNFT(id: id)
} With our Cadence scripts ready to go, we can now declare some Javascript functions and pass in the Cadence constants into the queries. `fcl` async function checkCollectionInit() {
    const isInit = await fcl.query({
        cadence: CHECK_COLLECTION,
        args: (arg,t) => [arg(currentUser?.addr, t.Address)],
    });
    console.log(isInit);
}

async function viewNFT() {
    console.log(idInputRef.current);
    const nfts = await fcl.query({
        	cadence: GET_NFT,
        	args: (arg,t) => [arg(currentUser?.addr,t.Address), 
arg(idInputRef.current, t.UInt64)]
    });
    setNFT(nfts);
    console.log(nfts);
}

async function viewIds() {
    const ids = await fcl.query({
        cadence: GET_NFT_ID,
        args: (arg,t) => [arg(currentUser?.addr,t.Address)]
    });
    setIds(ids);
    console.log(ids);
} Now let’s take a look at all the functions we’ve written. There are two things to notice: The fcl.query And the line. args: (arg,t) => [arg(addr,t.Address)], Since scripts are similar to functions in Solidity and don't require any gas fees to run, we are essentially just querying the blockchain. So we use to run scripts on Flow. view fcl.query To query something, we need to pass an argument. For that, we use arg, which is a function that takes a string value representing the argument, and , which is an object that contains all the different data types that Cadence has. So we can tell how to encode and decode the argument we are passing. t arg 5. Mutating the Flow blockchain While our previous functions were just “read only,” our next ones will have actions that can mutate the blockchain state and write to it; aka “mint an NFT.” To do this we’ll write another Cadence script as a constant. const MINT_NFT = `
import NonFungibleToken from 0xNonFungibleToken
import Collectibles from 0xCollectibles

transaction(name:String, image:String){
    let receiverCollectionRef: &{NonFungibleToken.CollectionPublic}
    prepare(signer:AuthAccount){
        // initialise account
        if signer.borrow<&Collectibles.Collection>(from: Collectibles.CollectionStoragePath) == nil {
            let collection <- Collectibles.createEmptyCollection()
            signer.save(<-collection, to: Collectibles.CollectionStoragePath)
            let cap = signer.capabilities.storage.issue<&{Collectibles.CollectionPublic}>(Collectibles.CollectionStoragePath)
            signer.capabilities.publish( cap, at: Collectibles.CollectionPublicPath)
        }
        //takes the receiver collection refrence
        self.receiverCollectionRef = signer.borrow<&Collectibles.Collection>(from: Collectibles.CollectionStoragePath)
      ?? panic("could not borrow Collection reference")
    }
    execute{
        let nft <- Collectibles.mintNFT(name:name, image:image)
        self.receiverCollectionRef.deposit(token: <-nft)
    }
} Now add the below function after the transaction code to the file. page.js async function mint() {
	try{
	  const txnId = await fcl.mutate({
        	cadence: MINT_NFT,
        	args: (arg,t) => [arg(name,t.String), arg(image, t.String)],
	   	payer: fcl.authz,
	  	proposer: fcl.authz,
	  	authorizations: [fcl.authz],
	  	limit:999,});
	} catch(error){
	console.error('Minting failed:' error)
}
    console.log(txnId);
} As for the function, the syntax is the same as . However, we do provide several extra parameters such as the following: fcl.mutate fcl.query payer: fcl.authz,
proposer: fcl.authz,
authorizations: [fcl.authz],
limit: 50, These are Flow-specific things that define which account will be paying for the transaction (payer), broadcasting the transaction (proposer), and the accounts from which we need authorizations. (In case an account has multiple keys attached, it can behave like a multi-sig wallet.) refers to the currently connected account. fcl.authz is like gasLimit in the Ethereum world, which places an upper limit on the maximum amount of computation. If the computation crosses the limit, then the transaction will fail. limit We’ll need to add one more function that will call and handle the function we just made. mintNFT const saveCollectible = async () => {
    if (urlInputRef.current.value.length > 0 && nameInputRef.current.value.length > 0) {
      try {
        setLoading(true);
        const transaction = await mintNFT(nameInputRef.current.value, urlInputRef.current.value);
        console.log('transactionID:', transaction);
        // Handle minting success (if needed)
      } catch (error) {
        console.error('Minting failed:', error);
        // Handle minting failure (if needed)
      } finally {
        setLoading(false);
      }
    } else {
      console.log('Empty input. Try again.');
    }
  }; 6. Final code With our main functions in place, we can now plug them into our UI. However, before we do that, we’ll add some calls to help load the initial state. You can add these right above the already existing call. useEffect useEffect useEffect(() => {
    checkCollectionInit();
    viewNFT();
  }, [currentUser]);

  useEffect(() => {
    if (currentUser.loggedIn) {
      setCollectiblesList(collectiblesList);
      console.log('Setting collectibles...');
    }
  }, [currentUser]); Now back in our section with the UI, we can add our functions to the appropriate parts of the app. return return (
    <div>
      <div className="navbar">
        <h1>Flow Collectibles Portal</h1>
        <span>Address: {currentUser?.addr ?? "NO Address"}</span>
        <button onClick={currentUser.addr ? fcl.unauthenticate : fcl.logIn}>
          {currentUser.addr ? "Log Out" : "Connect Wallet"}
        </button>
      </div>

      {currentUser.loggedIn ? (
        <div className="main">
          <div className="mutate">
            <h1>Mutate Flow Blockchain</h1>
            <form
              onSubmit={(event) => {
                event.preventDefault();
                saveCollectible();
              }}
            >
              <input
                type="text"
                placeholder="enter name of the NFT"
                ref={nameInputRef}
              />
              <input type="text" placeholder="enter a url" ref={urlInputRef} />
              <button type="submit">Mint</button>
            </form>
            <mark>Your Collection will be initialized while minting NFT.</mark>
          </div>
          <div className="query">
            <h1>Query Flow Blockchain</h1>
            <mark>Click below button to check 👇</mark>
            <button onClick={checkCollectionInit}>Check Collection</button>
            <p>
              Is your collection initialized: {isInitialized ? "Yes" : "No"}
            </p>
            <button onClick={viewIds}>
              View NFT IDs you hold in your collection
            </button>
            <p>NFT Id: </p>
            {ids.map((id) => (
              <p key={id}>{id}</p>
            ))}
          </div>
          <div className="view">
            <h1>View Your NFT</h1>
            <input
              type="text"
              placeholder="enter your NFT ID"
              onChange={handleInputChange}
            />
            <button onClick={viewNFT}>View NFT</button>
            <div className="nft-card">
              <p>NFT id: {nft.id}</p>
              <p>NFT name: {nft.name}</p>
              <img src={nft.image} alt={nft.name} />
            </div>
          </div>
        </div>
      ) : (
        <div className="main-2">
          <h1>Connect Wallet to mint NFT!!</h1>
        </div>
      )}
    </div>
  ); Check the final code . here Now with the app complete, let’s walk through how to use it! First, connect your wallet by clicking the “Connect Wallet” button in the top right. Now you can mint an NFT! Enter the name of your NFT and paste in a link to the image you want to use. After you click “mint” it will prompt you to sign a transaction with your wallet. It might take a little while for the transaction to complete. After it completes, you should be able to click the bottom button to view the IDs of your NFTs. If this is your first one, then the ID should be just “1”. Now you can copy the ID of your NFT, paste it into the View section, and click “View NFT”. Conclusion Well done! You've finished part 2 of the Collectibles portal project. In summary, we focused on building the frontend of our Collectibles portal. We did this by: Creating an app with Next.js Connecting the Flow Wallet Creating our very own NFTs for minting Viewing your NFT Have a really great day! Also published here.

How to Build a Digital Collectibles Portal Using Flow and Cadence (Part 2)

কিভাবে ফ্লো এবং ক্যাডেন্স ব্যবহার করে একটি ডিজিটাল সংগ্রহযোগ্য পোর্টাল তৈরি করবেন (পর্ব 2)

So erstellen Sie ein digitales Sammlerportal mit Flow und Cadence (Teil 2)

Cómo crear un portal de coleccionables digitales utilizando flujo y cadencia (Parte 2)

Comment créer un portail d'objets de collection numériques à l'aide de Flow et de Cadence (Partie 2)

प्रवाह और ताल का उपयोग करके डिजिटल संग्रहणीय पोर्टल कैसे बनाएं (भाग 2)

フローとケイデンスを使用してデジタル グッズ ポータルを構築する方法 (パート 2)

Flow와 Cadence를 사용하여 디지털 수집품 포털을 구축하는 방법(2부)

Como construir um portal de colecionáveis digitais usando fluxo e cadência (parte 2)

Как создать портал цифровых предметов коллекционирования, используя поток и ритм (часть 2)

Akış ve Ritim Kullanılarak Dijital Koleksiyon Portalı Nasıl Oluşturulur (Bölüm 2)

Cách xây dựng cổng sưu tầm kỹ thuật số bằng cách sử dụng Flow và Cadence (Phần 2)

如何使用 Flow 和 Cadence 构建数字收藏品门户（第 2 部分）

How to Build a Digital Collectibles Portal Using Flow and Cadence (Part 1)

ফ্লো এবং ক্যাডেন্স ব্যবহার করে কীভাবে একটি ডিজিটাল সংগ্রহযোগ্য পোর্টাল তৈরি করবেন (পর্ব 1)

So erstellen Sie ein digitales Sammlerportal mit Flow und Cadence (Teil 1)

Cómo crear un portal de coleccionables digitales utilizando flujo y cadencia (Parte 1)

Comment créer un portail d'objets de collection numériques à l'aide de Flow et de Cadence (Partie 1)

प्रवाह और ताल का उपयोग करके डिजिटल संग्रहणीय पोर्टल कैसे बनाएं (भाग 1)

フローとケイデンスを使用してデジタル グッズ ポータルを構築する方法 (パート 1)

Flow와 Cadence를 사용하여 디지털 수집품 포털을 구축하는 방법(1부)

Como construir um portal de colecionáveis digitais usando fluxo e cadência (parte 1)

Как создать портал цифровых предметов коллекционирования, используя поток и ритм (часть 1)

Akış ve Ritim Kullanarak Dijital Koleksiyon Portalı Nasıl Oluşturulur (Bölüm 1)

Cách xây dựng cổng sưu tầm kỹ thuật số bằng cách sử dụng Flow và Cadence (Phần 1)

如何使用 Flow 和 Cadence 构建数字收藏品门户（第 1 部分）

Flow is a permissionless layer-1 blockchain built to support the high-scale use cases of games, virtual worlds, and the digital assets that power them. The blockchain was created by the team behind Cryptokitties, Dapper Labs, and NBA Top Shot. One core attribute that differentiates Flow from the other blockchains is its way of providing to objects within the blockchain. Fine-grained access is a new method of providing access to users that follows the principle of least privilege. This makes it highly secure and fault-resistant. Flow is one of the unique blockchains to have this, as it is built on the fundamentals of Capability-based security. fine-grained permissions But how does this help you as a developer? If you’re writing smart contracts, then you likely have to regularly define access to objects and functions within your contract. Understanding the different types of access better will help you to define access types in code more accurately. This will allow you to write highly secure and efficient smart contracts. Let’s dive in. Understanding fine-grained permissions As opposed to Role-based access control (RBAC), where permissions are defined loosely for every role and not specifically for every individual, fine-grained permissions allow developers to define permissions for objects at the lowest level. This allows permissions to be defined for every object. This also allows you to add new permissions types, such as time-expiry and geography-based permissions. Let’s understand the core principle behind fine-grained permissions. The principle of least privilege The concept of least privilege means that in a computing environment, any module (such as a process, a user, or a programmer) only has the necessary access that it needs to do its specific job. Any other unnecessary permissions for its specific job are either revoked or unavailable. For example, a programmer whose job is to create backups does not need to make user data updates, so it should only have read permissions on the database of users. This principle is the core principle behind fine-grained permissions. Capability-based Security A capability is an unforgeable token of authority. In capability-based authorization, your identity does not matter. If you’ve been sent an access token by the owner/admin that grants you the capability to access a resource and you can execute that capability, then you will have access. Hence, at runtime, the application does not check what your identity is but only that you can access the requested resource. Thus, fine-grained access can be implemented on the foundations of capability-based security. History of fine-grained access In the 1980s, operating systems would define permissions on objects as “read”, “write”, and “execute”. This was called Access Control Lists. In the 1990s, Role-based Access Control was introduced, which allowed you to create groups and assign users to groups. Then, the concepts of attribute-based access control and capability-based access control arrived, which brought fine-grained access into the picture. In the world of blockchains, however, fine-grained access is new and brought by Cadence, the language used to write Flow smart contracts. Fine-grained access in Cadence Cadence, the language used to write flow smart contracts, has built-in special keywords to allow for fine-grained permissions to resources. Below, we dive into the common keywords and the usage of these keywords to provide fine-grained access. The access keywords Flow defines certain keywords, known as access keywords, with different parameters to define the access privileges of a certain resource. Below are the four primary keywords: Pub or access(all) Using this keyword means the declaration is accessible in all scopes. However, this also means that the declaration is not updatable except when you’re updating the value at an index of an array. Pub or access(all) are the least restrictive types of access and should generally be avoided. Below is an example of using the pub keyword: pub contract Car {    pub let carBrand: String    pub let carNameByBrand: {String: String}    pub fun returnCarBrand(): String {        return self.carBrand    }}} Following the above code example, if there’s an object called CarObject of type Car, then the statement below invocation is valid. CarObject.carBrand //Equals the value of greeting in the object The values with access type pub are generally not updatable except when updating the value at a certain index of an array. CarObject.carNameByBrand = {} //Not ValidCarObject.carNameByBrand[“Porsche”] = “Carrera” //Valid access(self) access(self) means that the declaration is only visible in the current and inner scopes. For example, an access(self) field can only be accessed by the functions of the type it is a part of. When using access(self), it is common practice to define setters and getter methods to allow other objects and contracts to access this field. This keyword makes the usage very safe but also restrictive. Below is an example of using access(self): pub contract Car {    access(self) let carBrand: String    access(self) let carNameByBrand: {String: String}    pub fun returnCarBrand(): String {        return self.carBrand    }    pub fun returnCarName(_ brand: String): String? {        return self.carNameByBrand[brand]    }}} access(contract) access(contract) means that the declaration is only accessible in the scope of the contract that defines it. Hence, functions defined in other contracts under the same account or functions defined in contracts under other accounts will not be able to access it. This keyword is unique to Cadence and comes in handy when you have any contract-specific variables you don’t want to expose to other contracts. Below is an example of using the access(contract) keyword: pub contract CarContract {    pub struct Car {        access(contract) var carBrand: String    }    pub fun returnCarBrand(_brand: Car): String {        return Car.carBrand    }}} In the above example, if you have a method in a different contract that has an object of the Car struct, you cannot get the carBrand variable directly. However, you can call the returnCarBrand function to get the value of carBrand. access(account) This keyword means that the declaration is only accessible inside the entire account owned by the current smart contract. Hence, other contracts in the same account can access a variable freely. This type of access is very powerful, allowing you to keep a variable private to your account. You are also able to deploy a smart contract that needs to use the variable in the future, if needed. This way, several contracts in the same account can share information seamlessly with one another, promoting the modularity of code. Below is an example of how to use it: pub contract CarContract {    pub struct Car {        access(account) var carBrand: String    }    pub fun returnCarBrand(_brand: Car): String {        return Car.carBrand    }}} In the above example, if you have a method in a different contract that has an object of the Car struct, you can get the carBrand variable directly. Conclusion The concept of least privilege and capability-based security play a significant role in Flow's precise permissions. The access keywords provide clear definitions of variable and function access, as we have covered in this article. One of the most noteworthy features that fundamentally strengthens the security of the Flow blockchain is its fine-grained access control. Blockchain technology has long been plagued by bugs and hacks, most of which occur because of ill-conceived access controls. However, fine-grained access control provides developers with a remarkable opportunity to effortlessly and smoothly secure their smart contracts. Ultimately, this is what sets Flow apart in the world of blockchain. On the topic of fine-grained permissions, hopefully you found this in-depth exploration valuable and helpful. For more information, refer to the . Or explore the and get some hands-on experience! official documentation Flow Docs

Better Smart Contracts with Fine-Grained Permissions using Cadence

is a permissionless layer-1 blockchain built to support the high-scale use cases of games, virtual worlds, and the digital assets that power them. The blockchain was created by the team behind CryptoKitties, Dapper Labs, and NBA Top Shot. Flow One of the best features of Flow is that it supports the paradigm of resource-oriented programming. Resource-oriented is a new way of managing memory where resources are held “in-situ” by the resource owner instead of in a separate ledger. This is very relevant for managing scarce and unreplicable digital resources on the blockchain. programming In this article, I’ll do a deep dive into resource-oriented programming—and allow you to better manage your resources in your Flow smart contracts. What is resource-oriented programming? In resource-oriented programming, objects are labeled as “resources.” Resources are a collection of variables and functions that only have exactly one copy at a time. Resources provide better composability than EVM and WASM. When something is called a resource, there are very specific rules for interacting with it. The three rules that apply to resources in resource-oriented programming are as follows: Each resource exists in only one memory location - Resources cannot be duplicated. Ownership of a resource is defined by where it is stored - No central ledger that keeps track of ownership. Only the owner of the resource can access its methods. To explain this better; in the real world, if you claim to own a watch, that ownership is proven by the fact that you possess it yourself. There is no central ledger that people refer to check if you are the owner. However, in programming, when we think of ownership, we think of a mapping somewhere in a ledger of the object ID to the owner ID. For example, in the case of ERC721 smart contracts, the ownership of digital assets is stored in a ledger owned by the main smart contract. Flow changes this paradigm of ownership by storing “resources” in the memory location owned by the owner itself (see image below). This means that if you’re holding a digital asset on the Flow blockchain, it is stored in the memory location of the account that you own. This has several benefits, which we’ll talk about in the coming section. Resources in Cadence is the world’s first high-level resource-oriented programming language. , created for Facebook’s now-defunct Diem, is the only other language that is resource-oriented, but it is more low-level. Cadence Move In Cadence, resources are defined using the “resource” keyword. Within a resource, you can define the attributes of the resource, like variables and functions. This definition of a resource now becomes a type and can be used to create objects of that type.\ An example of creating a resource and creating an instance of that resource is shown below: // Declare a resource that only includes one function.    pub resource CarAsset { // A transaction can call this function to get the "Honk Honk!"        // message from the resource.        pub fun honkHorn(): String {            return "Honk Horn!"        }    } // We're going to use the built-in create function to create a new instance    // of the Car resource    pub fun createCarAsset(): @CarAsset {        return <-create CarAsset()    } Destroy function Resources in Cadence can be explicitly destroyed using the “destroy” keyword. The Move Operator (<-) To make the moves of a resource explicit, the Move operator, such as “<-” must be used when: Initializing the value of a constant or variable with a resource Moving resources to a different variable Moving resources to the argument of a function Returning it from a function Code Example of Creating a Resource in Cadence Below is an example of a Cadence script that creates a CryptoKitty collection as a resource and also stores individual Kitties as a resource. contract CryptoKitties {// Accounts store a collection in their account storage  resource KittyCollection {// Each collection has functions to// move stored resources in and out  fun withdraw(kittyId: int): CryptoKittyfun deposit(kitty: CryptoKitty)}  // The resource objects that can be stored in the collectionresource CryptoKitty {}} transaction(signer: Account) {// Removes the Kitty from signer's collection, and stores it// temporarily on the stack. let theKitty <- signer.kittyCollection.withdraw(kittyId: myKittyId) // Moves the Kitty into the receiver's accountlet receiver = getAccount(receiverAccountId)receiver.kittyCollection.deposit(kitty: <-theKitty)} In the above code, we create a KittyCollection resource that has several CryptoKitty sub-resources within it. We then do a transfer transaction to transfer a Kitty from one user account to another. Other things to keep in mind Resources must be created using the “create” keyword. At the end of a function with resources, the resources should either be moved or destroyed. Accessing a field or a function of a resource does not destroy it. When a resource is moved, the constant or variable currently holding the resource becomes invalid. To make a resource type explicit, the prefix @ must be used in type annotations. Comparison and Benefits Resource-oriented programming versus ledger-based systems A common comparison of the ownership structure in resource-oriented programming is with ledger-based ownership. In the ledger model, like in ERC721 smart contracts, every time you have to update ownership, you need to update the mapping of the ID in a shared ledger. In resource-oriented programming, resources are stored within the account of the owner itself, so transferring a digital asset only means moving the resource from the first party to the second. This does not require updating any ledgers. Resource-oriented programming is more suitable for blockchain use cases like digital assets than the traditional ledger system. Benefits of resource-oriented programming There are several benefits that resource-oriented programming brings to the table. Let’s look at some of them below. Makes capability-based security possible Resource types provide the foundation on which capability-based security can be established. Capabilities are one of the best methods to create highly secure blockchain authorization systems. This brings the utmost security to the Flow blockchain. Eliminates reentrancy attacks Reentrancy attacks are one of the most severe smart contract vulnerabilities often exploited by hackers. In a reentrancy attack, a hacker calls the withdraw function on a smart contract recursively. This way, they are able to drain the entire funds of a smart contract. Since methods within a resource cannot be accessed by anyone but the owner, there is no possibility of a reentrancy attack. Better pricing and cost management In Ethereum, the CryptoKitties contract has 2 million digital assets collectively taking up more than 100 MB of space, living rent-free on the Ethereum blockchain. In an ideal world, it should be possible to charge the owners of Kitties based on how much of this data belongs to them on-chain. In Flow, since the resource is directly stored in the account of the owner, it is clear who needs to pay the cost for that data. Conclusion Resource-oriented programming is a new and innovative programming paradigm that has been brought to the blockchain world by the Flow blockchain. It makes resource management very efficient, easy, and secure. It also helps provide a better cost-sharing model for running blockchain infrastructure. You can refer to the on Resources to learn more. I also recommend that you get your hands dirty by going through and this . official docs page Flow Docs tutorial on Resources

The Power of Resource-Oriented Programming in Flow/Cadence: A Deep Dive

When starting a new project, it’s important to make the right choices about the blockchain and smart contract language. These choices can significantly impact the overall success of your project as well as your success as a developer. web3 In this article, we'll compare three popular smart contract programming languages: Solidity: used in Ethereum and other EVM-based platforms Cadence: used in the Flow blockchain Move: used in the Sui/Aptos blockchain We'll explain the concepts and characteristics of each language in simple terms, making it easier for beginners to understand. Let’s dive in. Solidity: The Foundation of Ethereum Smart Contracts is a high-level, object-oriented language used to build smart contracts in platforms like Ethereum. Initially, Solidity aimed to be user-friendly, attracting developers by resembling JavaScript and simplifying learning. While it still values user-friendliness, its focus has shifted to enhancing security. Currently, Solidity . Solidity has quite a few security pitfalls developers need to be aware of Some Solidity features include: Solidity uses clear, explicit code with a syntax similar to JavaScript, prioritizing ease of understanding for developers. Syntax and Simplicity: Solidity emphasizes secure coding practices and highlights risky constructs like gas usage. Security Focus: The language enforces data type declarations for variables and functions. Statically Typed: Solidity supports features like inheritance, libraries, and complex user-defined types. Inheritance and Libraries: Cadence: Empowering Digital Assets on Flow is designed by Flow, a blockchain known for helping to make web3 mainstream and working with major brands like Disney and the NBA. It ensures secure, clear, and approachable smart contract development. Cadence Some Cadence features include: The language enforces strict type-checking to prevent common errors. Type Safety: **Resource-oriented Programming:**Resources are unique types that can only move between accounts. They can’t be copied or discarded. If a function fails to store a Resource obtained from an account in the function scope during development, then semantic checks will show an error. The run-time enforces the same rules in terms of allowed operations. Contract functions that don’t handle Resources properly in scope before exiting will stop. These Resource features make them perfect for representing both fungible and non-fungible tokens. Ownership is tracked according to where they are stored, and the assets can’t be duplicated or lost since the language enforces correctness. If one person wants to access another person's stored items, the first person needs a permission called a . Using Capabilities allows you to let others access your stored items remotely. There are two types of Capabilities: public and private. If someone wants to allow everyone to access their items, they can share a public Capability. For example, an account can use a public Capability to accept tokens from anyone. On the other hand, someone can give private Capabilities to certain people, allowing them to access only certain features. For example, in a project with unique digital items, the project owner might grant an "administrator Capability" that lets those users create new items. Capability-based Security: Capability Functions have predefined conditions for safer execution. Built-in Pre- and Post-Conditions: Cadence's focus on resource-oriented programming makes it ideal for managing digital assets in areas such as onchain games. Optimized for Digital Assets: To grasp the importance of these new ideas, let's take a quick look at some history. In 2018, the Dapper Labs team began working on Cadence as a new programming language. They faced challenges with Solidity because of its limitations. The main frustration in building decentralized apps came from the way contracts were accessed using addresses, making it difficult to combine contracts. Freedom from msg.sender: Composability in Web3 Now, imagine contracts as Lego building blocks. Composability in web3 means one contract can be used as a foundation for others, adding their features together. For instance, if a contract records game results on a blockchain, another contract can be built to show the best players. Another one could go even further and use past game results to predict future game odds for betting. But here's the catch: Because of how Solidity works, contracts can only talk to one another if the first contract has permission to access the second one, even if users can access both. In Solidity, who can do what is controlled by protected functions in contracts. This means contracts know and check who is trying to access their protected areas. Cadence changes how access works. Instead of using the old way where contracts need permission, it uses Capabilities. When you have a Capability, you can use it to get to a protected item such as a function or resource. This means the contract no longer has to define who's allowed access. You can only get to the protected item if you have a Capability, which you can use with "borrow()." So, the old "msg.sender" way isn't needed anymore! The effects of composability are important. When contracts don't need to know beforehand who they're interacting with, users can easily interact with multiple contracts and their functions during a transaction if they have the right permissions (Capabilities). This also allows contracts to interact with one another directly without needing special permissions or preparations. The only condition is that the calling contract must have the required Capabilities. Move: Safeguarding Digital Assets on Sui/Aptos , used in the , addresses challenges posed by established languages like Solidity. It ensures scarcity and access control for digital assets. Move Sui/Aptos blockchain Move’s features include: : Move prevents the creation or use of assets more than once, ensuring robust blockchain applications. Preventing Double-spending : Developers have precise control over ownership and associated rights. Ownership and Rights Control : In Move, a smart contract is called a module, emphasizing modularity and organization. Module Structure : Move employs static analysis to reject invalid bytecode, enhancing security. Bytecode Verifier : Move includes a standard library for common transaction scripts. Standard Library Creating Smart Contracts Let's illustrate the differences by comparing a simple smart contract that increments a value in Cadence, Solidity, and Move. Solidity Example In Solidity, creating a contract that increments a value involves defining a contract, specifying the count variable, and creating functions to manipulate it. It uses explicit syntax for variable visibility and function declarations. // SPDC-License-Identifier: MIT pragma solidity ^0.8.17; contract Counter { uint public count; // function to get the current count function get() public view returns (uint) { return count; } // function to increment count by 1 function inc() public { count += 1; } // function to decrement count by 1 function dec() public { count -=1; } } Cadence Example Cadence's approach to incrementing a value is similar but emphasizes clarity. It utilizes a resource-oriented structure and straightforward syntax, making it easier for developers to create and manage digital assets. pub contract Counter { pub var count: Int // function to increment count by 1 pub fun increment() { self.count = self.count +1 } // function to decrement count by 1 pub fun decrement() { self.count = self.count – 1 } pub fun get(): Int { return self.count } init() { self.count = 0 } } Solidity versus Cadence Syntax Differences In Solidity, the visibility keyword comes before or after variable/function names, whereas Cadence consistently follows the visibility-type-name sequence. Scalability and Upgradability Flow's network boasts higher transaction throughput than Ethereum, making Cadence more scalable. Additionally, Flow's support for contract updates enhances development. Move Example Move introduces new concepts like modules, resources, and ownership control. A Move module creates an Incrementer resource, requiring the owner's signature for operations. module incrementer_addr::increment {

 

use aptos_framework::account;

use std::signer;

       struct Incrementer has key {

                  count: u64,

       }

 

       public entry fun increment(account: &signer) acquires Incrementer {

                  let signer_address = signer::address_of(account);

                  let c_ref = &mut borrow_global_mut<Incrementer>(signer_address).count;

                  *c_ref = *c_ref +1

       }

 

       public entry fun create_incrementer(account: &signer){

            let incrementer = Incrementer {

                  count: 0

            };

            move_to(account, incrementer);

       }

} Composite Types and Turing Completeness All three languages support composite types, allowing complex types from simpler ones. All are Turing complete, meaning they can handle any computation given enough resources. Resource-Oriented versus Object-Oriented While Solidity and Move require compilation, Cadence is interpreted. Cadence and Move employ a resource-oriented approach, securing digital ownership in one location. Conclusion: Choosing the Right Programming Language When selecting a programming language like Solidity, Cadence, or Move, consider the needs of your project. Solidity is commonly used, but it might not be very easy to work with. Developers need to be careful of the security pitfalls and understand best practices. Solidity: Mainly used for digital assets, Cadence is a newer language that focuses on security, is easy to understand, and provides developers with a superior experience. Cadence: Move is , a more complex language. Rust can be more difficult to learn and understand. Move is a new language, and it doesn't have many tools, resources, or a big community. Move: based on Rust Ultimately, your choice will impact your project's success, so make an informed decision and enjoy your ! journey as a web3 developer Also published . here

Comparing Smart Contract Languages: Solidity, Cadence, and Move

Welcome to the final step in creating your Collectibles portal! of this short series focused on building the collections portal. In this part, we'll focus on building the front end—the last piece of the puzzle. Here's what we'll achieve: Part one Connect with Flow Wallet: You'll be able to link your Flow Wallet. Create NFTs (Mint): You can make your very own by confirming the transaction. NFTs View NFTs: You'll be able to see your NFTs by asking the blockchain. We will work with React.js and an existing smart contract on Flow's testnet. This smart contract is the same Collectibles contract we crafted in part 1. Here are the steps we will follow to get there: : Setting things up and getting ready to go. Installation : Getting everything in order for a smooth operation. Configuration : Making sure you're securely connected. Authentication : Asking the blockchain for information. Querying the Flow Blockchain : Preparing your account for action. Setting up the Account : Modifying the blockchain as needed. Mutating the Flow Blockchain : Keeping track of your code. Final Step Are you ready to dive into creating your Collectibles Portal's front end? Let's get started! 1. Installation First, we need to create a React app using a tool called Yarn. To do this, open your terminal and type: yarn create react-app web After pressing Enter, your computer will begin creating a new React app inside your project. When it's done, you can open your new app. This is what your React app looks like. 2. Configuration We'll use the to manage wallet connections, run scripts, and send transactions in our application. Flow Client Library (FCL) To get started, let's install FCL for our app by running the following command: npm install @onflow/fcl --save After installing FCL, we need to configure it. Here's what you need to do: Create a file named config.js in the src folder. In this file, set up the configuration for the FCL, such as specifying the Access Node and wallet discovery endpoint. This helps you choose between using a testnet or a local emulator. Add the following code to the config.js file: import { config } from "@onflow/fcl";

config({
  "accessNode.api": "https://rest-testnet.onflow.org", // Mainnet: "https://rest-mainnet.onflow.org"
  "discovery.wallet": "https://fcl-discovery.onflow.org/testnet/authn" // Mainnet: "https://fcl-discovery.onflow.org/authn"
}) Now, you're all set up to use the FCL in your app. 3. Authentication To verify a user's identity in an app, you can use several functions. For logging in use . fcl.logIn() For signing up use . fcl.signUp() For logging out call . fcl.unauthenticate() After logging in, an object named is set up. This object allows you to watch for changes in user data, perform transaction signings, and more. Let's add several buttons for sign up/login and also subscribe to changes on the . When the user is updated (which will happen after authentication), we'll set the user state in our component to reflect this. To demonstrate user-authenticated sessions, we'll conditionally render a component based on whether the user is or is not logged in. Your code should look like this: fcl.currentUser currentUser import React from "react";
import './styles/App.css';
import "./config";
import * as fcl from "@onflow/fcl";

const App = () => {

  const [user, setUser] = useState({loggedIn: null})

  useEffect(() => fcl.currentUser.subscribe(setUser), [])

  const AuthedState = () => {
    return (
      <div>
        <div className="sub-text">Wallet Address: {user?.addr ?? "No Address"}</div>
        <button className="cta-button connect-wallet-button" onClick={fcl.unauthenticate}>
          Log Out
        </button>
      </div>
    )
  }

const UnauthenticatedState = () => {
    return (
        <button className="cta-button connect-wallet-button" onClick={fcl.logIn}>
          Log In
        </button>
    )
  }
  return (
    <div className="App">
      <div className="container">
        <div className="header-container">
          <p className="header gradient-text">Flow Collectibles Portal</p>
          <p className="sub-text">Upload your favorite collectibles to the Flow Blockchain</p>
          {user.loggedIn ? <AuthedState /> : <UnauthenticatedState />}
        </div>
      </div>
    </div>
  );
};

export default App; Now, you can either log in or sign up as a user and then log out. When you log in or sign up, a small window will pop up. In that window, you can pick a wallet provider. For this instance, let's pick the Blocto wallet to make an account. After you successfully prove it's you, you will see your wallet address on the screen like this: 4. Querying the Flow Blockchain When you're , a key task is to retrieve data from the blockchain and the smart contracts it holds. Let's understand how we can query a contract to find out about a specific NFT. Here's a simplified breakdown of the steps involved: building a dapp Import Contracts: First, you need to import the relevant contracts used in your dapp. In this example, we're interested in querying the NFTs, so we're importing the NonFungibleToken and Collectibles contracts. Use FCL: You create a function called queryNFT, which is asynchronous. Inside this function, you use the fcl.query function to query the blockchain. Set the result of the script to the app state in React so we can display the NFT in our browser. Display: Display "No NFT" if nothing was found. Take a look at the new code. We'll explain each new piece as we go. const [user, setUser] = useState({loggedIn: null})
const [nft, setNFT] = useState() //NEW

useEffect(() => fcl.currentUser.subscribe(setUser), [])

  // NEW
  const queryNFT = async () => {
    const nft = await fcl.query({
      cadence: `
        import NonFungibleToken from 0x631e88ae7f1d7c20
        import Collectibles from 0x490b5c865c43d0fd

        pub fun main(user: Address, id: UInt64): &NonFungibleToken.NFT? {
          let collectionCap= getAccount(user).capabilities
                      .get<&{Collectibles.CollectionPublic}>(/public/NFTCollection) 
                      ?? panic("This public capability does not exist.")

          let collectionRef = collectionCap.borrow()!

          return collectionRef.borrowNFT(id: id)
        }
      `,
      args: (arg, t) => [arg(user.addr, t.Address)]
    })

    setNFT(nft ?? 'No NFT')
  }

const AuthedState = () => {
    return (
      <div>
        <div className="sub-text">Wallet Address: {user?.addr ?? "No Address"}</div>
        <div className="sub-text">NFT: {nft ?? "--"}</div>
       <button className="cta-button" onClick={queryNFT}>View NFT</button>
       <button className="cta-button connect-wallet-button" onClick={fcl.unauthenticate}>
          Log Out
        </button>
      </div>
    )
  } A few things happened. In our AuthedState component, we added a button to send a query to view the NFT and a div to display the result above it. You can see the corresponding useState initialization at the top of the component. We also built out the actual query inside of the queryNFT method. Let's take a look at it more closely. await fcl.query({
      cadence: `
        import NonFungibleToken from 0x631e88ae7f1d7c20
        import Collectibles from 0x490b5c865c43d0fd

        pub fun main(user: Address, id: UInt64): &NonFungibleToken.NFT? {
          let collectionCap= getAccount(user).capabilities
                      .get<&{Collectibles.CollectionPublic}>(/public/NFTCollection) 
                      ?? panic("This public capability does not exist.")

          let collectionRef = collectionCap.borrow()!

          return collectionRef.borrowNFT(id: id)
        }
      `,
      args: (arg, t) => [arg(user.addr, t.Address)]
    }) Inside the query, you'll see we set two things: cadence and args. Remember that the Cadence code is specific to Flow's smart contract language, and you don't need to dive too deep into it unless you're working on writing more complex smart contracts. The key takeaway is that you're querying the blockchain to get NFT information based on the user's account address and the NFT ID. When you click the "View NFT" button, you'll see the NFT details, or if the NFT doesn't exist, it will display "No NFT". 5. Setting up the Account We use a process called "collection initialization” to set up a Collection resource in the user’s account. (We covered what a resource is in Part 1. You can review that here.) To make this happen, we’ll add a new function called "initAccount.” We'll use a code that asks, "Hey, does this account already have a Collection? If not, let's create one." We use something called a "transaction" to do this. Think of a transaction as a special task we want the system to do for us. Now, let's talk about how we write this code. Instead of saying "query," we use the word "mutate" for transactions. Since doing this task has a cost, we need to provide some information to Flow. We tell Flow who is suggesting the task, who is approving it, who is paying for it, and how much they're willing to pay. These parts are called "proposer," "authorizer," "payer," and "limit." Let's take a look at what the function to set up an account looks like. const initAccount = async () => {
  const transactionId = await fcl.mutate({
    cadence: `
    import Collectibles from 0x490b5c865c43d0fd

    transaction {
    prepare(signer: AuthAccount) {
        if signer.borrow<&Collectibles.Collection>(from: Collectibles.CollectionStoragePath) == nil {
            let collection <- Collectibles.createEmptyCollection()
            signer.save(<-collection, to: Collectibles.CollectionStoragePath)
            let cap = signer.capabilities.storage.issue<&{Collectibles.CollectionPublic}>(Collectibles.CollectionStoragePath)
            signer.capabilities.publish( cap, at: Collectibles.CollectionPublicPath)
        }
    }
    `,
    payer: fcl.authz,
    proposer: fcl.authz,
    authorizations: [fcl.authz],
    limit: 50
  })

  const transaction = await fcl.tx(transactionId).onceSealed()
  console.log(transaction)
} You can see the new fields we talked about. You'll also notice , which is shorthand for "use the current user to authorize this transaction.” You could also write it as . fcl.authz fcl.currentUser.authorization For this example, we'll keep it simple with the user being each of these roles. You'll also notice we are awaiting a response with our transaction data by using the syntax . This will return when the blockchain has sealed the transaction and it's complete in processing and verifying it. Now, your App.js file should look like this. (we also added a button for calling the function in the ): fcl.tx(transactionId).onceSealed() initAccount AuthedState const App = () => {

  const [user, setUser] = useState({loggedIn: null})
  const [nft, setNFT] = useState() //NEW
  const [txnStatus, setTxnStatus] = useState(null)

  useEffect(() => fcl.currentUser.subscribe(setUser), [])

  // NEW
  const queryNFT = async () => {
    const nft = await fcl.query({
      cadence: `
        import NonFungibleToken from 0x631e88ae7f1d7c20
        import Collectibles from 0x490b5c865c43d0fd

        pub fun main(user: Address, id: UInt64): &NonFungibleToken.NFT? {
          let collectionCap= getAccount(user).capabilities
                      .get<&{Collectibles.CollectionPublic}>(/public/NFTCollection) 
                      ?? panic("This public capability does not exist.")

          let collectionRef = collectionCap.borrow()!

          return collectionRef.borrowNFT(id: id)
        }
      `,
      args: (arg, t) => [arg(user.addr, t.Address)]
    })

    setNFT(nft ?? 'No NFT')
  }

  // NEW
  const initAccount = async () => {
  const transactionId = await fcl.mutate({
    cadence: `
    import Collectibles from 0x490b5c865c43d0fd

    transaction {
    prepare(signer: AuthAccount) {
        if signer.borrow<&Collectibles.Collection>(from: Collectibles.CollectionStoragePath) == nil {
            let collection <- Collectibles.createEmptyCollection()
            signer.save(<-collection, to: Collectibles.CollectionStoragePath)
            let cap = signer.capabilities.storage.issue<&{Collectibles.CollectionPublic}>(Collectibles.CollectionStoragePath)
            signer.capabilities.publish( cap, at: Collectibles.CollectionPublicPath)
        }
    }
    `,
    payer: fcl.authz,
    proposer: fcl.authz,
    authorizations: [fcl.authz],
    limit: 50
  })

  const transaction = await fcl.tx(transactionId).onceSealed()
  console.log(transaction)
}

  const mintNFT = async () => {
  const transactionId = await fcl.mutate({
    cadence: `
      import Profile from 0xProfile

      transaction(name:String, image:String){
        let receiverCollectionRef: &{NonFungibleToken.CollectionPublic}
        prepare(signer:AuthAccount){
          self.receiverCollectionRef = signer.borrow<&Collectibles.Collection>(from: Collectibles.CollectionStoragePath)
              ?? panic("could not borrow Collection reference")
        }
        execute{
          let nft <- Collectibles.mintNFT(name:name, image:image)
          self.receiverCollectionRef.deposit(token: <-nft)
        }
      }
    `,
    args: (arg, t) => [arg("Pikachu", t.String),arg("https://cdn.pixabay.com/photo/2020/08/29/16/08/pikachu-5527377_640.jpg",t.String)],
    payer: fcl.authz,
    proposer: fcl.authz,
    authorizations: [fcl.authz],
    limit: 50
  })

  fcl.tx(transactionId).subscribe(res => setTxnStatus(res.status))
}


    const AuthedState = () => {
    return (
      <div>
        <div className="sub-text">Wallet Address: {user?.addr ?? "No Address"}</div>
        <div className="sub-text">NFT: {nft ?? "--"}</div>
        <div className="sub-text">Transaction Status: {txnStatus ?? "--"}</div>
        <button className="cta-button" onClick={queryNFT}>View NFT</button>
        {/*NEW*/}
        <button className="cta-button" onClick={initAccount}>Create Collection</button>
        <button className="cta-button" onClick={mintNFT}>Mint</button>
        <button className="cta-button connect-wallet-button" onClick={fcl.unauthenticate}>
          Log Out
        </button>
      </div>
    )
  }


  const UnauthenticatedState = () => {
    return (
        <button className="cta-button connect-wallet-button" onClick={fcl.logIn}>
          Log In
        </button>
    )
  }

  return (
    <div className="App">
      <div className="container">
        <div className="header-container">
          <p className="header gradient-text">Flow Collectibles Portal</p>
          <p className="sub-text">Upload your favorite collectibles to the Flow Blockchain</p>
          {user.loggedIn ? <AuthedState /> : <UnauthenticatedState />}
        </div>
      </div>
    </div>
  );
};

export default App; Click the "Init Account" button. This will prompt your wallet to ask for permission to complete a transaction. Once you give permission, you'll notice a message about the transaction in the console. (Make sure the console is open.) This might take a short while. Once the message shows the result of the transaction, you can use the transactionId to find out more details about the transaction using a . block explorer 6. Mutating the Flow Blockchain After initializing the account and setting up the collection resource into it, we now and store it in the collection. To do this, we will write another transaction that allows us to mint the NFT. Everything else looks the same in the following code except for one thing: We'll subscribe to the status changes instead of waiting for them to be sealed after the mutate function returns. It looks like this: mint the NFT const executeTransaction = async () => {
const transactionId = await fcl.mutate({
    cadence: `
      import NonFungibleToken from 0x631e88ae7f1d7c20
      import Collectibles from 0x490b5c865c43d0fd

      transaction(name:String, image:String){
        let receiverCollectionRef: &{NonFungibleToken.CollectionPublic}
        prepare(signer:AuthAccount){
          self.receiverCollectionRef = signer.borrow<&Collectibles.Collection>(from: Collectibles.CollectionStoragePath)
              ?? panic("could not borrow Collection reference")
        }
        execute{
          let nft <- Collectibles.mintNFT(name:name, image:image)
          self.receiverCollectionRef.deposit(token: <-nft)
        }
      }
    `,
    args: (arg, t) => [arg("Pikachu", t.String),arg("https://cdn.pixabay.com/photo/2020/08/29/16/08/pikachu-5527377_640.jpg",t.String)],
    payer: fcl.authz,
    proposer: fcl.authz,
    authorizations: [fcl.authz],
    limit: 50
  })

  fcl.tx(transactionId).subscribe(res => setTransactionStatus(res.status))
} Here you can see our two arguments which are "Pikachu” and image URL “ ”. At the bottom, we've called the subscribe method instead of onceSealed. Let's see how that works inside our whole app.js file. Let’s also set the status to our React component's state so we can see what state we're in on screen. https://cdn.pixabay.com/photo/2020/08/29/16/08/pikachu-5527377_640.jpg Conclusion Well done! You've finished part 2 of the Collectibles portal project. In summary, we focused on building the front end of our Collectibles portal. We did this by: Creating an app with React.js Connecting with Flow Wallet Creating our very own NFTs for minting Viewing NFTs by asking the blockchain Now you have a better understanding. Keep up the fantastic effort! Have a really great day! Also published . here

Build an NFT Website Using The Flow Blockchain and Cadence [Part 2]

Stories, News & Mentions about KADENCE

Kadence’s Stories on HackerNoon