1

CHAPTETER 1

INTRODUCTION

1.1 ABOUT THE ORGANIZATION

We offer a beautiful web design company based in India, SEO friendly and optional Google
AdWords as well as other Google Search Engine Optimization booster to help you gain advantage
& exposure in the online business industry. We started our passion for digital marketing in
2014. Our values are transparency, respect, honest communication & mutual understanding. We
have dealt with many kinds of customers, & we assure you that we listen & will implement the
agreement into action at our best.

1.2 OUR SERVICES

Technology We Use

Businesses who look for good looking & features of nowadays website with the ability of
maintaining your site by yourself

● PHP / Frameworks
● WordPress / CMS
● E-Commerce / WooCommerce
● Android / IOS
● SEO / SMO
● Digital marketing
● Tally

MISSION

Give us a Chance to Grow Your Business Online. SEO friendly and optional Google AdWords as
well as other Google Search Engine Optimization boosters to help you gain advantage & exposure in the
online business industry.
 2

VISION
Our vision is to be the state's most well-known carrier supplier enterprise focused to deliver the
maximum to our clients. We consider in the simple not problematic. We’re additionally giving equal
attention of innovations

1.2 OVERVIEW OF THE PROJECT

In today's digital landscape, issues of ownership, authenticity, and fraudulence have become increasingly
prevalent, especially in online marketplaces and the art world. Traditional methods of establishing ownership
and transferring assets are often susceptible to manipulation and fraud, leading to concerns among creators,
sellers, and buyers alike. However, the emergence of Non-Fungible Tokens (NFTs) presents a promising
solution to these challenges. NFTs, built on block chain technology, offer a unique and secure way to
establish ownership and authenticate digital assets. By leveraging smart contracts, parties can agree on the
terms of ownership and transfer, ensuring transparency and accountability throughout the process. This is
particularly relevant in online marketplaces like OLX, where fraudulent listings can undermine trust and
credibility. For digital creators, such as artists and content creators, NFTs provide a means to protect their
intellectual property and ensure proper attribution and compensation for their work. This is especially crucial
in the fast-growing digital art market, where issues of authenticity and ownership are paramount. By
utilizing NFTs, digital creators can tokenize their artworks, creating unique digital assets that can be bought,
sold, and traded securely on block chain-based platforms. This not only provides creators with a verifiable
record of ownership but also opens up new avenues for monetization and distribution. In the broader
business environment, the adoption of NFTs has the potential to revolutionize various industries, from art
and collectibles to gaming, real estate, and beyond. As block chain technology continues to evolve and gain
mainstream acceptance, NFTs are poised to play a significant role in shaping the future of digital ownership
and commerce. In summary, the project aims to explore the transformative potential of NFTs in establishing
secure digital ownership, combating fraudulence, and empowering creators in the digital economy. Through
the implementation of block chain-based solutions and smart contracts, the project seeks to provide a robust
framework for verifying and transferring ownership of digital assets, ultimately fostering trust, transparency,
and innovation in the digital ecosystem.
 3

CHAPTER 2
2.1 INTRODUCTION

The system design for the NFT-Based Digital Ownership Platform addresses the complexities
surrounding the authentication, purchase, and transfer of digital assets, particularly in realms like online
marketplaces and digital art exhibitions. Users authenticate their identities securely upon registration, with
measures like two-factor authentication enhancing security. Role-based access control (RBAC) ensures
appropriate permissions based on user roles (e.g., buyer, seller, administrator). Digital assets are tokenized into
Non-Fungible Tokens (NFTs) using block chain technology. Each NFT represents a unique digital asset with
distinct ownership and attributes, enabling secure and transparent transactions. Smart contracts deployed on
the block chain define the terms of ownership transfer. They automate transaction execution, ensuring secure
and transparent transfer of ownership once purchase agreements are met. Seller's list digital assets for sale,
providing detailed descriptions and metadata. Buyers browse listings and discover assets based on various
criteria like category, artist, or price. Buyers initiate purchases through bids or offers, and upon agreement, the
smart contract facilitates ownership transfer from seller to buyer. This transfer is recorded immutably on the
block chain, ensuring a transparent ownership history. Integrated digital wallets enable users to manage their
assets and NFTs securely. They facilitate viewing, transferring, and selling assets, ensuring a seamless user
experience. Mechanisms are implemented for verifying asset authenticity. Metadata associated with NFTs may
include provenance information, artist details, and certification of authenticity, ensuring trust and credibility.

2.2 ANALYSIS MODEL

The NFT-Based Digital Ownership Platform addresses critical challenges in establishing and
verifying ownership of digital assets, particularly in online marketplaces and the art world. In
online marketplaces like OLX, fraudulent activities often occur where buyers and sellers struggle
to determine ownership and authenticity of digital goods. This lack of clarity leads to distrust and
poses risks for both parties. Additionally, digital creators face challenges in protecting their
intellectual property, particularly in the rapidly growing digital art market, where online
exhibitions can be easily forged or replicated. Buyers and Sellers: Individuals or entities engaged

in the buying and selling of digital assets. Artists, content creators, and digital converters who
create and tokenize digital assets. Platform Administrators: Responsible for managing and
maintaining the NFT-based platform. Individuals interested in purchasing and collecting digital
artworks. Authentication and Authorization: Robust authentication mechanisms are needed to
verify the identity of users and authorize their access to the platform's features. Digital assets must
be tokenized into Non-Fungible Tokens (NFTs) to establish unique ownership records.
 4

2.3 SYSTEM REQUIREMENTS

HARDWARE AND SOFTWARE SPECIFICATIONS

2.3.1 HARDWARE REQUIREMENTS

•
• Processor : Intel Core i5 or equivalent

• RAM : 8 GB

• Hard disk : 256 GB

• Monitor : 15-inch color monitor

2.3.2 SOFTWARE REQUIREMENTS

• Front End : HTML5, CSS3, Python 3.10

• Back End : MySQL 8.14

• IDE : PyCharm Community Edition 2024.1.1

• Interface : Website Application (Flask) 3.0.3

2.4 EXISTING SYSTEM

The existing system for addressing issues of ownership and authenticity in digital and physical goods
typically relies on traditional methods of record-keeping and authentication, which often lack transparency
and security. In the case of digital assets, platforms like OLX operate on centralized databases where users
create accounts and list items for sale without comprehensive verification processes. This lack of
authentication opens the door to fraudulent activities, such as fake listings and unauthorized sales. For
 5

digital artworks, artists and creators face challenges in proving ownership and protecting their intellectual
property rights. Online exhibitions are vulnerable to unauthorized replication and distribution, as there is no
standardized system for verifying the authenticity of digital artworks. Similarly, in the physical art world,
provenance and authenticity are established through paper-based records, certificates of authenticity, and expert
authentication processes. However, these methods are susceptible to forgery and manipulation, leading to
uncertainty and disputes over ownership and provenance. In both digital and physical contexts, block chain
technology and NFTs offer a promising solution to these challenges. By leveraging decentralized ledgers and
cryptographic tokens, block chain-based platforms can provide transparent and immutable records of ownership
and provenance. NFTs, as digital representations of unique assets, enable creators and owners to tokenize their
works and establish verifiable ownership on the block chain.
2.4.1 Disadvantages

• The process used in the existing system seems to be time consuming

• The normal existing survey system is to cost for implementation

• It does not identify the real product maintenance in real life applications.

2.5 PROPOSED SYSTEM

The proposed system aims to revolutionize the management of ownership and authenticity for both
digital and physical goods by leveraging block chain technology and Non-Fungible Tokens (NFTs). Users
will undergo a rigorous authentication process to verify their identities before accessing the platform. Role-
based access control will be implemented to ensure that users have appropriate permissions based on their
roles, such as buyer, seller, or administrator. Digital and physical goods will be tokenized into NFTs using
block chain technology. Each NFT will represent a unique digital certificate of ownership, securely stored
and tamper-proof on the block chain. This process will provide transparency and traceability throughout the
lifecycle of the goods. Smart contracts will be deployed to automate the execution of transactions and define
the terms of ownership transfer. These contracts will serve as digital agreements between parties, ensuring
that ownership is transferred securely and transparently once a purchase has been made. Sellers will have the
ability to list their digital and physical goods for sale on the platform, providing detailed descriptions and
metadata. Buyers can easily discover and browse listings based on various criteria such as category, artist, or
price, enhancing the overall user experience. Buyers will initiate purchases
 6

through the platform, and upon agreement, ownership will be transferred from the seller to the buyer. This
transfer will be recorded immutably on the block chain, providing a clear and transparent record of ownership.
Mechanisms will be implemented to verify the authenticity of both digital and physical goods. Metadata
associated with NFTs will include provenance information, artist details, and certification of authenticity,
allowing buyers to make informed decisions about their purchases.

2.5.1 Advantages

• Fake seller can be eliminated

• Secure NFT storage using block chain can be done

• The ECC shows a rate of 97% accuracy limit

• External maintenance can be done in the proposed system with server storage

2.6 MODULE DESCRIPTION:

Admin – Admin will be the head of the system in which the admin can maintain all details

• Login – The login of the admin will be default where the username and password verification can be
done
• View seller – The admin will view the details of the seller where the seller information can be
processed.

• View buyer – The admin will view the information's of the buyer where the buyer information's
will be loaded

• NFT verification – Token verification can be processed with the functional system for purchasing.

• Payments - The payment details can be viewed in this module where the payment functions.

DW Admin

• Login: DW administrators can log in to access administrative features specific to digital wallets.
• View Seller: DW administrators can view information and details of sellers registered on the
platform.
 7

• View Buyer: DW administrators can view information and details of buyers registered on the
platform.
• View NFT: DW administrators have access to view details and verify NFTs associated with digital
assets, ensuring their legitimacy.

Seller
• Register – the seller will make a registration and create an account with the system

• Login – With the created account the seller will make a login

• Add post – The seller will add the post details in which the post information will contain the product
with resale

• Generate NFT – The resale product needs a verification token called Non-Fungible Token verification

• Verified access – In the verified access where the implementation of the complete ID can be done
and performed

• Request product – The product buy request can be proceeded to the seller

• View payments – In this module, the payment can be verified with payment access

• Secure Block chain – Secure block chain-based loading interface has been generated
Buyer
• Register – The buyer will make a registration with a register module and the account can be created

• Login – The buyer can make a login on using created username and password session

• View post – The buyer will view the post in this module and plan for buying those product

• Verify NFT – The product they wish to purchase may have an NFT token where the NFT range of
unique number access

• Purchase request – After the verification of the token the purchase information can be done if the
product is genuine

• Make Payment – The payment concerned can be viewed and verified in this system.
8
 9

CHAPTER 3
SOFTWARE REQUIREMEN SPECIFICATION
3.1 Introduction
The NFT-based digital ownership platform aims to provide a secure and transparent marketplace for
buying, selling, and verifying ownership of digital and physical goods, with a focus on artworks and other
valuable assets. Leveraging block chain technology and Non-Fungible Tokens (NFTs), the platform ensures
authentic ownership records and facilitates trusted transactions between parties.

Functional Requirements:

User Management: The system shall support user registration, login, and profile management functionalities
for administrators, sellers, and buyers. Users shall be authenticated using secure methods such as
username/password, email verification, or two-factor authentication.

Listing Management: Sellers shall be able to create detailed listings for goods, including artworks,
providing descriptions, images, and metadata. Listings shall be categorized and searchable based on various
criteria such as category, artist, or price range.

NFT Tokenization and Smart Contracts: The platform shall tokenize digital and physical assets into NFTs
using blockchain technology. Smart contracts shall automate transaction processes and define ownership
transfer terms between parties.

Verification and Authentication: Mechanisms shall verify the authenticity of NFTs associated with assets,
including provenance information, artist details, and certificates of authenticity. NFT metadata shall be
transparent and immutable, providing buyers with confidence in their purchases.

Transaction Management: The platform shall facilitate secure and transparent transactions between buyers
and sellers. Buyers shall be able to initiate purchase requests, and sellers shall have the option to accept or
reject them. Payments shall be processed securely through integrated payment gateways, ensuring financial
security for all parties.
 10

Non-Functional Requirements:

Security:
The platform shall implement robust security measures to protect user data, transactions, and assets
from unauthorized access and cyber threats. Compliance with relevant privacy regulations shall be ensured to
safeguard user privacy rights and data confidentiality.

Implement continuous monitoring and automated threat detection systems to identify and mitigate
potential security breaches. Regular security audits and penetration testing shall be conducted to ensure the
integrity of the system.

Performance:
The system shall be scalable to accommodate a growing user base and increasing transaction
volumes. Performance optimization techniques shall be implemented to ensure responsive and efficient
platform operation.

Implement performance optimization techniques such as database indexing, caching, and

asynchronous processing to minimize latency and improve response times. Regularly monitor system
performance and conduct stress testing to identify and address bottlenecks.

Utilize cloud infrastructure with auto-scaling capabilities to dynamically adjust resources based on
real-time demand. This ensures efficient use of resources while maintaining high performance during peak
times.

Usability:
The user interface shall be intuitive and user-friendly, providing a seamless experience for both
buyers and sellers. Dashboards shall be provided for users to manage their listings, purchases, and
transactions efficiently.

Provide comprehensive dashboards for users to manage their listings, purchases, and transactions.
These dashboards should include features such as filtering, sorting, and search functionality to help users
quickly find and manage their data.
 11

CHAPTER 4

SYSTEM DEVELOPMENT ENVIRONMENT

4.1 FRONTEND(Python)

INTRODUCTION

Python is a widely used high-level programming language first launched in 1991. Since then, Python has
been gaining popularity and is considered as one of the most popular and flexible server-side programming
languages. Unlike most Linux distributions, Windows does not come with the Python programming
language by default. However, you can install Python on your Windows server or local machine in just a
few easy steps.

PREREQUISITES

● A system running Windows 10 with admin privileges

● Command Prompt (comes with Windows by default)
● A Remote Desktop Connection app (use if you are installing Python on a remote Windows server)

PYTHON INSTALLATION ON WINDOWS

Step 1: Select Version of Python to Install

The installation procedure involves downloading the official Python .exe installer and running it on
your system.
The version you need depends on what you want to do in Python. For example, if you are working on a
project coded in Python version 2.6, you probably need that version. If you are starting a project from
scratch, you have the freedom to choose.
If you are learning to code in Python, we recommend you download both the latest version of Python 2
and 3. Working with Python 2 enables you to work on older projects or test new projects for backward
compatibility.

Step 2: Download Python Executable Installer

1. Open your web browser and navigate to the Downloads for Windows section of the official Python
website.
 12

2. Search for your desired version of Python. At the time of publishing this article, the latest Python 3
release is version 3.7.3, while the latest Python 2 release is version 2.7.16.

3. Select a link to download either the Windows x86-64 executable installer or Windows x86
executable installer. The download is approximately 25MB.

Step 3: Run Executable Installer

1. Run the Python Installer once downloaded. (In this example, we have downloaded Python 3.7.3.)

2. Make sure you select the Install launcher for all users and Add Python 3.7 to PATH checkboxes. The
latter places the interpreter in the execution path. For older versions of Python that do not support the Add
Python to Path checkbox, see Step 6.

3. Select Install Now – the recommended installation options.

 13

For all recent versions of Python, the recommended installation options include Pip and IDLE. Older
versions might not include such additional features.

4. The next dialog will prompt you to select whether to Disable path length limit. Choosing this option
will allow Python to bypass the 260-character MAX_PATH limit. Effectively, it will enable Python to use
long path names

The disabled path length limit option will not affect any other system settings. Turning it on will resolve
potential name length issues that may arise with Python projects developed in Linux.

Step 4: Verify Python Was Installed on Windows

 14

1. Navigate to the directory in which Python was installed on the system. In our case, it
is C:\Users\Username\AppData\Local\Programs\Python\Python37 since we have installed the latest
version.
2. Double-click python.exe.
3. The output should be like what you can see below:

Step 5: Verify Pip Was Installed

If you opted to install an older version of Python, it is possible that it did not come with Pip
preinstalled. Pip is a powerful package management system for Python software packages. Thus, make sure
that you have it installed.

We recommend using Pip for most Python packages, especially when working in virtual

environments. To verify whether Pip was installed:

1. Open the Start menu and type “cmd.”

2. Select the Command Prompt application.
3. Enter pip -V in the console. If Pip was installed successfully, you should see the following output:
 15

Step 6: Add Python Path to Environment Variables (Optional)

We recommend you go through this step if your version of the Python installer does not include the Add
Python to PATH checkbox or if you have not selected that option.

Setting up the Python path to system variables alleviates the need for using full paths. It instructs

Windows to look through all the PATH folders for “python” and find the install folder that contains the
python.exe file.

1. Open the Start menu and start the Run app.

2. Type systemic and click OK. This opens the System Properties window.
 16

3. Navigate to the Advanced tab and select Environment Variables.

4. Under System Variables, find and select the Path variable.

5. Click Edit.

6. Select the Variable value field. Add the path to the python.exe file preceded with a semicolon (;).
For example, in the image below, we have added “; C:\Python34.”

7. Click OK and close all windows.

By setting this up, you can execute Python scripts like this: Python script.py
Instead of this: C:/Python34/Python script.py
As you can see, it is cleaner and more manageable.

4.2 Backend (MySQL)

MySQL is the world's most used open-source relational database management system (RDBMS) as
of 2008 that runs as a server providing multi-user access to several databases. The MySQL development
project has made its source code available under the terms of the GNU General Public License, as well as
under a variety of proprietary agreements. MySQL was owned and sponsored by a single for-profit firm, the
Swedish company MySQL AB, now owned by Oracle Corporation.

MySQL is a popular choice of database for use in web applications and is a central component of the
widely used LAMP open-source web application software stack—LAMP is an acronym for "Linux, Apache,
MySQL, Perl/PHP/Python." Free-software-open-source projects that require a full-featured database
management system often use MySQL.
 17

For commercial use, several paid editions are available, and offer additional functionality.
Applications which use MySQL databases include: TYPO3, Joomla, Word Press, phpBB, MyBB, Drupal
and other software built on the LAMP software stack. MySQL is also used in many high-profile, large-scale
World Wide Web products, including Wikipedia, Google (though not for searches), Imagebook, Twitter,
Flickr, Nokia.com, and YouTube.

Inter images

MySQL is primarily an RDBMS and ships with no GUI tools to administer MySQL databases or
manage data contained within the databases. Users may use the included command line tools, or use MySQL
"front ends", desktop software and web applications that create and manage MySQL databases, build
database structures, back up data, inspect status, and work with data records. The official set of MySQL
front-end tools, MySQL Workbench is actively developed by Oracle, and is freely available for use.

Graphical
The official MySQL Workbench is a free integrated environment developed by MySQL AB, which
enables users to graphically administer MySQL databases and visually design database structures. MySQL
Workbench replaces the previous package of software, MySQL GUI Tools. Similar to other third-party
packages, but still considered the authoritative MySQL frontend, MySQL Workbench lets users manage
database design & modeling, SQL development (replacing MySQL Query Browser) and Database
administration (replacing MySQL Administrator).MySQL Workbench is available in two editions, the
regular free and open source Community Edition which may be downloaded from the MySQL website, and
the proprietary Standard Edition which extends and improves the feature set of the Community Edition.

Command line
MySQL ships with some command line tools. Third parties have also developed tools to manage a
MySQL server, some listed below. Maat kit - a cross-platform toolkit for MySQL, PostgreSQL and
Memcached, developed in Perl Maat kit can be used to prove replication is working correctly, fix
corrupted data, automate repetitive tasks, and speed up servers. Maat kit is included with several GNU/Linux
distributions such as CentOS and Debian and packages are available for Programming.
 18

MySQL works on many different system platforms, including AIX, BSD, FreeBSD, HP-UX, eComStation,
i5/OS, IRIX, Linux, Mac OS X, Microsoft Windows, NetBSD, Novell NetWare, OpenBSD, Open Solaris,
OS/2 Warp, QNX, Solaris, Symbian, SunOS, SCO Open Server, SCO UnixWare, Sanos and Tru64. A port
of MySQL to OpenVMS also exists.

MySQL is written in C and C++. Its SQL parser is written in Yac, and a home-brewed lexical
analyzer. Many programming languages with language-specific APIs include libraries for accessing MySQL
databases. These include MySQL Connector/Net for integration with Microsoft's Visual Studio (languages
such as C# and VB are most used) and the JDBC driver for Java. In addition, an ODBC interim age called
MyODBCallows additional programming languages that support the ODBC inter image to communicate
with a MySQL database, such as ASP or ColdFusion. The HTSQL - URL-based query method also ships
with a MySQL adapter, allowing direct interaction between a MySQL database and any web client via
structured URLs.

Features

As of April 2009, MySQL offered MySQL 5.1 in two different variants: the open-source MySQL
Community Server and the commercial Enterprise Server. MySQL 5.5 is offered under the same licenses.
They have a common code base and include the following features:
● A broad subset of ANSI SQL 99, as well as extensions

● Cross-platform support

● Stored procedures

● Triggers

● Cursors

● Updatable Views

● Information schema

● Strict mode (ensures MySQL does not truncate or otherwise modify data to conform to an underlying
data type, when an incompatible value is inserted into that type)
● X/Open distributed transaction processing (DTP) support; two phase commits as part of this,
using Oracle's InnoDB engine
● Transactions with the InnoDB, and Cluster storage engines

● SSL support
 19

● Query caching

● Sub-SELECTs (i.e. nested SELECTs)

● Replication support (i.e. Master-Master Replication & Master-Slave Replication) with one master per
slave, many slaves per master, no automatic support for multiple masters per slave.
● Full-text indexing and searching using My ISAM engine

● Embedded database library

● Partitioned tables with pruning of partitions in optimizer

● Shared-nothing clustering through MySQL Cluster

● Hot backup (via MySQL hot copy) under certain conditions

Multiple storage engines, allowing one to choose the one that is most effective for each table in the
application (in MySQL 5.0, storage engines must be compiled in; in MySQL 5.1, storage engines can be
dynamically loaded at run time): Native storage engines (My ISAM, Falcon, Merge, Memory (heap),
Federated, Archive, CSV, Black Hole, Cluster, EXAMPLE, Maria, and InnoDB, which was made the default
as of 5.5). Partner-developed storage engines (solid DB, Nitro EDB, Scale DB, Toku DB, Info bright
(formerly BrightHouse), Kick fire, Xtra DB, IBM DB2). InnoDB used to be a partner-developed storage
engine, but with recent acquisitions, Oracle now owns both MySQL core and InnoDB

Partner-developed storage engines expand MySQL's capabilities further. solidDB and NitroEDB cater to specialized
performance needs, while ScaleDB provides scalable solutions for high-volume environments. TokuDB offers efficient
storage and retrieval for large datasets through its fractal tree indexing, and Infobright (formerly BrightHouse) focuses on
analytical processing. Kickfire and XtraDB (a high-performance variant of InnoDB) are designed for data-intensive
operations, while IBM DB2 integration extends MySQL's reach into enterprise environments.

InnoDB, originally a partner-developed storage engine, is now owned by Oracle along with MySQL core, following
Oracle's acquisition. This integration underscores InnoDB's critical role in MySQL's architecture, combining transactional
robustness with MySQL's widespread adoption and flexibility. These diverse storage engines ensure that MySQL can be
tailored to meet a wide range of application demands, from simple web applications to complex, high-transaction
enterprise systems.
 20

CHAPTER 5
SYSTEM DESIGN

5.1 INTRODUCTION
The system design for the NFT-based digital ownership platform revolves around leveraging block chain
technology and Non-Fungible Tokens (NFTs) to establish and verify ownership of digital and physical
goods. Users, including administrators, sellers, and buyers, will have unique accounts that require
authentication upon login. User management functionalities will allow for registration, login, and profile
management, ensuring secure access to the platform. Sellers will be able to create detailed listings for goods,
such as artworks, providing descriptions, images, and metadata. Listings will be categorized and searchable,
enabling buyers to browse and discover items of interest easily. The platform will tokenize assets into NFTs
using block chain technology, ensuring transparency and immutability of ownership records. Smart contracts
will govern the transfer of ownership between parties, defining the terms and conditions of transactions.
Mechanisms will be in place to verify the authenticity of NFTs associated with assets, including provenance
information, artist details, and certificates of authenticity. This verification process will instill confidence in
buyers regarding the legitimacy of their purchases. The platform will facilitate secure and transparent
transactions between buyers and sellers. Buyers will be able to initiate purchase requests, which sellers can
accept or reject. Payments will be processed securely through integrated payment gateways, ensuring
financial security for all parties involved.

5.2 NORMALIZATION

Normalization is a crucial process in database design aimed at organizing data efficiently and ensuring
data integrity. Its primary objective is to address issues stemming from data redundancy, which occurs when
the same data is repeated across multiple records in a database. By eliminating redundancy, normalization
helps prevent inconsistencies and anomalies that can arise during data manipulation operations such as
insertion, deletion, and updating. Decomposition, an integral part of normalization, involves splitting
relations (tables) into multiple smaller relations to eliminate anomalies while maintaining data integrity. This
is achieved by adhering to a set of rules known as normal forms, which provide guidelines for structuring
relations in a database. These normal forms progressively refine the organization of data, starting from the
First Normal Form (1NF) and culminating in higher forms such as the Boyce-Codd Normal Form (BCNF)
and Fifth Normal Form (5NF). Common anomalies addressed by normalization include insertion anomalies,
 21

where data cannot be added due to missing related information; deletion anomalies, resulting in unintentional
loss of data when deleting records; and update anomalies, causing data inconsistency due to redundancy and
partial updates. Overall, normalization ensures that databases are well-structured, efficient, and free from
anomalies, thereby enhancing data reliability and usability.

5.3 SYSTEM ARCHITECTURE DESIGN

A system architecture or systems architecture is the conceptual model that defines the structure, behavior,
and more views of a system. An architecture description is a formal description and representation of
a system, organized in a way that supports reasoning about the structures and behaviors of the system.
System architects or solution architects are the people who know what components to choose for the specific
use case, make right trade-offs with awareness of the bottlenecks in the overall system. Usually, solution
architects who have more years of experience tend to be good at system architecting because system design
is an open-ended problem, there is no one correct solution. Mostly it’s trial and error experiments done with
the right trade-offs. So, experience teaches you what components to choose based on the problem at hand but
to gain that experience you need to start somewhere. That’s why I am writing this article for developers who
have never done system designs.

The system architecture is mainly based on fuzzy nature analytics where the learner behavior while
learning a course and his style of learning is efficiently predicted using the intuitionistic fuzzy logic. The
observer system can be designed with the modeling of various attributes like knowledge credibility, learner
aggregation, learner objects

System architecture is a complex and dynamic field that requires a balance of theoretical knowledge and
practical experience. By understanding the basics, practicing hands-on, analyzing real-world systems,
seeking feedback, and continuously improving, developers can gradually build the skills necessary to design
robust and efficient systems. Leveraging advanced techniques such as fuzzy nature analytics can further
enhance the adaptability and intelligence of your system designs, particularly in specialized applications like
educational platforms.
 22

Fig 5.3.1 Architectural Diagram

5.4 E – R DIAGRAM:

The relation upon the system is structured through a conceptual ER-Diagram, which not only
specifies the existing entities, but also the standard relations through which the system exists and the
cardinalities that are necessary for the system state to continue. The Entity Relationship Diagram (ERD)
depicts the relationship between the data objects. The ERD is the notation that is used to conduct the date
modeling activity, the attributes of each data object noted, is the ERD can be described with a data object
description. The set of primary components that are identified by the ERD are Data object Relationships
Attributes Various types of indicator The primary purpose of the ERD is to represent data objects and their
relationships.
 23

Fig 5.4.1 ER Diagram

5.5 DATA FLOW DIAGRAM:

A two-dimensional diagram explains how data is processed and transferred in a system. The graphical
depiction identifies each source of data and how it interacts with other data sources to reach a common
output. Individuals seeking to draft a data flow diagram must identify external inputs and outputs, determine
how the inputs and outputs relate to each other, and explain with graphics how these connections relate and
what they result in. This type of diagram helps business development and design teams visualize how data is
processed and identify or improve certain aspects.
Data Flow Diagrams are essential tools in system design and analysis, offering a clear visual
representation of data processes. By meticulously mapping out inputs, processes, and outputs, businesses can
streamline their operations, identify areas for improvement, and ensure that all stakeholders have a unified
understanding of the system. Utilizing DFDs fosters better communication, enhances system efficiency, and
supports ongoing development and refinement efforts.
A high-level view showing the system as a single process with external entities and major data flows.
 24

Data flow Symbols:

Symbol Description

An entity. A source of data or a destination

for data.

A process or task that is performed by the

system.

A data store, a place where data is held

between processes.

A data flow.

LEVEL 0

DFD Level 0 is also called a Context Diagram. It’s a basic overview of the whole system or process
being analyzed or modeled. It’s designed to be an at-a-glance view, showing the system as a single high-
level process, with its relationship to external entities. It should be easily understood by a wide audience,
including stakeholders, business analysts, data analysts and developers.
Clear Communication: Provides a simplified overview that can be understood by stakeholders with
varying levels of technical expertise.
Requirements Gathering: Helps in gathering and validating system requirements by providing a
visual representation of system interactions.
System Boundary Definition: Clearly defines what is inside the system and what is external, helping
to set appropriate boundaries for the system.
 25

LEVEL 1

DFD Level 1 provides a more detailed

breakout of pieces of the Context Level Diagram.
You will highlight the main functions carried out
by the system, as you break down the high-level process of the Context Diagram into its sub–processes. A
level 1 data flow diagram (DFD) is more detailed than a level 0 DFD but not as detailed as a level 2
DFD. It breaks down the main processes into sub processes that can then be analyzed and improved on a
more intimate level.
Detailed Analysis: Allows for a deeper understanding of specific system functions, facilitating
targeted improvements.
Improved Communication: Provides a more detailed view that helps technical and non-technical
stakeholders understand specific processes.
 26

Purchase request

Fig 5.5.2 level 1 DFD

Foundation for Further Detailing: Sets the stage for Level 2 DFDs, which can break down sub-processes even
further if necessary.
Enhanced System Design: Helps in identifying bottlenecks, redundancies, and inefficiencies within specific
processes.
 27

5.6 UML DIAGRAM

A UML diagram is a diagram based on the UML (Unified Modeling Language) with the purpose of
visually representing a system along with its main actors, roles, actions, artifacts or classes, in order to better
understand, alter, maintain, or document information about the system.
Understand the Purpose: Clearly define what you want to achieve with the diagram. Different
diagrams serve different purposes.
Keep it Simple: Avoid unnecessary complexity. Focus on the most important elements relevant to the
audience.
Use Standard Notations: Stick to standard UML symbols and notations to ensure clarity and
consistency.
Validate with Stakeholders: Regularly review diagrams with stakeholders to ensure they meet
requirements and accurately represent the system.
Iterate as Needed: Be prepared to update and refine diagrams as the system evolves.

USE CASE DIAGRAM

Use case diagrams are usually referred to as behavior diagrams used to describe a set of actions
(use cases) that some system or systems (subject) should or can perform in collaboration with one or more
external users of the system (actors). In software and systems engineering, a use case is a list of actions or
event steps typically defining the interactions between a role (known in the Unified Modeling Language as
an actor) and a system to achieve a goal. The actor can be a human or other external system. An actor in the
Unified Modeling Language (UML) "specifies a role played by a user or any other system that interacts with
the subject." "An Actor models a type of role played by an entity that interacts with the subject (e.g., by
exchanging signals and data), but which is external to the subject." UML Use Case Include. Use case include
is a directed relationship between two use cases which is used to show that behavior of the included use
case (the addition) is inserted into the behavior of the including (the base) use case.
 28

Fig 5.6.1 use case diagram

ACTIVITY DIAGRAM
An activity diagram is a type of behavioral diagram in Unified Modeling Language (UML) that
visually represents the flow of activities and actions within a system or process. It illustrates the sequence of
actions, decisions, and transitions that occur during the execution of a particular use case or business process.
Activity diagrams are commonly used in software development, business process modeling, and system
analysis to depict the dynamic aspects of a system.
 29

 Clarity: Provides a clear visual representation of the workflow or process.

 Communication: Enhances communication among stakeholders by providing a
common understanding of the process.
 Analysis: Helps identify bottlenecks, inefficiencies, and areas for improvement.
 Documentation: Serves as a useful documentation tool for processes and
workflows.
 Software Development: To model the workflow of a particular use case or
feature.
 Business Process Modeling: To represent business processes and workflows.
 System Analysis: To analyze and understand the dynamic behavior of a system.

Fig 5.6.2 Activity Diagram

5.7 TABLE DESIGN:

Add NFT provider

 30

Fie Type Null Default

ld
id int (50) Yes NULL
name varchar (100) Yes NULL
contact varchar (100) Yes NULL
email varchar (100) Yes NULL
Address varchar (100) Yes NULL
gender Varchar (100) Yes NULL
password Varchar (100) Yes NULL

Seller register

Fie Type Null Default

ld
name int (50) Yes NULL
contact varchar (100) Yes NULL
email varchar (100) Yes NULL
address varchar (100) Yes NULL
Pan card varchar (100) Yes NULL
aadhar int (50) Yes NULL
password varchar (100) Yes NULL

Add product

Fie Type Null Default

ld
product name varchar (50) Yes NULL

price varchar (50) Yes NULL

description Varchar (50) Yes NULL

bill id Varchar (50) Yes NULL

31
 32

CHAPTER 6

OUTPUT SCREENS
33
34
35
36
37
38
39
40
41
42
43
44
45
46
 47

CHAPTER 7

SYSTEM TESTING AND IMPLEMENTATION

TESTING

Testing is a series of different tests whose primary purpose is to fully exercise the computer-based
system. Although each test has a different purpose, all work should verify that all system elements have been
properly integrated and performed allocated function. Testing is the process of checking whether the
developed system works according to the actual requirement and objectives of the system. The philosophy
behind testing is to find the errors. A good test is one that has a high probability of finding an undiscovered
error. A successful test is one that uncovers the undiscovered error. Test cases are devised with this purpose
in mind. A test case is a set of data that the system will process as an input.

SYSTEM TESTING

After a system has been verified, it needs to be thoroughly tested to ensure that every component of
the system is performing in accordance with the specific requirements and that it is operating as it should
include when the wrong functions are requested, or the wrong data is introduced.

Testing measures consist of developing a set of test criteria either for the entire system or for specific
hardware, software and communications components. For an important and sensitive system such as an
electronic voting system, a structured system testing program may be established to ensure that all aspects of
the system are thoroughly tested.

Testing measures that could be followed include:

 Applying functional tests to determine whether the test criteria have been met
 Applying qualitative assessments to determine whether the test criteria have been met.
 Conducting tests in “laboratory” conditions and conducting tests in a variety of “real life”
conditions.
 Conducting tests over an extended period to ensure systems can perform consistently.
 48

 Conducting “load tests”, simulating as close as possible likely conditions while using or
exceeding the amounts of data that can be expected to be handled in an actual situation.

Test measures for hardware may include:

 Applying “non-operating” tests to ensure that equipment can stand up to expected levels of physical
handling.
 Testing “hard wired” code in hardware (firmware) to ensure its logical correctness and that
appropriate standards are followed.

 Tests for software components also include:

 Testing all programs to ensure its logical correctness and that appropriate design, development and
implementation standards have been followed.
 Conducting “load tests”, simulating as close as possible a variety of “real life” conditions using or

 exceeding the amounts of data that could be expected in an actual situation.

 Verifying that integrity of data is maintained throughout its required manipulation.

Fig 7.1 System testing

 49

UNIT TESTING
The first test in the development process is the unit test. The source code is normally divided into
modules, which in turn are divided into smaller units called units. These units have specific behavior. The
test done on these units of code is called unit test. Unit test depends upon the language on which the project
is developed.

Unit tests ensure that each unique path of the project performs accurately to the documented specifications
and contains clearly defined inputs and expected results. Functional and reliability test in an Engineering
environment, producing tests for the behavior of components (nodes and vertices) of a product to ensure their
correct behavior prior to system integration.

Fig 7.2 Unit testing

INTEGRATION TESTING

Testing is in which modules are combined and tested as a group. Modules are typically code
modules, individual applications, source and destination applications on a network, etc. Integration Testing
follows unit testing and precedes system testing. Testing after the product is code complete.
 50

Betas are often widely distributed or even distributed to the public at large in hopes that they will buy
the final product when it is released.

Fig 7.3 Integration testing

VALIDATION TESTING

Validation testing is testing where tester performed functional and non-functional testing. Here
functional testing includes Unit Testing (UT), Integration Testing (IT) and System Testing (ST), and non-
functional testing includes User acceptance testing (UAT). Validation testing is also known as dynamic
testing, where we are ensuring that "we have developed the product right." And it also checks that the
software meets the business needs of the client. It is a process of checking the software during or at the end
of the development cycle to decide whether the software meets the specified business requirements. We can
validate that the user accepts the product or not.

Conducted to ensure the software meets business requirements and can be used
by the end-users. Typically performed by the client or end-users. Validates that
the software handles real-world scenarios and user workflows.
 51

Fig 7.4 Validation Testing

7.2 CODING

import csv

import os

import random

from datetime import date, timedelta

import re

from difflib import SequenceMatcher

from random import randint, randrange

import uuid

from datetime import datetime

from url lib import request

 52

import py m sql

from werkzeug.utils import secure_filename

import socket

import ar_master

import smtp lib, ssl

from flask import Flask, render_template, request, session, Response, current_app,

send_from_directory, redirect, \

url_for

from blockchain import blockchain_method

app = Flask( name , static_folder='static',template_folder='templates',static_url_path='/static')

app.config.from_object( name )

app.config['SECRET_KEY'] = '7d441f27d441f27567d441f2b6176a'

from uuid import uuid4

node_address = str(uuid4()).replace('-', '')

ar=blockchain_method()

mm =

ar_master.master_flask_code('python_blockchain_based_nft')

@app.route("/")

def homepage():

return render_template('index.html')

@app.route("/dw_admin")

def dw_admin():

return render_template('dw_admin.html', error='')

@app.route("/dw_admin_login", methods = ['GET', 'POST'])

def dw_admin_login():
 53

error = "Login Failed"

if request.method == 'POST':

if request.form['Email'] == 'dwa' and request.form['Password'] == '123':

session['admin']='dw_admin'

return render_template('dw_admin_home.html',error=error)

else:

return render_template('dw_admin.html', error=error)

@app.route("/admin")

def admin():

return render_template('admin.html', error='')

@app.route("/admin_login", methods = ['GET', 'POST'])

def admin_login():

error = "Login Failed"

if request.method == 'POST':

if request.form['Email'] == 'admin' and request.form['Password'] == 'admin':

session['admin'] = 'admin'

return render_template('admin_home.html',error=error)

else:

return render_template('admin.html', error=error)

@app.route("/admin_home")

def admin_home():

blockchain_data =

ar.get_chain_data()

print(blockchain_data)

return render_template('admin_home.html', error='',blockchain_data=blockchain_data)

 54

@app.route("/dw_admin_home")

def dw_admin_home():

return render_template('dw_admin_home.html', error='')

@app.route("/admin_add_nft_provider",methods = ['GET', 'POST'])

def admin_add_nft_provider():

if request.method == 'POST':

id = request.form['id']

name = request.form['name']

contact = request.form['contact']

email = request.form['email']

address = request.form['address']

gender = request.form['gender']

password = request.form['password']

maxin=mm.find_max_id("nft_provider")

result=mm.insert_query("insert into nft_provider

values('"+str(maxin)+"','"+str(id)+"','"+str(name)+"','"+str(contact)+"','"+str(email)+"','"+str(address)+"','"+st

r(gender)+"','"+str(password)+"','0','0')")

if (result == 1):

return render_template('admin_add_nft_provider.html',flash_message=True,msg="Registration

Successfully")

else:
 55

return render_template('admin_add_nft_provider.html',

msg="Failed") return render_template('admin_add_nft_provider.html',

msg="")

@app.route("/seller")

def seller():

return render_template('seller.html', error='')

@app.route("/seller_login",methods = ['GET', 'POST'])

def seller_login():

if request.method == 'POST':

n = request.form['Email']

g = request.form['Password']

q = ("SELECT * from seller_details where email='" + str(n) + "' and password='" + str(g) + "'")

data = mm.select_direct_query(q)

data1 = len(data)

if data1 == 0:

return render_template('seller.html', flash_message=True,

error="Failed") else:

msg = 'Success'

session['seller'] = n

session['seller_id'] = data [0]

[1]

session['seller_name'] = data [0][2]

return render_template('seller_home.html', sid=n)

return render_template('seller.html', error='')

@app.route("/seller_register", methods=['GET', 'POST'])

 56
def seller_register():
 57

if request.method == 'POST':
name = request.form['Name']
contact = request.form['contact']
email = request.form['email']
address = request.form['address']
pan = request.form['pan']
aadhar = request.form['aadhar']
password = request.form['Password']
maxin = mm.find_max_id("seller_details")

qq = "insert into seller_details values('" + str(maxin) + "','" + str(name) + "','" + str(contact) + "','" + str(
email) + "','" + str(address) + "','" + str(pan) + "','" + str(aadhar) + "','" + str(password) + "','0','0')"
result = mm.insert_query(qq)

if (result == 1):

return render_template('seller.html',flash_message=True,data="Success")
else:
return render_template('seller_register.html')
return render_template('seller_register.html',
error='')
@app.route("/seller_home")
def seller_home():
return render_template('seller_home.html', error='')
@app.route("/seller_add_product", methods=['GET', 'POST'])
def seller_add_product():
import socket
 58

hostname = socket.gethostname()

IPAddr =

socket.gethostbyname(hostname)

print(IPAddr)

import uuid

mac=(hex(uuid.getnode()))

print(mac)

seller=session['seller']

if request.method == 'POST':

product_name = request.form['product_name']

price = request.form['price']

description = request.form['description']

bill_id = request.form['bill_id']

l1 = request.form['lat']

l2 = request.form['lon']

f1 = request.files['file']

f1.save(os.path.join("static/uploads/", secure_filename(f1.filename)))

f2 = request.files['file2']

f2.save(os.path.join("static/uploads/", secure_filename(f2.filename)))

f3 = request.files['file3']

f3.save(os.path.join("static/uploads/", secure_filename(f3.filename)))

f4 = request.files['file4']

f4.save(os.path.join("static/uploads/", secure_filename(f4.filename)))

today = date.today()

maxin = mm.find_max_id("product_details")
 59

qq = "insert into product_details values('" + str(maxin) + "','" + str(seller) + "','" + str(product_name) +

"','" + str(

price) + "','" + str(description) + "','" + str(bill_id) + "','" + str(f1.filename) + "','" + str(f2.filename) +

"','" + str(f3.filename) + "','" + str(f4.filename) + "','0','0','"+str(IPAddr)+"','"+str(mac)

+"','"+str(l1)+"','"+str(l2)+"')"

result = mm.insert_query(qq)

if (result == 1):

return render_template('seller_add_product.html',flash_message=True,data="Success")

else:

return render_template('seller_add_product.html', data='Failed')

return render_template('seller_add_product.html', error='')

@app.route("/nft_provider")

def nft_provider():

return render_template('nft_provider.html', error='')

@app.route("/nft_provider_login", methods = ['GET', 'POST'])

def nft_provider_login():

error = "Login Failed"

if request.method == 'POST':

n = request.form['Email']

g = request.form['Password']

q = ("SELECT * from nft_provider where email='" + str(n) + "' and password='" + str(g) + "'")

print(q)

data = mm.select_direct_query(q)
 60

data1 = len(data)

if data1 == 0:

return render_template('nft_provider.html', flash_message=True,

error="Failed") else:

msg = 'Success'

return render_template('nft_provider_home.html')

@app.route("/nft_provider_home")

def nft_provider_home():

return render_template('nft_provider_home.html', error='')

@app.route("/nft_provider_request")

def nft_provider_request():

data=mm.select_direct_query("SELECT * FROM product_details where status='0' order by id")

return render_template('nft_provider_request.html',items=data)

@app.route('/nft_provider_request1/<string:id>', methods=['GET','POST'])

def nft_provider_request1(id):

session['id']=id

data=mm.select_direct_query("select * from product_details where id='"+str(id)+"'")

return render_template('nft_provider_request1.html', items=data)

@app.route("/nft_provider_request2", methods = ['GET', 'POST'])

def nft_provider_request2():

error = "Login Failed"

import time

ts = time.time()

rid=(int(ts))
 61

id=session['id']

today = date.today()

if request.method == 'POST':

a1=request.form['Submit']

if a1 =="Accept":

data = mm.select_direct_query("select * from product_details where id='" + str(id) + "'")

for x in data:

ip=x[12]

mac=x[13]

l1=x[14]

l2=x[15]

seller=x[1]

product=x[2]

price=x[3]

maxin = mm.find_max_id("track_owner_ship")

qq = "insert into track_owner_ship values('" + str(maxin) + "','" + str(seller) + "','" + str(rid) + "','"

+ str(today) + "','" + str(ip) + "','" + str(mac) + "','" + str(l1) + "','" + str(l2) + "','0','0')"

result = mm.insert_query(qq)

mm.insert_query("update product_details set status='Accept',report='"+str(rid)+"' where

id='"+str(id)+"'")

previous_block = ar.get_previous_block()
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
 78

CHAPTER 8

SYSTEM SECURITY

8.1 INTRODUCTION

The security of a system built around Non-Fungible Tokens (NFTs) to manage ownership and transfer of
digital and physical assets is crucial given the potential for fraud and unauthorized access. Implement robust
access controls to restrict access to sensitive functionalities and data. Role-based access control (RBAC) can
be employed to assign permissions based on user roles such as administrators, sellers, and buyers.
Additionally, multi-factor authentication (MFA) should be enforced to enhance login security and prevent
unauthorized access. All sensitive data, including user credentials, transaction details, and NFT ownership
records, should be encrypted both in transit and at rest using strong encryption algorithms. This prevents
unauthorized access to data, even if the system or database is compromised. Smart contracts governing
ownership transfers should be thoroughly audited and tested to identify and mitigate vulnerabilities. This
includes vulnerabilities such as reentrancy attacks, integer overflow, and unauthorized access. Code reviews
and best practices in smart contract development should be followed to enhance security. Leverage the
immutability of block chain technology to ensure that data related to ownership transfers is tamper-proof and
resistant to unauthorized modifications. Each transaction and ownership transfer should be recorded on the
block chain, providing an immutable audit trail of asset ownership.

8.2 SECURITY IN SOFTWARE

Ensuring software security in a system leveraging Non-Fungible Tokens (NFTs) for ownership and
authenticity verification is crucial to mitigate risks associated with fraudulence and unauthorized access. The
security framework for such a system must encompass several key aspects: Firstly, robust authentication
mechanisms are essential to verify the identity of users and ensure that only authorized individuals can
access the platform. This includes implementing secure login procedures, such as multi-factor authentication,
to prevent unauthorized access to user accounts. Secondly, the integrity and confidentiality of data must be
safeguarded through encryption techniques. Sensitive information, including user credentials, transaction
details, and NFT metadata, should be encrypted both at rest and in transit to prevent unauthorized disclosure
or tampering.
 79

CHAPTER 9

CONCLUSION

In conclusion, the adoption of Non-Fungible Tokens (NFTs) presents a promising solution to address the
challenges of ownership and authenticity in both the digital and real-world domains. By leveraging block
chain technology and smart contracts, NFTs enable transparent and immutable records of ownership,
providing a secure and reliable way to verify the authenticity of assets. This is particularly relevant in the
context of digital artworks, where issues of ownership and credit are prevalent in the fast-growing digital
world. NFTs offer digital creators, such as artists and content creators, the opportunity to securely monetize
and protect their work, mitigating the risk of fraud and unauthorized replication. Furthermore, NFTs hold
great potential beyond the realm of digital art, offering a novel approach to representing ownership and
authenticity for a wide range of assets, including collectibles, virtual goods, and intellectual property. As
block chain technology continues to evolve and gain mainstream adoption, NFTs are poised to revolutionize
the way we perceive and transact with both digital and real-world entities, ushering in a new era of trust and
security in our business environment.

 Environmental Impact: The energy consumption of blockchain networks,

particularly those using proof-of-work consensus mechanisms, raises environmental
concerns. Solutions such as proof-of-stake and other eco-friendly consensus
algorithms are being explored to mitigate this issue.
 Regulation and Legal Framework: The regulatory landscape for NFTs is still
evolving, and there is a need for clear legal frameworks to address issues related to
ownership, taxation, and intellectual property rights.
 Market Volatility: The NFT market is highly speculative and can be volatile.
Buyers and sellers must exercise caution and conduct thorough research before
engaging in NFT transactions.
 Security Risks: While blockchain technology provides robust security features,
vulnerabilities in smart contracts and user interfaces can be exploited. Ensuring the
security of NFT platforms and educating users about safe practices is crucial.
 80

CHAPTER 10

FUTURE ENHANCEMENT

A future enhancement for NFT-based solutions in the realm of digital art ownership and credit could
involve the integration of decentralized identity protocols. These protocols would allow digital artists to
establish and maintain verifiable digital identities tied to their artworks. By associating unique identifiers
with their creations, artists can assert their ownership and authorship rights more effectively.

Technical Complexity:
Challenge: Implementing decentralized identity protocols can be technically complex.
Solution: Develop user-friendly interfaces and tools to simplify the process for artists and collectors.
Adoption and Standardization:
Challenge: Widespread adoption and standardization of decentralized identity protocols are needed
for interoperability.
Solution: Collaborate with industry stakeholders to create and promote standards, ensuring cross-
platform compatibility.
Privacy and Security:
Challenge: Ensuring the privacy and security of digital identities.
Solution: Utilize advanced cryptographic techniques and privacy-preserving technologies to protect
user data.
Artists register their digital identities on a decentralized identity platform.
These identities are secured using cryptographic keys and stored on a blockchain.
When creating an NFT, the artist’s digital identity is linked to the artwork.
Metadata associated with the NFT includes the artist's unique identifier, ensuring permanent linkage.
Buyers and collectors can verify the authenticity and ownership of an artwork by checking the artist’s
digital identity against the blockchain records.
This process can be automated through smart contracts and integrated into NFT marketplaces.
 81

REFERENCES

BOOK REFERENCES
White Belt Mastery, "SQL For Beginners: SQL Guide to Understand How to Work with a Database," 2nd
Edition 2020

Overview: This book provides a comprehensive guide for beginners to learn SQL (Structured Query
Language), which is essential for managing and manipulating databases. It covers the fundamental concepts and
commands of SQL, enabling readers to perform basic to intermediate database operations.

Content Highlights:

Introduction to SQL and its importance in database management.

Step-by-step instructions on creating, modifying, and querying databases.

Practical examples and exercises to reinforce learning.

Best practices for writing efficient and effective SQL queries.

Mark Lutz, "Python Pocket Reference: Python in Your Pocket," 5th Edition 2023

Overview: This pocket reference is a quick-access guide to Python programming, offering concise and
precise information on the language. It serves as a handy reference for experienced programmers and beginners
alike.

[1] White Belt Mastery · “SQL For Beginners: SQL Guide to understand how to work with a Data
Base” 2nd edition 2020.

[2] Eric Matthes,” Python Crash Course”, 2nd edition 2020.

[3] Mark Lutz “Python Pocket Reference: Python in Your Pocket”, 5th edition 2023.

WEB REFERENCES

1. https://www.researchgate.net/publication/347555599_Students'_attention_in_class_Patterns_percepti
ons_of_cause_and_a_tool_for_measuring_classroom_quality_of_life

2. https://www.irjweb.com/Face%20Recognition%20Using%20Machine%20Learning.pdf