Blockchain

Even among cryptocurrency enthusiasts, non-fungible tokens (NFTs) aren't the most well-known or understood piece of the decentralized ledger system. 
NFTs may seem abstract and difficult to understand, but many applications for these tokens make them essential in the crypto space and beyond. If you're unfamiliar with this type of token, you came to the right place as this post breaks down everything you need to know about NFTs! Give it a read and discover what NFTs are and how they relate to blockchain and cryptocurrency technology.

### What are non-fungible tokens (NFTs)?

Blockchain and cryptocurrency are two buzzwords that have been thrown around for a while now. Although NFTs combine both of these emerging technologies, there's still a lot of confusion about what exactly they are. Keep in mind that even though the NFTs are based on the same blockchain technology as cryptocurrencies, they are not a currency. So let’s get right on it and let’s see what Non-Fungible tokens actually are.

The term non-fungible refers to something that another similar object cannot replace i.e they can only ever be replaced by themselves — or not at all. And that is precisely what makes them unique.  **A non-fungible token (NFT) is a one-of-a-kind digital asset that represents ownership of physical or virtual items such as art, video clips, music, and so on.**  

Simply put, NFTs are digital proof of ownership for any given item. NFTs are securely recorded on a blockchain — the same technology that lies behind cryptocurrencies — ensuring that the asset is unique. To shed some light on the whole thing, let’s have a look at some of the examples of NFTs.

![Picture2.jpg](https://strapi.suprabit.eu/uploads/Picture2_45375cdc1c.jpg)
Source: [Instagram (@adamsackstoons)](https://www.instagram.com/p/CVK066CPshA/)

### Examples of NFTs

[Cryptokitties](https://www.cryptokitties.co/), [CryptoPunks](https://www.larvalabs.com/cryptopunks), [Rare Pepes ](http://rarepepedirectory.com/) are all examples of non-fungible tokens.  NFT was first introduced on the Ethereum blockchain protocol as a concept that allows you to mint and trade virtual assets that are unique, but now many other blockchains like Polygon, Cardano, or Kusama, to name a few, have also their own NFT implementations. 

Let’s have a closer look at Cryptokitties, digital cats that have unique genes. Think of them as crypto-collectables. Each is a one-of-a-kind digital asset built on Ethereum's blockchain and entirely owned by you. They can't be replicated, taken away, or destroyed. They can be, however, transferred from one digital wallet to another.

As defined by the Ethereum ERC721 standard, non-fungible tokens like Cryptokitties can be identified via a specific token ID - and only exist once within Ethereum blockchain. 

NFTs are today what football cards were back in the day - the latest collectables. While the latter was traded in person, NFTs are easily bought and sold online. Which, in turn, quickly made them a lucrative business. [The art world particularly profited from the sale of NFTs](https://www.nftsstreet.com/most-expensive-nfts-ranked/). Below are a few examples you probably heard about:

●	[Beeple](https://cryptoart.io/artist/beeple), a digital artist, sold the first purely digital work of art called "Everydays—the First 5000 Days" at Christie's for $69.3 million.
![Picture3.jpg](https://strapi.suprabit.eu/uploads/Picture3_42b577f7ff.jpg)
Source: [Wikipedia](https://en.wikipedia.org/wiki/Everydays:_the_First_5000_Days)

●	For $2.9 million, Twitter CEO auctioned off an NFT of his first tweet.
![Picture4.png](https://strapi.suprabit.eu/uploads/Picture4_aadbe91d09.png)
Source: [Twitter (@jack)](https://twitter.com/jack/status/20?ref_src=twsrc%5Etfw%7Ctwcamp%5Etweetembed%7Ctwterm%5E20%7Ctwgr%5E%7Ctwcon%5Es1_&ref_url=https%3A%2F%2Fwww.cnbc.com%2F2021%2F03%2F22%2Fjack-dorsey-sells-his-first-tweet-ever-as-an-nft-for-over-2point9-million.html)

●	At Sotheby's first curated NFT sale, a CryptoPunk NFT was sold for $1.8 million.
![Picture5.jpg](https://strapi.suprabit.eu/uploads/Picture5_a062679f34.jpg)
Source: [Twitter (@Sothebys)](https://twitter.com/Sothebys/status/1402996062474760193?ref_src=twsrc%5Etfw%7Ctwcamp%5Etweetembed%7Ctwterm%5E1402996062474760193%7Ctwgr%5E%7Ctwcon%5Es1_&ref_url=https%3A%2F%2Fmarkets.businessinsider.com%2Fnews%2Fcurrencies%2Fcryptopunk-nft-covid-alien-draftkings-sothebys-auction-fungible-token-2021-6)

●	$208,000 was paid for 20-second footage of LeBron James' "Cosmic Dunk #29."

### How do NFTs work?
To understand NFTs, we could look at fungible and non-fungible items from a financial perspective. Today, most people think of cash as fungible—if I give you a $5 bill and you give me back another $5 bill, nothing really changed in terms of value as all the 5$ bills are the same. We don’t care about the dollar bill as a paper-based physical item, we care only about its value.
In contrast, collectables and antiques provide value as individual units; these kinds of goods aren't interchangeable with others with similar or even the same features (like dollar bills). 
Non-fungible tokens work on blockchains like Ethereum, but they are totally different blockchain assets with different features. 

### How are NFTs used?

There are three main ways NFTs can be used: as collectables, for identity, and ownership. 

**Collectibles** are non-fungible assets that can be owned and traded on NFT marketplaces. 

**Identity** refers to non-fungible personal information about an individual or business, such as educational history or employment background. 

**Ownership** refers to the possession of a physical or digital asset represented by an NFT. By trading NFT you’re actually transferring ownership of those assets. This could include things like real estate, art, intellectual property, etc. 

As time goes on, we will likely see many more creative uses for digital NFTs.

### Difference between cryptocurrency and NFTs

Cryptocurrencies and NFTs both rely on the same blockchain technology. As a result, NFT markets may also compel customers to use cryptocurrencies to acquire NFTs. 
Cryptocurrencies aspire to function as currencies by holding value or allowing you to purchase and sell items. Cryptocurrency tokens are fungible, and comparable to conventional currencies like the US dollar. 
On the flip side, NFTs are tailored to generate one-of-a-kind tokens that may be used to demonstrate ownership and communicate rights over digital products.

### Online exchange and marketplaces to buy NFTs

[OpenSea](https://opensea.io/) and [Nifty Gateway](https://niftygateway.com/) are widely known marketplaces to trade NFTs. With a user base of close to 2 million accounts on OpenSea, it is by far one of the biggest marketplaces for NFTs at the moment. 

**Foundation**: Foundation happens to be an NFTs marketplace, and in order to join the platform, a user must be invited by another user who is already a member.

**Nifty Gateway**: This is an art-focused NFTs marketplace that works with athletes, brands, and creators.

**OpenSea**: When you want to mention one of the largest marketplaces for a wide range of NFTs collectables, you can think about OpenSea.

**Rarible**: If you're looking for an art-focused NFTs platform, Rarible is an ideal choice that rewards members with its own token - RARI.  

### Key takeaways

When you think of cryptocurrencies, your mind surely jumps to Bitcoin and other alt-coins. But blockchain is more than just digital currencies; it's a protocol for creating unique data sets within a network that are time-stamped, cryptographically secured, and immutable. 
In other words, it is also about taking physical assets—diamonds, Picassos, gold, and digital assets like artwork and turning all of them into non-fungible tokens (NFTs). NFTs can be stored on an Ethereum or a number of other public ledgers. Each token would be identified by a unique ID number and tied to everything from value to ownership rights. 
In the future, the idea is that you'll have NFTs representing everything from your passport, driver's license, game collectables, real estate ownership, you name it! So, is there any reason we shouldn't extend the concept of NFT beyond its borders? We think not! Stay tuned and wait to see what the Suprabit team has been working on.

small_Picture3.jpg

thumbnail_Picture3.jpg

Picture3.jpg

We want you to enter the world of non fungible tokens! A new type of blockchain based asset is taking some of the well established markets by storm. Find out why and what is our stake in it.

Non-Fungible Tokens (NFTs) Explained

React

Development

At first, the transition seemed scary since the two fields appeared to be worlds apart. However, as I delved deeper, I realized that embedded and mobile development share more similarities than I initially thought. So, let's explore how these two fields intersect and the skills you can use to excel in both.

# Things in common:

## Hardware limitations

Embedded developers are accustomed to working in a resource-constrained environment where every byte of memory and every clock cycle counts. This not only helps in writing efficient and optimized code but also develops a valuable skill set that can be leveraged in mobile development. Similarly, mobile development also requires optimizing battery life and processing power, making the transition from embedded to mobile development easier.

## Debugging skills

Debugging skills are essential for any type of software development. While there are several debugging tools available, such as logic analyzers or JTAG, what separates the experts from the novices is their methodical and analytical way of thinking, combined with patience and focus. A great developer can navigate through the maze of code, identifying and resolving issues efficiently and effectively, regardless of the technology.

## Knowledge of hardware interfaces

As an embedded developer, understanding hardware components and configurations is necessary for dealing with real-time issues. Power optimization is a key objective, given that embedded devices often rely on battery power. Similarly, mobile developers need to understand hardware configuration to troubleshoot communication failures and connectivity issues. Also, battery-related issues can bring down mobile applications, and knowledge of power optimization is essential to help track and resolve battery-related issues, as it can be the difference between a successful or underperforming app. 

## Handling interrupts and callbacks

Handling interrupts is common in embedded development, where a single device can handle multiple events, such as timers, buttons, and sensors. Since every interrupt is important and any of them can happen at any time, it is essential to have strong knowledge and a deep understanding of how to handle them properly. In mobile development, user inputs are handled as interrupts. Therefore, experience in embedded development is useful in learning how to handle user events in the mobile app properly. 

Callbacks are another fundamental concept in embedded development, where they can be categorized as synchronous and asynchronous. Mastering callback handling enables developers to manage events more effectively. In mobile development, asynchronous programming is crucial since most of the user interrupts in the mobile app are event-based.

# Biggest differences:

## UI

The focus of embedded development is creating software that integrates with the system hardware. Usually, the user interface on the embedded device doesn't exist and the user can interact with the device through small screens or buttons. However, in mobile development, creating an intuitive and appealing user interface is a focused aspect of the development process. As mobile applications heavily rely on user interaction, designing a user-friendly interface is key to delivering an enjoyable user experience.

## Devices

Embedded development focuses on designing and creating software that runs on one specific device, usually having a resource-constrained environment. Most of the embedded devices are very different so the software can be used only on the device that it's made for. On the other hand, mobile development is focusing on creating software that can work on a range of devices with different hardware specifications. The user might have different devices with different screen sizes, resolutions, and processing power, so the software must be flexible enough to work on all of them. Mobile development requires more consideration of device compatibility, while embedded development can be more tailored to the specific device it's running on.

# Challenges I faced when learning mobile development

As an embedded developer, I started my career mainly using C and C++ programming languages. For mobile development, I used [JavaScript](https://www.javascript.com/) and [React Native](https://reactnative.dev/) which were unfamiliar territories. Learning a new language is always tricky at first, but as they say, practice makes perfect, and with every new task, I gained more experience and confidence in the language.

Another challenge was making an application that is working on both iOS and Android platforms. In the end, as an embedded developer, I was focused exclusively on hardware development, so there were a lot of interesting challenges with creating user interfaces. But hey, what's life without a little challenge, right? 

# Advice to embedded developers interested in learning mobile development

As always, start by focusing on the fundamentals of mobile development. Take a common framework like React Native and learn its syntax. Then, try your hand at developing a simple app like a memory game or notes app, where you can learn more about user interface and asynchronous programming. After that, give yourself a bigger challenge and make an app that uses multiple screens, databases or even a hardware integration like BLE. Remember, the best way to learn is through trial and error, so don't be afraid to make mistakes and learn from them.

In conclusion, don't let the differences between embedded and mobile development discourage you from exploring new horizons. Instead, see mobile development as an opportunity to expand your programming skills and add another layer of expertise to your repertoire. Many of the skills you've acquired as an embedded developer are transferable to mobile development, such as memory management, power optimization, and debugging techniques. Embrace this challenge and use your experience to your advantage. Good luck on your mobile development journey!

Learning JavaScript and React Native as an Embedded Developer

large_Embedded to Mobile.jpg

medium_Embedded to Mobile.jpg

small_Embedded to Mobile.jpg

thumbnail_Embedded to Mobile.jpg

Embedded to Mobile.jpg

Picture this: I'm an embedded developer who's used to working on exciting projects involving smart building management. But after some time, I decided to shake things up and venture into the world of mobile development. 

Embedded Developer's Guide To Transitioning To Mobile Development



<div style="width:70%; margin:auto;">
<h2> What are embedded systems? </h2>
Embedded systems are computer systems with a specific function within a larger system. This includes all computing systems, such as home appliances, digital watches, cameras, avionics, and medical devices, except for PCs and smartphones. When classifying embedded systems by their main computing component, two of the most common types are microcontroller (MCU) and a microprocessor (MPU/CPU) based systems. There are also DSP, FPGA and custom ASIC-based systems. 


Microcontroller-based embedded systems are typically programmed either without an operating system, known as "bare metal," or with a real-time operating system (RTOS). Microcontrollers are cost-effective, single-chip computers that include a CPU, memory, and input/output capabilities on a single integrated circuit (IC). However, their specifications are limited compared to standard PCs, with less than 1MB of RAM and less than 8MB of flash memory, and typically only one CPU core with a frequency of less than 500MHz. Many 32-bit microcontrollers today are based on ARM Cortex-M CPUs.

In contrast, microprocessor-based systems, which are based on more powerful CPUs such as ARM Cortex-A, run Linux and have specifications more similar to PCs or smartphones. These systems, known as single-board computers, feature RAM, eMMC (flash), and various peripheral chips on the board, rather than on a single IC.

![1.png](https://strapi.suprabit.eu/uploads/1_a622eb8f94.png)

While microcontroller-based systems are generally more affordable and energy-efficient than embedded Linux devices, they also have more limited computing capabilities and feature sets. This blog post will focus on the unique characteristics of microcontroller-based embedded systems. However, as part of the Internet of Things (IoT) ecosystem, modern embedded systems are expected to have a range of features such as wireless communication, internet connectivity, and advanced sensors and actuators, all while maintaining cost and power efficiency. Careful consideration of both hardware and software is crucial for the successful design and development of these devices.

<h3> Optimizing power consumption </h3>
When selecting components for a wireless embedded device, it is important to consider factors such as suitability for the intended application, software and community support, market availability and cost. The microcontroller, RF communication chip, and sensors/actuators are the main components to evaluate. Factors like deep sleep functionality, communication interfaces, security options, processing speed, and memory of the microcontroller should all be taken into account to ensure that the device's requirements are met in the most optimal way possible.

<h3>MCU</h3>
Low-power MCUs on the market can typically achieve current consumption below 1 μA in their sleep modes. Some of these include ST's STM32L0xx, Silicon Labs' C8051F98x, Microchip's SAM Lx and TI's MSP430.
In our recent project, we used STM32L051 MCU and in its Stop mode, we were able to achieve 1.3 μA with Low Power Timer and Watchdog running.



 ![Microchip.png](https://strapi.suprabit.eu/uploads/Microchip_a7739c6ed3.png)


<h3> RF communication chip </h3>
When choosing an RF communication chip, it's important to select an appropriate wireless communication protocol that takes into account factors such as power consumption, range, and throughput. Factors that will affect the power consumption of the device are protocol frequency (sub-GHz, 2.4 GHz, 5 GHz, etc.), data packet length, the number of messages being sent within a certain timeframe, and signal power. Operating frequency affects range, power consumption, and throughput. Lower frequencies (sub-GHz) have better range and lower power consumption, while higher frequencies have better throughput. It's essential to keep the number of messages sent within a certain timeframe as low as possible for battery-powered devices, usually 1-2 messages every 10+ minutes. Smaller data packet length increases the throughput and power efficiency of a protocol, as it takes less time to transmit information and keeps the RF transceiver in active mode. With greater power, the range is increased, but so is power consumption. Low-power RF chips on the market can typically achieve current consumption in the nA or few μA range in their sleep modes, making them a good choice for battery-powered devices. In our recent project, we used AX5243 sub-GHz RF chip at 868 MHz with a custom protocol. In its Powerdown mode, we were able to achieve 0.8 μA.

![2.png](https://strapi.suprabit.eu/uploads/2_d19cc36535.png)
When choosing sensors/actuators, their idle current consumption should also ideally be in nA or worst-case few μA range.

Besides hardware, software choices and optimizations can also greatly affect the power consumption of a device; choosing the appropriate sleep mode of the MCU and RF chip, minimizing time spent in running mode of the MCU and RF chip, using only the lowest-power MCU timer while the device is in idle mode, setting MCU peripherals in low-power mode, etc.



<h5>Here are some important takeaways from our recent project with STM32L051:</h5>
<div style="background-color: #1D3656; padding:10px; border-radius: 4px; width:70%; margin:auto;">

</div>

<div style="background-color: #1D3656; padding:10px; border-radius: 4px; width:70%; margin:auto;">
<ul style="font-size:16px;">
<li  style="color:#ffffff">setting all unused GPIOs as analog inputs has reduced average current consumption by a few μA</li>
<br/>
<li style="color:#ffffff">ADC needed to be powered off after each measurement, otherwise it would add ~35 μA to average current consumption in sleep mode </li>
<br/>
<li style="color:#ffffff">although Standby mode has the lowest current consumption, in this mode SRAM and register contents are lost and only certain GPIOs can wake up MCU, so we've used Stop mode</li>
<br/>
<li style="color:#ffffff">in Stop mode, LSI is the only oscillator that works (and only timers whose clock source is LSI can work</li>
<br/>
<li style="color:#ffffff">LSI is unprecise, but it can be calibrated using an internal MSI oscillator and more precise e.g. periodic interval measurements can be achieved</li>
</ul> 
</div>




Wireless embedded devices transmit data in periodic intervals and spend the rest of the time in sleep mode, which minimizes the amount of time the microcontroller and RF transceiver are running and consuming power. However, if the running time is too long, it can significantly impact the average power consumption and shorten the device's battery life. To optimize power consumption, it's important to keep the duration of running time to a minimum, whether due to a periodic interval or an interrupt.


<h5>Here are some methods that we've used to minimize the duration of running time: </h5>
<div style="background-color: #1D3656; padding:10px; border-radius: 4px; width:70%; margin:auto;">
<ul style="font-size:16px;">
<li  style="color:#ffffff">compiler optimizations</li>
<br/>
<li style="color:#ffffff"> removing printfs/serial outputs  </li>
<br/>
<li style="color:#ffffff">making sure there's no polling or register flag checking that keeps device in running mode</li>
<br/>
<li style="color:#ffffff">checking whether higher MCU frequency (with higher current consumption, but shorter processing time) is better for power consumption</li>
<br/>
<li style="color:#ffffff">using constants/hard coded values instead of calculations if possible</li>
</ul> 
</div>

It's important to select an RTOS mode that is optimized for low power consumption, especially as the number of features increases, as RTOS is often required in such cases.

Finally, tools that we've used to measure current consumption are Otii Arc and a multimeter (just to double-check Otii Arc measurements). Also, it's useful to have measurement ports on PCB for measuring the current consumption of certain components separately (MCU, RF transceiver, sensors).

![pic1.png](https://strapi.suprabit.eu/uploads/pic1_6e7794a3ee.png)


With whole PCB average current consumption being under 5 μA (idle mode consumption below 2.5 μA), these devices can ideally last on one e.g. CR2032 battery (~230 mAh) for more than 5 years.

<h2> Optimizing memory usage </h2>
As projects need to be profitable, prices of the components are very important. But with lower prices, MCUs usually also come with smaller amounts of RAM and Flash memory. For example, STM32L051 has 8 kB of RAM and 64 kB of Flash memory . As the complexity of the application increases and the feature set expands, optimizing memory usage becomes necessary for these microcontrollers.

<h5>Here are some methods of optimizing memory usage that we've used in our recent project: </h5>
<div style="background-color: #1D3656; padding:10px; border-radius: 4px; width:70%; margin:auto;">

</div>


<div style="background-color: #1D3656; padding:10px; border-radius: 4px; width:70%; margin:auto;">
<ul style="font-size:16px;">
<li  style="color:#ffffff">compiler flags</li>
<ul>

<li style="color:#ffffff; opacity: 70%;">we've used GCC's <span style="font-weight:bold">arm-none-eabi</span> toolchain: <span style="font-weight:bold">-ffunction-sections, -fdata-sections, -fno-exceptions, -fno-rtti, -Os, --specs=nano.specs</span> (for using nano version of newlib)</li>
</ul>
<br/>
<li style="color:#ffffff">check out functions with the highest memory usage and try to optimize them</li>
<ul>
<li style="color:#ffffff; opacity: 70%;">for <span style="font-weight:bold">arm-none-eabi</span> toolchain: <span style="font-weight:bold">arm-none-eabi-readelf -s elf_name.elf</span></li>
</ul>
<br/>
<li style="color:#ffffff"> disable unused RTOS features</li>
<br/>
<li style="color:#ffffff">remove unnecessary printfs</li>
<br/>
<li style="color:#ffffff">remove double and float arithmetic <span style="font-weight:bold">__aeabi_</span>functions if possible</li>
</ul> 
</div>



That wraps up this blog post on memory and power consumption optimization for microcontroller-based embedded systems. We hope it'll turn out to be helpful in your current and future embedded projects too!

</div>

large_IOT BLOG (2).png

medium_IOT BLOG (2).png

small_IOT BLOG (2).png

thumbnail_IOT BLOG (2).png

IOT BLOG (2).png

In this blog post, we'll explore various ways of optimizing power consumption and memory usage of wireless embedded devices with examples from one of our recent projects.

Optimizing power consumption and memory usage of wireless embedded devices


## Motivation
Modern Smart Building Management solutions are fairly complex, comprising of a number of software modules supporting a variety of, often proprietary, protocols. When you add in all the front and back-end devices, automation stations, sensors and gateways, it can all seem like a real pain in the neck. But there is a clear economic benefit as functional smart building solutions are able to optimize energy consumption, provide better living environments and better security for building occupants, bringing your business closer to achieving that net zero goal. However, there are new issues regarding data security popping up every day, due to complexity, Internet integration and, more often than usual, slow adaptation to the newest technology stack. Traditional solutions relied on private networks where security was not such a big deal, but now, as every smart building solution provider offers Internet connectivity, the security paradigm changed. That left most solutions vulnerable to inside and outside attacks as well as data breaches. On the other hand, with the advancement of the Internet, many new use cases emerged that have the potential to significantly improve the ROI of smart building management solutions and enable more building automation in favour of building occupants and investors.  

This presents an obvious need to introduce a new data infrastructure layer to your solutions that will guarantee data security and data availability within a smart building management market. 

## Lavsa
Lavsa is a decentralized storage solution for smart building management, developed using blockchain and IoT technology. Our solution is taking in a stream of data and then replicating that data to every node in a private blockchain network. The newly added data sets are hashed and the hash is published on permissionless public blockchains like Ethereum, Polygon etc. By using blockchain(s) as an additional layer of security, we are improving integrity, immutability and availability. This is a step up from the traditional database model because, in Lavsa, every piece of data is distributed across a number of nodes and additionally hashed on a public blockchain, making it virtually impossible to fake, change or delete the data. At the same time, smart contracts are used to improve data relevancy, white and black lists and support new use case scenarios.  




![blockchain.svg](https://strapi.suprabit.eu/uploads/blockchain_77fbf6c69c.svg)





## Lavsa Goals
- Put the building data security, integrity and availability at the forefront of the Smart Building and IoT initiatives
- Establish trust among stakeholders of the building automation projects
- Enable higher level of automation
- Support integration with third-party building automation and business solutions
- Enable new disruptive business models 
 

## Lavsa Use Cases

Lavsa puts the data produced by a variety of smart building devices at the forefront of the Smart Building economy enabling new disruptive business models like 
- Data monetization and data markets
- AI solutions based on relevant building data
- Regulatory compliance
- Support for ESG initiatives 
- M2M payments
- Building Automation Infrastructure As a Service

If you have any questions regarding Lavsa, or if you are interested in discussing various Smart Building use cases - feel free to [contact us](https://suprabit.eu/contact) and let's give it a thought together.



large_androfin-min.png

medium_androfin-min.png

small_androfin-min.png

thumbnail_androfin-min.png

androfin-min.png

Back in 2018., the blockchain hype started to gain traction outside of the crypto scene and a number of enthusiasts proposed using blockchain for different business use cases. We had a vision to provide every party with relevant and tamper-proof data delivered by smart building sensors and devices. That data has to be so good that somebody wants to pay for it. Once you bought it, you want to have it ready at your disposal for further processing. And you want to be sure of its integrity.

Lavsa - a new kid on the Block

Internship


**First thing first: the team and the brainy stuff**

Before starting the internship, I wasn’t really feeling nervous as I felt I had a good understanding of the basics of both Solidity and blockchain. Also, my colleague shared some insider information with me regarding the atmosphere, so I wasn’t surprised by the openness of the team and their willingness to help me and the other interns.
Firstly, we slowly studied the stack and the task itself. Then we got familiar and learned to work with the new blockchain technology that enables easier management of smart contracts. We were excited to start developing our own solutions!

Since blockchain is still a quite new technology, you can learn something new about it every day, as long as you know what to search for. Us interns were involved in the whole development cycle starting from the very beginning. First, we went back and forth researching the technologies and deciding which ones would be the best for this project and the internship, before deciding on Scaffold-ETH.

**You’ve heard it several times already: tHErE aRe No STuPid qUEsTioNs!**


![mulan-mushu.gif](https://strapi.suprabit.eu/uploads/mulan_mushu_9349847d61.gif)

 

Well, I’m going to say it again, there really are no stupid questions in Suprabit. Around here, everybody is eager to help each other, be it solving a bug or replacing the coffee pod. Don’t waste your time asking yourself “What will they think of me asking many questions or the same question many times?” because nobody will turn their back or roll their eyes at you. They all know the common goal is gaining understanding and moving forward.
 
The atmosphere is chill and most enjoyable. Once you've had enough of the keyboard tapping, you can make your way to our local table tennis station situated inside the office. Ask away, someone will surely join you! (Beware of the boss, you have to let him win, otherwise...).
 
 
**Future opportunities**

The internship program was well planned and adapted to students with or without previous knowledge of blockchain technology. The people were great, and I enjoyed the entire experience. I'm grateful for the things that I’ve learned during the internship and I'm happy that I was able to stay at Suprabit as an employee after the internship had finished. I know that Suprabit will continue to support my growth and make me a better blockchain developer (and a better table tennis player)!
 
![DSC00401-min.jpg](https://strapi.suprabit.eu/uploads/DSC_00401_min_4b49f3e364.jpg)



large_WhatsApp Image 2022-10-26 at 13.44.46.jpeg

medium_WhatsApp Image 2022-10-26 at 13.44.46.jpeg

small_WhatsApp Image 2022-10-26 at 13.44.46.jpeg

thumbnail_WhatsApp Image 2022-10-26 at 13.44.46.jpeg

WhatsApp Image 2022-10-26 at 13.44.46.jpeg

This summer, I decided to spend my summer-break gaining as much knowledge on blockchain as possible. After a couple of hours of research, a few interviews and one solved solidity smart contract task, I landed my internship at Suprabit.

My Blockchain Internship at Suprabit!

## What and why? 👀

For starters, what exactly is Expo? Expo is a bundle of tools created around React Native to help you start an app very fast. It gives you the means to simplify the creation and testing of React Native App. With Expo, there is no need to directly use Xcode or Android Studio. That means you can finally develop for iOS even if you are not a Macbook lover.

What’s more, if you choose Expo, you will never have to touch any native Swift, Objective-C or Kotlin or Java code. This means you can rely on just your Javascript skills for developing a real-feel native app, ready to be used on both iOS and Android!
However, sometimes you still need to add some native code. We will go over the steps on how to do that as well!

## Setting up the project 💻

You can read all about getting started on [this link](https://docs.expo.dev/get-started/installation/), here we will do just a quick overview so you can get right into the important stuff.
The first step should be downloading the Expo Go app on your phone as well as installing the Expo CLI on your computer:
```bash
npm install --global expo-cli
```

Then you should enter the following command in the terminal and choose one out of four templates:
```bash
expo init-my-app
```

After installing the project, you can start the app by entering 
```bash
expo start
```

A QR code will now pop up on the screen, then you can scan the code from within the Expo Go app if you’re using Android, or directly from the phone's camera if you're using iOS.
Now you can see all the changes you’ve made within the app right as you make them.

## Adding native modules using plugins 📌

Sometimes during your development, you will need to use native modules not directly supported by React Native. Before switching to the bare workflow, you should check if there is a plugin available for the module you need. Expo uses plugins to generate and configure all the native code for a managed project. 

If there is a plugin available, you can easily add it to your project following these instructions.
First, you need to install the plugin of your choice. After installation finishes, edit the app.config.json or app.json file. Edit the expo key and put in the following code: 
```json
{
  "expo": {
    "plugins": ["@config-plugins/name-of-your-plugin"]
  }
}
```
Before being able to fully use the native module, you need to build the application in the development mode using EAS. You can read up more about building later in the article.
Now you can start your app with:
```bash
expo start –dev-client
```

## Permissions ☑️ 

Some native modules require the user to give his permission. With Expo, you don’t have to dig into the native code to handle permissions. It is again enough to just edit the app.config.json file. Here we will be adding [this Bluetooth plugin](https://github.com/dotintent/react-native-ble-plx), but the process is the same for any available plugin. 
For Android, you need to add a new permission field like this
```json
{
   "android": {
      "permissions": ['BLUETOOTH', 'BLUETOOTH_ADMIN'],
    },
}
```
For iOS, you need to do a bit more work. 
```json
{
"ios": {
      "bundleIdentifier": 'your.bundle.identifier',
      "infoPlist:" {
        "NSBluetoothAlwaysUsageDescription":
          'Our app uses bluetooth to find, connect and transfer data between different devices',
      },
    },
}
```
And that's it! Now your app will ask the user for his/hers permission on startup.

## Adding native modules with no plugins available 🖇️

Even though by using Expo we try to stay away from native coding, occasionally there is no other way to achieve some functionality. <br/> Up until recently, if you wanted to add native code, you needed to eject Expo altogether. That means that you wouldn't be able to use the Expo Go app anymore, but more importantly, you would need to remove all your plugins and add them to the native code by hand! Luckily, now there is a workaround and that is using Expo's new feature - the bare workflow!

If you want to use custom native code that isn't already in the Expo Go app, you will need to generate the native iOS and Android projects. To do that, first, you need to switch from managed to bare workflow. You do this by running
```bash
expo run:android
```
and
```
expo run:ios
```

Using the run commands will initially prebuild your project to generate all of the native code within your project directory. Keep in mind that you need to have both Xcode and Android Studio installed to do this. 
Now, you can test your native code on simulators, and continue to use the Expo Go for all other testing and development. You can’t access native code while using the Expo Go app, but you can still access and keep all of your plugins. 

After adding a plugin to the bare workflow, you need to run expo prebuild so Expo CLI adds required permissions to the Info.plist and AndroidManifest.xml. As before, anytime you add a new plugin, you need to build the app again.

## Building the app 🔨

To build the app, we will use [EAS Build](https://docs.expo.dev/build/introduction/). EAS Build allows you to build a ready-to-submit binary of your app for the Apple App Store or Google Play Store.
First, you will need an Expo Dev account. You can register [here](https://expo.dev/).

At the root of your project, you have eas.json, where you can find the four types of builds: dev-ios-simulator, development, preview, and production.
<ul>
<li>Development builds include developer tools, and they are never submitted to an app store.</li>
<li>️Dev-ios-simulator build is used to create the development build for the iOS simulator.</li>
<li>Preview builds don't include developer tools, they are intended to be installed by your team and other stakeholders, to test out the app in production-like circumstances.</li>
<li>️Production builds are submitted to the app store, they are meant for release to the general public or as part of a store-facilitated testing process such as TestFlight.</li>
</ul>


You can change the default value of the bundle identifier in the app.config.js file. By default, the build will be of production type. You can also specify the build type in your command.
```bash
eas build --profile development
```
After that, you can select the platform for which you want to build or you can skip that step by specifying the platform directly in the command.
```
eas build --profile development --platform all
```
The Android build will start immediately. If you chose iOS, log in to your Apple account.

When the build is over, go to the given link or scan the QR code and install the app.
Keep in mind that the app won't run with build types Development and Preview on iOS devices that are not registered on your Apple account.

In the development and preview build, the result for an Android build is the .apk file, while for the production build the result is the .aab file. If you want to change the type of build file, you will need to edit the eas.json file.
```json
{
  "build": {
    "preview": {
      "android": {
        "buildType": "apk"
      }
    },
    "preview2": {
      "android": {
        "gradleCommand": ":app:assembleRelease"
      }
    },
    "preview3": {
      "developmentClient": true
    },
    "production": {}
  }
}
```

You only need to make a new build if you add new native dependencies, or if you register a new Apple device in your provision profile and you want to run the build on it. 

## Conclusion 📝

With Expo's new features, you can finally use it for the whole development process. Adding plugins and native code has never been easier. Since the building process lasts only a few minutes, your clients can now get day-to-day updates on your progress! Other than that, definitely check out [the documentation](https://docs.expo.dev/) for other commonly used features.

Have fun and stay tuned for more! 📻 😊





large_expo.png

medium_expo.png

small_expo.png

thumbnail_expo.png

expo.png

See how Expo helps you in your development and takes care of native things for you.

Using Expo with React Native



## Introduction

In today's world trust is everything, but unfortunately, different parties, more often than not, do not trust each other. Therefore, it is crucial for one party to prove something to the other party - in that case, trust is not required, but only sophisticated mechanisms that would almost guarantee the truth. 

Data anchoring with Merkle tree when implemented correctly can make a zero-knowledge proof. To find out how, first you would need to get familiar with those three terms - Data anchoring, Merkle tree and zero-knowledge proof.

### Data anchoring

Data anchoring consists in creating a timestamped proof of existence for data and storing it to a tamper-resistant blockchain.

Key point is that having the data enables the recreation of the proof, but not the other way around. This way whoever is in possession of the data can verify if the data has been tampered with since its anchoring on the blockchain.


### Merkle tree

Merkle tree or hash tree is a binary tree in which every leaf is labeled with cryptographic hash of a data block, and every node that is not a leaf is labeled with cryptographic hash of the labels of its child nodes. 

![merkletree.png](https://strapi.suprabit.eu/uploads/merkletree_78340c824f.png)
Source: [Wikipedia](https://en.wikipedia.org/wiki/Merkle_tree)

Similar to data anchoring, with knowing all data blocks it is easy to construct a Merkle tree and find the label of the root node or simply called root hash (top hash), but it is not possible to find data blocks knowing only root hash. That is why Merkle tree is used in data anchoring where root hash is the proof that the data is stored onto blockchain.

Another key feature Merkle tree has is that it can be partially created with only subset of data and a receipt for that subset. It is important to note that only those who possess all the data are able to generate such receipts. For example: if we only have L1 and L2 data blocks from the picture above, and we have "Hash 1" inside the receipt, we are able to construct the left side of the Merkle tree with data blocks, and with "Hash 1" from the receipt we are able to calculate root hash.

### Zero-knowledge proof

Zero-knowledge proof is a method by which one party (the prover) can prove to another party (the verifier) that a given statement is true while the prover avoids conveying any additional information apart from the fact that the statement is indeed true. The essence of zero-knowledge proofs is that it is trivial to prove that one possesses knowledge of certain information by simply revealing it; the challenge is to prove such possession without revealing the information itself. - from [Wikipedia](https://en.wikipedia.org/wiki/Zero-knowledge_proof)

## How is it done?

Now that you have gotten familiar with these terms, I am guessing you got a hang of it - how could Merkle tree be used to achieve data anchoring and zero-knowledge proof? First, to anchor your data you would simply order your data blocks and construct a Merkle tree. It is important to arrange data blocks in deterministic order because later data blocks will need to be ordered exactly the same. The root hash of this tree has to be stored on a public blockchain and that is it - you anchored your data.

Second thing you want to do is to ensure you are able to recreate Merkle tree with only subset of your data blocks and an according receipt. You would have to write two algorithms - first algorithm, based on the subset of data blocks and all data blocks, creates the receipt for the subset; second one, given the subset and an according receipt, recreates the Merkle tree. First algorithm is used internally when you want to share a portion of your data, and second algorithm should be open source that would be used by the receiver of the data to verify whether the data has been tampered with since its anchoring.

## Conclusion

Data anchoring is useful mechanism that finds its applications in various industries. There are a lot of ways to implement data anchoring, but in our case we used Merkle tree to do so. Merkle tree is a binary tree in which leaf nodes are labeled with hash of data blocks, and each non-leaf node is labeled with hash of its child nodes. Hence, Merkle tree algorithm can create a single hash (root hash) out of multiple data blocks. Also, root hash of a Merkle tree can be recreated either with all data blocks it contains, or with a subset of the data blocks and an according receipt. 

Data anchoring using the Merkle tree algorithm creates the ability to prove certain data is valid without sharing all the data. This makes it zero-knowledge proof.


large_blockchain-g44b9a7004_1920.jpg

medium_blockchain-g44b9a7004_1920.jpg

small_blockchain-g44b9a7004_1920.jpg

thumbnail_blockchain-g44b9a7004_1920.jpg

blockchain-g44b9a7004_1920.jpg

Find out what data anchoring is and why is it beneficial. This article will teach you basic principles and simple usage so you can start thinking of ways to apply data anchoring in your business.

Data anchoring and verification using zero-knowledge proof

## Introduction

In our introductory [NFT blog post](https://www.suprabit.eu/article/nfts-explained), we explained what NFTs are and what they are used for. In the meantime, we delivered [Suprabit Giant NFT](https://opensea.io/collection/suprabit-giant-nft) to our business partners and employees and hopefully opened a new era of NFT corporate gifts 👍. <br/>
Suprabit Giant was a small but very interesting project that included a digital artist, full-stack and blockchain devs, a business developer, and a legal officer who jointly delivered a unique experience to our partners.

This post will help you get into the technical details of the Suprabit Giant implementation. 

## NFTs

As a quick technical introduction to NFTs, we will compare fungible and non-fungible tokens with simplified pseudocodes for the most basic functions, keeping track of the account balance, adding funds to the account, and removing funds from the account. In the examples below, fungible tokens are on the left, and non-fungible tokens are on the right. Notice how we don’t distinguish individual fungible tokens on the left - we store balance as a number, while with the non-fungible tokens on the right, the balance of an account is defined as a collection of token ids - each token has its unique id. Transferring fungible tokens means just decreasing the sender’s balance, and increasing the receiver’s balance. Meanwhile, transferring non-fungible tokens means removing specific tokens from the sender’s collection and inserting them into the receiver’s collection.

<table style="font-size: 0.75em; display: flex; justify-content: center;">
<tr>
<td style="max-width: 50vw;">

```js
// Account balance - integer
account.tokens = 100;
// Add 10 funds
account.tokens += 10;
// Remove 10 funds
account.tokens -= 10;
```

</td>
<td style="max-width: 50vw;">

```js
// Account balance - set of token ids
account.tokens = [1, 3, 100, 200];
// Add tokens with id 99
account.tokens.insert(99);
// Remove token with id 99
account.tokens.remove(99);
```

</td>
</tr>

<tr>
<th>Fungible Token</th>
<th>Non-Fungible Token</th>
</tr>
</table>

<br/>

## ERC721

[Ethereum Improvement Proposals](https://eips.ethereum.org/) (EIPs) describe standards for the Ethereum platform, including core protocol specifications, client APIs, and contract standards. Among EIPs there are Ethereum Request for Comments (ERCs) which tackle application-level standards and conventions.

[ERC721](https://eips.ethereum.org/EIPS/eip-721) introduces a standard interface for the implementation of an NFT smart contract. It defines a set of methods that each smart contract needs to implement to be ERC721 compliant. Below we can see the simplified ERC721 interface, this is not a full ERC721 interface, we only extracted a few basic functions.


<table style="font-size: 0.75em; display: flex; justify-content: center;">
<tr>
<td style="max-width: 90vw;">

```solidity
/// @title ERC-721 Non-Fungible Token Standard
/// @dev See https://eips.ethereum.org/EIPS/eip-721
///  Note: the ERC-165 identifier for this interface is 0x80ac58cd.
interface ERC721 /* is ERC165 */ {
    /// @notice Count all NFTs assigned to an owner
    /// @dev NFTs assigned to the zero address are considered invalid, and this
    ///  function throws for queries about the zero address.
    /// @param _owner An address for whom to query the balance
    /// @return The number of NFTs owned by `_owner`, possibly zero
    function balanceOf(address _owner) external view returns (uint256);

    /// @notice Find the owner of an NFT
    /// @dev NFTs assigned to zero address are considered invalid, and queries
    ///  about them do throw.
    /// @param _tokenId The identifier for an NFT
    /// @return The address of the owner of the NFT
    function ownerOf(uint256 _tokenId) external view returns (address);

    /// @notice Transfers the ownership of an NFT from one address to another address
    /// @dev This works identically to the other function with an extra data parameter,
    ///  except this function just sets data to "".
    /// @param _from The current owner of the NFT
    /// @param _to The new owner
    /// @param _tokenId The NFT to transfer
    function safeTransferFrom(address _from, address _to, uint256 _tokenId) external payable;

    /// @notice Transfer ownership of an NFT -- THE CALLER IS RESPONSIBLE
    ///  TO CONFIRM THAT `_to` IS CAPABLE OF RECEIVING NFTS OR ELSE
    ///  THEY MAY BE PERMANENTLY LOST
    /// @dev Throws unless `msg.sender` is the current owner, an authorized
    ///  operator, or the approved address for this NFT. Throws if `_from` is
    ///  not the current owner. Throws if `_to` is the zero address. Throws if
    ///  `_tokenId` is not a valid NFT.
    /// @param _from The current owner of the NFT
    /// @param _to The new owner
    /// @param _tokenId The NFT to transfer
    function transferFrom(address _from, address _to, uint256 _tokenId) external payable;
}
```
</td>
</tr>
</table>
<br/>

But why is this even important for us? Can’t we create our own NFT smart contract without any fuss with standards? In theory, we can, no one forces us to be ERC721 compliant, in practice, a short answer - no. Now for the long answer, we need to enable interoperability between our NFT contract and other applications. A primary example of this interoperability is a wallet application. The general expectation is that users can see and manage their tokens in their wallet application - this is generally a mobile app. A wallet application can check which tokens the user owns only by reading the NFT smart contract directly. Now imagine what would happen if every NFT smart contract was implemented differently - a wallet application would need to develop an interface for each smart contract which doesn’t make sense. This is why we accept ERC721 and other EIPs and implement smart contracts accordingly. Any application can integrate with our NFT just by fetching the address of our smart contract as everything is publicly available.

Now that we have a better understanding of what we need to implement it’s a good time to introduce OpenZeppelin, an open-source library of standardized smart contracts that were developed following best security practices, and are extensively audited. Within the library, we have an implementation of the basic ERC721 compliant smart contract which tackles all the standard functionality of the NFT, minting, fetching balance, transferring, etc. As smart contracts are object-oriented, we can just inherit OpenZeppelin’s basic ERC721 contract and extend it with our business logic that is specific to our NFT.

At this point, we have a smart contract with basic NFT functionality - we have the tokens, but what differentiates them? Where is the uniqueness, the praised non-fungibility? This is where the token metadata comes into play, and if we consult the ERC721 interface we can spot the metadata extension which describes a way to attach metadata to the contract and each token individually. This allows us to attach some assets to tokens, like images, videos, and other media, or data in general. Below you can see the interface of the metadata extension. The main function here is the tokenURI which allows us to specify a distinct URI for a specific token. The idea is that the tokenURI points to a JSON file that contains all the metadata related to the specific token.

<table style="font-size: 0.75em; display: flex; justify-content: center;">
<tr>
<td style="max-width: 90vw;">

```solidity
/// @title ERC-721 Non-Fungible Token Standard, optional metadata extension
/// @dev See https://eips.ethereum.org/EIPS/eip-721
///  Note: the ERC-165 identifier for this interface is 0x5b5e139f.
interface ERC721Metadata /* is ERC721 */ {
    /// @notice A descriptive name for a collection of NFTs in this contract
    function name() external view returns (string _name);

    /// @notice An abbreviated name for NFTs in this contract
    function symbol() external view returns (string _symbol);

    /// @notice A distinct Uniform Resource Identifier (URI) for a given asset.
    /// @dev Throws if `_tokenId` is not a valid NFT. URIs are defined in RFC
    ///  3986. The URI may point to a JSON file that conforms to the "ERC721
    ///  Metadata JSON Schema".
    function tokenURI(uint256 _tokenId) external view returns (string);
}
```
</td>
</tr>
</table>
<br/>


Below is the example of the token metadata in JSON format, tokenURI should point to this data. In this example we modeled an NFT for a football player card, the metadata contains a URL to an image of a player, and a couple of attributes assigned to the token. Observant among you may have already noticed a link to an image hosted on the hns-cff.hr domain,  oh no. It’s completely valid to question the integrity of our NFT at this point, we promised you full control of your NFT, but then you find that someone else has full control of the essential part of the NFT - the digital asset it encapsulates. What happens when the owners of the hns-cff.hr domain decide they don’t want to host the image anymore a few months or even a few years after you received the NFT? They have the full right to do so, they don’t have any incentive to continue hosting the image for free. The NFT without the digital asset becomes just an id assigned to you in the smart contract, practically useless.

<table style="font-size: 0.75em; display: flex; justify-content: center;">
<tr>
<td style="max-width: 90vw;">

```json
{
    "name": "Luka Modric",
    "image": "https://hns-cff.hr/files/images/luka-modric.jpg",
    "attributes": [
        {
            "trait_type": "country",
            "value": "Croatia"
        },
        {
            "trait_type": "kit_number",
            "value": 10
        },
        {
            "trait_type": "position",
            "value": "midfielder"
        },
        {
            "trait_type": "captain",
            "value": "true"
        }
    ]
}
```

</td>
</tr>
</table>
<br/>


You might wonder why don’t just store all the metadata in the blockchain? Storing data in the blockchain is expensive, storing just 1MB of data to the Ethereum blockchain costs roughly 4 ETH which is, at the time of writing, equivalent to roughly $13,000. We won’t dig deeper into what is the reason behind this, but for anyone interested, a description of the Ethereum Virtual Machine (EVM) and its opcodes might be a good starting point. Nevertheless, don’t worry, we won’t stop here, there is a solution for the issue, this is where IPFS comes to save us.
<br/>

## IPFS

InterPlanetary File System is a protocol and peer-to-peer network for storing and sharing data in a distributed file system. It doesn’t sound like something that would solve our issues, but IPFS uses content-based addressing as opposed to location-based addressing which is a standard on the web today. If we look at the standard URL, let’s take an URL for the image of our football player as an example. Location-based addressing strictly defines on which domain is the image hosted, and where exactly is the image stored on that domain, in our example the domain is hns-cff.hr, and the image itself is located in the directory files/images/. Any change in either the domain name or the directory structure would result in this URL becoming invalid, alongside our NFT that depends on it.

![URL Example](https://strapi.suprabit.eu/uploads/URL_example_7209f2a836.png)


On the other hand, IPFS takes a completely different approach. As its name already says, content-based addressing addresses files based on their content. Imagine if the URL address for the image would be the hash of the image, it wouldn’t be convenient for humans as the URL wouldn’t be readable, and the links would be error-prone. But in our case we would greatly benefit from content-based addressing as we wouldn’t be vulnerable to any domain or directory changes, as long as someone has the original file, the URL can be resolved. Let’s try to check what would an IPFS URL look like. Content identifier (CID) is based on the hash of the file so for simplification, we can think of it just like a hash. A consequence of the CID is that any change in the file’s contents results in a different CID, which means that the file we are addressing with an IPFS URL is immutable. The file itself can be updated, but that would also update the CID so the original IPFS URL will point to the old version of the file. This is a great property for our use case, with IPFS CIDs we get addressing that preserves the integrity of the content.

![IPFS URL Example](https://strapi.suprabit.eu/uploads/IPFS_URL_1a3c9c8b76.png)

As IPFS is also a distributed file system, multiple peers in the network can host the same file, as the CID of the file would be the same there wouldn’t be any integrity violations. Multiple peers hosting the same file would only help others retrieve the file. If we try to retrieve the file from the peer that doesn’t have a file with that CID locally present, the peer will query neighboring peers if they have a file with that CID - this query propagates through the network until the file is found. A consequence of a peer-to-peer system is that the query for a file can take a long time to resolve as we need to propagate through the network until we find a peer that hosts this file.

Ok, now we know how to immutably address the metadata, but did we solve the issue if the original author stops hosting metadata? At least one peer in the IPFS still needs to host this file if we want NFT to work properly? True, at least one peer needs to host metadata for NFT to function, but now we at least have the ability to host data ourselves which is surprisingly easy as multiple cloud services offer us IPFS storage service - some of them even have free tiers that are more than sufficient to accommodate the storage of NFT metadata. This property comes from the fact that the metadata is not hosted by some server behind a domain, rather it’s hosted on IPFS, any IPFS peer should be able to find this file if at least one peer in the network hosts it.

You might be confused by some IPFS URLs looking like the example below. This link represents an HTTP gateway of an IPFS peer - ipfs.io in this example, it allows us to access IPFS files from the browser. You might wonder, didn’t we return to the beginning as we still need to use the HTTP gateway of some peer - what happens if that peer stops working? This is the exact reason why it’s strongly recommended to address IPFS files using ipfs://<cid> URL format as this allows consumers of that link to use any peer they want to access that file. We can even specify a list of IPFS peers that we use, so we have alternatives if one peer stops working.

<img alt="IPFS Peer Gateway" src="https://strapi.suprabit.eu/uploads/IPFS_peer_gateway_URL_779096ba1d.png"  height="70"/>


All in all, IPFS solves our issue of storing and linking metadata. Before deploying a smart contract we need to generate metadata, and media assets that will be linked with NFTs so that we can configure what the tokenURI method of the NFT returns. Below is the example of our metadata for one of our NFTs, we followed [OpenSea’s metadata format](https://docs.opensea.io/docs/metadata-standards#metadata-structure).

<table style="font-size: 0.75em; display: flex; justify-content: center;">
<tr>
<td style="max-width: 90vw;">

```json
{
    "name": "Suprabit Giant #0",
    "description": "This Suprabit NFT represents one of 100 unique frames of Suprabit Giant digital artwork.",
    "image": "ipfs://bafybeigp6cki2w7v26coqecxa5iohadhjg345n5b7ukkesbvq3kqeguvs4",
    "animation_url": "ipfs://bafybeig77wew3xfhejgatekmah5t46btoeteugaa2maynicyctl4zxwp6m",
    "external_url": "https://suprabit.eu/nft/giant/0",
    "attributes": [
        {
            "display_type": "boost_number",
            "trait_type": "Mobile",
            "value": 5
        },
        {
            "display_type": "boost_number",
            "trait_type": "IoT",
            "value": 10
        },
        {
            "display_type": "boost_number",
            "trait_type": "Blockchain",
            "value": 4
        },
        {
            "display_type": "boost_number",
            "trait_type": "AI",
            "value": 25
        },
        {
            "display_type": "boost_number",
            "trait_type": "Cloud",
            "value": 9
        },
        {
            "display_type": "boost_number",
            "trait_type": "Table Tennis",
            "value": 47
        }
    ]
}
```

</td>
</tr>
</table>
<br/>

The next step is to pick a blockchain network to where the NFT smart contract will be deployed to. As we used ERC721 which is an interface for Solidity smart contracts, we need to choose a network that supports Ethereum Virtual Machine (EVM). Naturally, Ethereum is the first network to be considered, but at the time of writing Ethereum’s high transaction cost due to high network traffic is not suitable for our case. Polygon is a few orders of magnitude more efficient than Ethereum at the moment so it was an easy decision to select it over Ethereum.
<br/>

## Minting

Lastly, we need to figure out an easy and intuitive way for users to claim their gifts. This is a hard task as the blockchain ecosystem introduced a new way of interaction with online services which is fairly complex for new users. We have to anticipate that a majority of users won’t even have a crypto wallet so we need to guide them through the whole process, not just the interaction with our smart contract. We utilized WalletConnect to help us connect users’ wallet applications with our NFT website where users redeemed their gift NFTs. The last thing we needed to do is to actually create and assign NFT to the user, this process is called minting. In order to mint the NFT, we need to call the smart contract and pass the token id we want to mint, and the address of the owner’s wallet. This operation is packed into a transaction that will require a small fee in order to be executed on the blockchain. As NFT is a gift we wanted to handle all minting fees ourselves which is why we created a small minting service that mints NFT at the user’s request - of course, we had to protect this service against unauthorized requests.

Along the way, we stumbled upon a hurdle of connecting a user’s wallet to the Polygon network which at the time of publishing NFT had to be manually configured in the wallet application, and this hurt the user experience a bit. Fortunately, this won’t be the issue for so long as there is already a [standard proposal](https://eips.ethereum.org/EIPS/eip-3085) that should fix this issue - the wallet applications just need to implement support for it.
<br/>

## Conclusion

To wrap it up, we successfully launched our first NFT and delivered it as a gift to our business partners and employees. It was awesome to hear positive feedback regarding the user experience of redeeming the NFT as we invested a lot of time to make it as easy, and as intuitive as possible. The general idea behind the gift was to give people first-hand experience with blockchain and introduce them to the concept of NFTs and help spark their ideas for NFT use cases. 

If you have any questions regarding this project, or if you are interested in various NFT use cases, and where can it be used in your field of work - feel free to contact us and let us give it thought together.



large_cover_nft_blog.png

medium_cover_nft_blog.png

small_cover_nft_blog.png

thumbnail_cover_nft_blog.png

cover_nft_blog.png

Making of Suprabit NFT Giant



Prior to starting, I felt a little nervous because I wasn't sure if I would be able to contribute and work well with my new team. However, a few days beforehand, my team made me feel welcomed by giving me the materials needed for preparation.

**Joining the full-stack team**

The team was just starting to build a brand new website from scratch. For the first couple of days, I was learning about new technologies that I was going to use throughout the project. I was also learning about the project itself by participating in conversations, discussing features that we were going to implement and brainstorming optimal solutions.
I got an insight into front-end, content management systems, publishing and UI/UX design. The focus was on Strapi, Next.js and Figma with React being the main point of interest.
I have to admit things were challenging in the beginning, but after some time and help from my colleagues, I was able to write a clean code on my own!


> I feel like everyone at Suprabit has an open mind and a passion for helping others! The management is flexible and attentive to the needs of the developers. If you're thinking of becoming a member of the Suprabit team or are even given an opportunity to be one, I hope you take it!

**Gaining confidence**

I realized I was able to do more than I thought I could! At the beginning of the summer, I was worried that I wasn't going to contribute enough. I never would have thought that by the end of the internship, I would become a valuable member of my team. Gaining confidence also meant talking about new concepts with my colleagues and finding the courage for pitching new ideas. One of the most important things that I learned was not to be afraid to ask questions! Asking questions meant that I'm curious and that I care about the quality of the work I'm doing. Furthermore, I learned not to ask the same question twice and to make sure the time I spent asking questions was valuable to everyone involved.


**Connecting theory and practice**

Before I started my internship, I thought I had a lot of knowledge on software development from my university.  However, as soon as I started to put such knowledge into practice, I realized that there was still so much to learn! At my university, I usually had to write small programs or projects, so working on such a big project was certainly new to me. The internship had a really positive effect on my studies as it had taught me how to write clean and understandable code and work in a team, but more importantly, it had given me hands-on experience in my field which is priceless.

**Conclusion**

I feel this internship program is well planned and adapted to students with no working experience. Throughout the entire experience, everyone was open, honest and understanding. No one ever made me feel like I was any less just because I had less experience than my fellow colleagues. I'm grateful for the things I learned during my internship and I'm so happy to be able to stay at Suprabit even after the internship has finished. I know that Suprabit will continue to support me and challenge me to be a better software developer!

large_about.jpg

medium_about.jpg

small_about.jpg

thumbnail_about.jpg

about.jpg

Interning at Suprabit has been one of the most challenging summers of my life, but it's been well worth it! Besides teaching me skills and giving me an insight into the functioning of a software company, it has forced me to learn and grow like never before.

My internship at Suprabit!

These last couple of months Suprabit experienced a noticeable increase in the number of employees. Because of the circumstances, we didn’t get the chance to meet all those new faces in person as everyone was working from home. So the best thing to do was to organize a fun team building in nature.


![GH011780_1632587258727.jpg](/uploads/GH_011780_1632587258727_aa96f8d466.jpg)




After the democratic elections with a few given options, the decision was made - we're going rafting! On early Saturday morning, we all got together and started our journey towards Brod na Kupi, a small town on the Croatian-Slovenian border. When we came there, we had great fun trying on our wet suits and boots. After we picked up all of the equipment, we sat in the car in wet suits and followed the mini kayak caravan upstream to the start of our water journey. After listening to short instructions, we were ready to jump in the river with our kayaks and immediately started bumping into each other. 




![GH011788_1632587858025.jpg](/uploads/GH_011788_1632587858025_87f54783fe.jpg)




 The water was really cold but the weather was sunny and actually quite nice. Sadly, the water level was pretty low so we missed out on some great adrenaline rushes, but the important thing was spending quality time together, relaxing, and taking in the beautiful mountain views. We still had so much fun because who wouldn’t laugh while watching your colleagues fall into cold water. 



![GH011796_1632663478230.jpg](/uploads/GH_011796_1632663478230_b22c299837.jpg)




By the time we finished kayaking, we were all pretty hungry, but luckily, there was a delicious lunch waiting for us. We enjoyed local specialties eating fresh food from the Gorski kotar region and finished off with amazing wild berries strudel. 





Tired but happy, we headed to Zagreb full of new memories and with tummies full with food.

![GH011805_1632662430929.webp](/uploads/GH_011805_1632662430929_07799deb0c.webp)

You can check the atmosphere for yourself in our video!

<style>.embed-container { position: relative; padding-bottom: 56.25%; height: 0; overflow: hidden; max-width: 100%; } .embed-container iframe, .embed-container object, .embed-container embed { position: absolute; top: 0; left: 0; width: 100%; height: 100%; }</style><div class='embed-container'><iframe src='https://www.youtube.com/embed//Nn00gVJNGDI' frameborder='0' allowfullscreen></iframe></div>




large_GH011780_1632587258727.jpg

medium_GH011780_1632587258727.jpg

small_GH011780_1632587258727.jpg

thumbnail_GH011780_1632587258727.jpg

GH011780_1632587258727.jpg

We had a great time at our recent team building!

Team Building 2021: Kayak Adventure

Design

# We needed a change

People say that the website is the face of the company, and that is indeed true. The website is often the first thing somebody sees about your company and if they see an IT company with a bad, ugly or non-functioning website, imagine what they will think about the company itself.

Our old website was kind of out of date and since Suprabit is a company working with cutting edge technologies and following modern trends, we had to update our website to better represent us - what we do and who we are.

# Choosing what we want

Before doing a project like this, we had to agree on what we want to show on our website, how to package it and how to put emphasis on things we think are the most important. After the agreement had been made, our designer had to make a design prototype and web development team had to design application architecture and select the technologies to work with.

# Development

Our designer used **Figma**, a vector graphics editor and prototyping tool, to create the design which our development team would have to follow. For content management, we selected **Strapi**. Strapi is one of the best headless Content Management Systems, it is open source, 100% built in JavaScript and very simple to set up. **Next.js** is an open-source development framework built on top of Node.js enabling **React** based web applications functionalities such as server-side rendering and generating static websites. Since we are already experienced in developing Next.js applications, it was an easy decision to select this technology for building our website.

Following the design in Figma, the development team built React components. Next.js was important here to render as much as possible on the server side, and then serve the client with components already populated with content from Strapi. This increases user experience as the client has much fewer requests per page and pages load much faster.

# Deployment

For deployment of our web application and even through the development process, we used **Docker** containers for both Strapi API and for Next.js app. **Docker Compose** came in handy for easier management of both containers with only few command lines in the terminal. **Digital Ocean** is our selected cloud service provider and during the development phase, we had set up a dev environment and deployed our application iteratively as it was being built and as new features were being added. To do that without connecting to the server and running several commands lines every time, we created a **GitHub Action** to do all of that for us, deploying the application version on the main branch.

Once the app was ready, we needed to make it run over HTTPS protocol, instead of HTTP, and finally update DNS servers to route www.suprabit.eu to our server. 

large_Suprabit-web-1440x810.jpg

medium_Suprabit-web-1440x810.jpg

small_Suprabit-web-1440x810.jpg

thumbnail_Suprabit-web-1440x810.jpg

Suprabit-web-1440x810.jpg

Designing a new look for our website. Selecting technologies and principles to build our website on, implementing them and finally deploying the website to cloud.