Name – Saurabh Umbarkar

Roll no – 60
PRN no - 2043110151
Branch - CSE
Subject - Block Chain and Digital Currency

Experiment - 4

Aim - Write a program in solidity to create Student data.

Use the following constructs:
• Structures
• Arrays
• Fallback
Deploy this as smart contract on Ethereum and Observe
the transaction fee and Gas values

Theory -

Solidity is an object-oriented programming language for

implementing smart

contracts on various blockchain platforms, most notably, Ethereum.

It was developed

by Christian Reitwiessner, Alex Beregszaszi, and several former

Ethereum core
contributors. Programs in Solidity run on Ethereum Virtual
Machine.

Solidity was proposed in August 2014 by Gavin Wood; the language

was later

developed by the Ethereum project's Solidity team, led by Christian

Reitwiessner.

Solidity is the primary language on Ethereum as well as on other

private blockchains,

such as the enterprise-oriented Hyperledger Fabric blockchain.

SWIFT deployed a

proof of concept using Solidity running on Hyperledger Fabric.

- Solidity - Struct
Structs in Solidity allow you to create more complicated data types
that have multiple

properties. You can define your own type by creating a

struct

They are useful for grouping together related data.

Structs can be declared outside of a contract and imported in another

contract.

Generally, it is used to represent a record. To define a structure

struct
keyword is

used, which creates a new data type.

Syntax:
struct <structure_name> {
<data type> variable_1;

<data type> variable_2

; }

- Solidity - Arrays
In Solidity, an array can be of compile-time fixed size or of dynamic
size. For storage

array, it can have different types of elements as well. In case of

memory array,

element type can not be mapping and in case it is to be used as

function parameter

then element type should be an ABI type.

All arrays consist of contiguous memory locations. The lowest

address corresponds to

the first element and the highest address to the last element.
Declaring Arrays

To declare an array of fixed size in Solidity, the programmer

specifies the type of the

elements and the number of elements required by an array as

follows

type arrayName [ arraySize ];

This is called a single-dimension array. The

arraySize

must be an integer constant

greater than zero and

type

can be any valid Solidity data type. For example, to

declare a 10-element array called balance of type uint, use this

statement

uint balance[10];

To declare an array of dynamic size in Solidity, the programmer

specifies the type of

the elements as follows

type[] arrayName;
Initializing Arrays

You can initialize Solidity array elements either one by one or using
a single

statement as follows

uint balance[3] = [1, 2, 3];

The number of values between braces [ ] can not be larger than the
number of

elements that we declare for the array between square brackets [ ].

Following is an

example to assign a single element of the array

If you omit the size of the array, an array just big enough to hold the
initialization is

created. Therefore, if you write

uint balance[] = [1, 2, 3];

You will create exactly the same array as you did in the previous
example.

balance[2] = 5;
The above statement assigns element number 3rd in the array a
value of 5.

Creating dynamic memory arrays

Dynamic memory arrays are created using new keywords.

uint size = 3;

uint balance[] = new uint[](size);

Accessing Array Elements

An element is accessed by indexing the array name. This is done by
placing the index

of the element within square brackets after the name of the array.
For example

uint salary = balance[2];

The above statement will take 3rd element from the array and assign
the value to

salary variable. Following is an example, which will use all the

above-mentioned

three concepts viz. declaration, assignment and accessing arrays

 - Solidity – Fall Back Function
The solidity fallback function is executed if none of the other
functions match

the function identifier or no data was provided with the function

call. Only one

unnamed function can be assigned to a contract and it is executed

whenever the

contract receives plain Ether without any data. To receive Ether and
add it to the total

balance of the contract, the fallback function must be marked

payable. If no such

function exists, the contract cannot receive Ether through regular

transactions and

will throw an exception.

Properties of a fallback function:

• Has no name or arguments.

• If it is not marked

payable

, the contract will throw an exception if it receives plain

ether without data.

• Can not return anything.

• Can be defined once per contract.

• It is also executed if the caller meant to call a function that is not

available

• It is mandatory to mark it external.

• It is limited to 2300 gas when called by another function. It is so for

as to make this function call as cheap as possible.

Ethereum transaction fee

Ethereum transaction fees work differently in comparison to
Bitcoin's. The fee takes

into account the amount of computing power needed to process a

transaction, known

as gas. Gas also has a variable price measured in ether (ETH), the
network's native

token.

While the gas needed for a specific transaction can stay the same,
gas prices can rise

or fall. This gas price is directly related to network traffic. If you

pay a higher gas

price, miners will likely prioritize your transaction.

How are Ethereum transaction fees calculated?
The total gas fee is simply a price that covers the cost, plus an
incentive to process

your transaction. However, you should also consider the gas limit,
which defines

what's the maximum price paid for that transaction or task.

In other words, the gas cost is the amount of work required, and the
gas price is the

price paid for “each hour” of work. The relation between these two
and the gas limit

defines the total fee for an Ethereum transaction or smart contract

operation

.
Let's pick a random transaction on Etherscan.io as an example. The
transaction cost

21,000 gas, and the gas price was 71 Gwei. So, the total transaction
fee was

1,491,000 Gwei or 0.001491 ETH.

As Ethereum makes its way towards a Proof of Stake model (see

Casper), there is an

expectation that gas fees will decrease. The amount of gas needed to
confirm a

transaction will be lower as the network will need only a fraction of

the
computational power to validate transactions. But, network traffic
can still affect transaction fees as validators prioritize higher-paying
transactions.
Program -
//SPDX-License-Identifier: UNLICENSED

pragma solidity >= 0.7.0 <0.9.0;

// Build the Contract

contract MarksManagmtSys

// Create a structure for

// student details

struct StudentStruct

uint ID;

string fName;

string lName;

uint marks;

address owner;

uint public stdCount = 0;

//Create Array to store Student data

StudentStruct[] stdRecords;

constructor()

owner=msg.sender;

}
// Create a function to add

// the new records

function addNewRecords(uint _ID,

string memory _fName,

string memory _lName,

uint _marks) public payable

// Increase the count by 1

stdCount = stdCount + 1;

//Adding data into array

stdRecords.push(StudentStruct(_ID , _fName , _lName , _marks));

function getAllRecords() public view returns(StudentStruct[] memory)

return stdRecords;

}
Output -
1) An analysis of the transaction fee and gas fee
required for contract deployment.
2) An analysis of the transaction fee and gas fee required for smart
contracts transactions.