Archive
Cardano Academy
Cardano Academy
Certification “Cardano Blockchain Certified Associate” (CBCA)
Module 1 Overview
Introduces the foundation of blockchain, from the main components of a typical blockchain network, to how consensus algorithms provide a mechanism to reach agreement in decentralized systems. It delves into the Byzantine Generals’ Problem and explains what Byzantine and Practical Byzantine fault-tolerant systems are. This module looks at the key concepts behind proof-of-work and proof-of-stake systems, including their respective limitations. Other proof-based consensus models including proof of authority, proof of Importance and proof of History are briefly explored. Encryption methods are examined and how hash functions and digital signatures provide data authenticity and integrity.
Topics
- Introduction to Blockchain
- Consensus Algorithms
- The Byzantine Generals Problem (BGP)
- The Basics of Networks
- Properties of Consensus Algorithms
- The Original Bitcoin Whitepaper
- BFT vs. PoW Consensus Algorithms
- Blockchain Fundamentals
- Components and Structure of a Blockchain
- Blockchain Careers and Use Cases
- Blockchain Generations: First and Second
- Introduction to Ethereum
- Ethereum’s Decentralized Systems
- Third Blockchain Generation
- Cardano’s Native Token
- Blockchain Architecture: Layer 1
- Blockchain Types
- Evolution of the Internet
- Understanding Encryption and Decryption
- Symmetric Encryption
- Asymmetric Encryption
- Attack Models
- Hash Function
- Avalanche Effect
- Resistance
- Types of Hash Functions
- Hash Function Applications
- Signing and Verification Algorithms in Digital Signatures
- The Digital Signature Verification Algorithm Under Attack
- Wallets in a Blockchain Network
- Hot and Cold Storage
- Introduction to Practical Byzantine Fault Tolerance
- Synchrony
- Practical Byzantine Fault Tolerance
- Vote-Based Consensus
- Introduction to Proof-Based Consensus
- Proof of Work
- Proof of Stake
- Different Stakeholders’ Approaches to Proof of Stake
- Proof of Authority (PoA)
- Proof of Activity (PoA)
- Proof of Importance (PoI)
- Proof of Burn (PoB)
- Proof of Capacity (PoC)/Proof of Space (PoSpace)
- Proof of Elapsed Time (PoET)
- Proof of Contribution (PoCo)
- Proof of History (PoH)
Module 2 Overview
Builds on the concepts introduced in Module 1. It defines the transaction models used in blockchain, including account-based, Unspent Transaction Output, and extended Unspent Transaction Output. It examines the content of a block and the role of the block producer. Module 2 also explains how the risks against double-spending and Sybil attacks are mitigated, the causes of soft and hard forks, and the importance of incentive mechanisms. It concludes with a look at layer 1 and layer 2 scaling solutions.
Topics
- Introduction to Transaction Models
- Tokens
- The Transaction Lifecycle
- Record-Keeping Transaction Models
- The UTxO Transaction Model
- Inputs, Outputs and Wallets
- A Blockchain’s State
- Cardano’s Extended UTxO
- The EUTxO model
- Introduction to the Basics of Block Structure
- Longest Chain Algorithms
- Sending and Receiving Transactions via Block Producing Nodes
- Blockchain Miners
- Blockchain Parameters
- The Fundamental Properties of Blockchain
- Double-Spending Attack Example
- Block Generation Power
- Avoiding Double-Spending Attacks
- Soft Fork and Hard Fork
- Introduction to Blockchain Incentives
- Why Blockchain Needs Incentives
- Rewards in Proof-of-Work Protocols
- Types of Networks in Blockchain
- Acquiring Tokens in Mainnet and Testnet
- API and Nodes Communication Protocol
- Nebula’s Architecture
- Introduction To Scalability
- Fundamentals
- Scalability Techniques: Part 1
- Scalability Techniques: Part 2
- Scalability Techniques: Part 3
- Introduction to Layer 2 Solutions
- State Channels
- Drawbacks of State Channels
- Rollups
- Drawbacks of Rollups
- Other Scaling Solutions
Module 3 Overview
Focuses on the Cardano blockchain, it describes Cardano’s genesis and genesis entities, and the mission and principles governing Cardano. It looks at the Cardano node and how the eras have developed and enhanced features of the network. Ouroboros, Cardano’s consensus algorithm, is examined, along with the reward and incentive mechanism of Cardano. The governance process including Cardano Improvement Proposals is explained, along with the role of the Cardano Community.
Topics
- Introduction to Cardano Genesis
- Cardano’s Principles
- Cardano Genesis
- Cardano Roadmap
- Introduction to Cardano Architecture
- Cardano Eras: Part 1
- Cardano Eras: Part 2
- Networking
- Consensus in Public Permissionless Ledgers
- Ouroboros: a Family of Consensus Protocols
- The Ouroboros Family: Classic, Praos and Genesis
- Ouroboros: Crypsinous, Chronos, Leios, BFT and Omega
- Delegated Proof of Stake
- Rewards Sharing Scheme (RSS): Part 1
- Rewards Sharing Scheme (RSS): Part 2
- Wallets
- BIPs and CIPs
- Types of Addresses
- Payment Addresses
- Stake Addresses
- Fundamentals
- Programming on Cardano
- Smart Contract Languages
- Embedded Domain Specific Languages (eDSL)
- Why Does Community Matter?
- Decentralization
- What Does Community Offer?
- Why Cardano?
- Community Groups: Part 1
- Community Groups: Part 2
- History
- Cardano Improvement Proposals
- The CIP Process
- The CIP Actors
- Notable CIPs: Part 1
- Notable CIPs: Part 2
Module 4 Overview
Looks at how to get started buying, storing, and transferring ada. It also examines how staking works on Cardano with the staking lifecycle, along with the role of stake pools and stake pool operators. It describes how to create and transfer both native assets and non-fungible tokens and concludes with a look at decentralized applications and exchanges.
Topics
- Smart Contract Programming Frameworks
- API Query Layers
- Other Tools and Services
- Blockchain Explorers
- Choosing a Wallet
- Getting Started With Your Chosen Wallet
- Buying ADA from a Centralized Exchange (CEX)
- Transactions
- Staking on Cardano
- Stake Pool Operators (SPOs)
- How to Choose a Stake Pool?
- Cardano Foundation Delegation Strategy
- Alice and Bob Q&A
- Chimeric Ledger
- Staking Lifecycle: GUI vs CLI
- Jargon Buster
- Metadata Standards
- Creating a Native Token
- Wallets and DApps Interactions
- DApp Tour: Part 1
- DApp Tour: Part 2
- DApp Tour: Part 3
- Future of DApps on Cardano
- Security and Standards
Practice Exam
9th International Public Procurement Conference

9th International Public Procurement Conference
03.10 – 05.10.2024
Umm Al Quwain, United Arab Emirates
Tentative Program: IPPC9 Tentative Program.doc
Conference Program: IPPC9 Conference Program.doc
Prepared materials for the conference
Title: TENDER SYSTEM USING THE ETHEREUM BLOCKCHAIN PLATFORM: A PROCESS WITHOUT TRUST IN THE ORGANIZER
Paper Status: Accepted
Full paper: Full paper.doc





















Solidity Project: Improvement Stage

Project: Improvement Stage
17.10.2020
Blockchain ecosystem: Ethereum
Programming Language: Solidity
Technologies: Ganache, Truffle, Metamask, Git
Github: here
Description: Smart contract allows you to initiate Improvement Stage of the tender on the Blockchain network and submit improved commercial proposals.
Smart Contract

Screens




Solidity Project: Submitting Initial Commercial Offers
Project: Submitting Initial Commercial Offers
16.10.2020
Blockchain ecosystem: Ethereum
Programming Language: Solidity
Technologies: Ganache, Truffle, Metamask, Git
Github: here
Description: Smart contract allows you to initiate a tender on the Blockchain network and submit initial commercial proposals.
Smart Contract

Screens







Cryptozombies.io Platform
Cryptozombies
via Cryptozombies.io Platform
16.03.2020
Online Educational Course “Solidity Path: Beginner to Intermediate Smart Contracts”
The content of the modules:
- Making the Zombie Factory
- Zombies Attack Their Victims
- Advanced Solidity Concepts
- Zombie Battle System
- ERC721 & Crypto-Collectibles
- App Front-ends & Web3.js
Project
Coursetro.com Platform
Coursetro
via Coursetro.com Platform
04.03.2020
Online Educational Course “Developing Ethereum Smart Contracts for Beginners“
The content of the modules:
1. What are Smart Contracts and Decentralized Apps?
2. Variables and Types
3. Creating a Web UI for our Smart Contract
4. Solidity Events
5. Function Modifiers
6. Mappings and Structs
7. Inheritance & Deployment
8. Finishing the Web3 UI
Project
Coursera: University at Buffalo
University at Buffalo
via coursera.org Platform
04.03.2020
Online Educational Course “Smart Contracts“
This second course of the Blockchain specialization will help you design, code, deploy and execute a smart contract – the computational element of the blockchain technology.
Smart contracts allow for implementing user-defined operations of arbitrary complexity that are not possible through plain cryptocurrency protocols. They allow users to implement conditions, rules and policies of the domain applications. Smart contracts are a powerful feature that, when properly designed and coded, can result in autonomous, efficient and transparent systems.
You will design and program smart contracts in Solidity language, test and deploy them in the Remix development environment, and invoke them from a simple web interface that Remix provides.
This course features best practices for designing solutions with smart contracts using Solidity and Remix IDE. Main concepts are delivered through videos, demos and hands-on exercises.
Syllabus:
WEEK 1. Smart Contract Basics
The purpose of this module is to introduce the reasons for a smart contract and its critical role in transforming blockchain technology from enabling decentralized systems. We will explore the structure and basic concepts of a smart contract through examples, and illustrate Remix (remix.ethereum.org) web IDE for deploying and interacting with a smart contract.
WEEK 2. Solidity
Our goal is to master the basics of Solidity, a high-level language that is a combination of Javascript, Java and C++. It is specially designed to write smart contracts and to target the Ethereum Virtual Machine. Learners will be able to follow demonstrations and practice using Solidity.
WEEK 3. Putting it all Together
This module focuses on the development of the Ballot smart contract incrementally to illustrate various features including time dependencies, validation outside the function code using access modifiers, asserts and require declarations, and event logging.
WEEK 4. Best Practices
This module will focus on best practices including evaluating whether a blockchain-based solution is suitable for your problem, designing Solidity smart contracts, and those relating to Remix IDE.
Bitdegree.org Platform
Bitdegree
via Bitdegree.org Platform
03.03.2020
Online Educational Course “Learn Solidity with Space Doggo: an Interactive Solidity Tutorial”
The content of the modules:
- Contracts
- Variables
- Arithmetics
- Structs
- Mappings
- Using Structs
- Using Mappings
- Hashes and Typecasting
Project
Altcademy.com Platform
Altcademy
via Altcademy.com Platform
01.03.2020
Online Educational Course “Ethereum Smart Contract 101”
The content of the modules:
- Welcome to Ethereum Smart Contract 101
- What is Ethereum and Smart Contract?
- Getting an Ethereum account and some Ethers
- Writing your first contract
- Deploying your contract
- Interact with contracts
Project
Training.eos.io Platform

Eos.io
via Training.eos.io Platform
06.02.2020
Online Educational Course “Smart Contracts 201”
The content of the modules:
Module 1: Assets
- Introduction to tokens
- The eosio.token contract
- The asset type
Module 2: Receiving Transfers
- on_notify, especially [[eosio::on_notify(“eosio.token::transfer”)]]
- The old way: custom apply()
Module 3: In-line Actions
- Review of the eosio.code permission
- require_recipient()
- Explanation of why we must use require_auth(get_self()) with require_recipient()
- <action type>.send(…), the action constructor (permission, action, data)
- Action wrappers
- Custom permissions
Module 4: Singletons
- Appropriate for single-row use cases, such as contract settings
- Using get() and set()
Module 5: Bonus Lab: Add a “Pot” to Tic Tac Toe Games
Module 6: Updating Table Schemas and Migrating Data
- Review of inability to update structure of contract table containing data
- Description of migration options, including the binary_extension wrapper
Module 7: Getting Data from the Outside World
- The Oracle Problem
- Potential exploits (frontrunning, collusion, etc.)
- Delphi
- Provable
- Native EOSIO Oracles
- LiquidOracles
Module 8: Organizing Action Parameters
- Action parameter list organization and serializiation
- Situations requiring packed parameters
Module 9: Randomness
- Recap of the need for determinism in blockchains
- Pseudo-randomness and its dangers
- Multi-party randomness
- Oracle-based randomness
Module 10: Scheduled and Recurring Actions
- Deprecated: deferred transactions
- Provable, LiquidOracles, and other methods for scheduling actions
- Using contract design to mitigate the need for scheduled actions
Module 11: User-Friendly Resource Management
- RAM Payer
- ONLY_BILL_FIRST_AUTHORIZER
Module 12: More to Explore: Interoperability and Testing Frameworks
- Intro to interoperability/IBC
- Survey of testing tools available for EOSIO smart contracts
Training.eos.io Platform

Eos.io
via Training.eos.io Platform
05.02.2020
Online Educational Course “Smart Contracts 101”
The content of the modules:
- Module 0: Survey of Prerequisite Knowledge
- Module 1: Smart Contracts on EOSIO
- Module 2: Getting Started with Smart Contract Development
- Module 3: Persistence with Multi-Index Tables
- Module 4: Secondary Indices
- Module 5: The ABI
- Module 6: Building Out Tic Tac Toe
- Module 7: Reading and Debugging EOSIO Code
- Module 8: Final Project
Project

Chainshot.com Platform

Chainshot by Alchemy
via Chainshot.com Platform
04.02.2020
Online Educational Course “Introduction to Solidity”
The content of the modules:
- Welcome to ChainShot. An Introduction to Learning with ChainShot
- Getting Started. Tips & Guides for Getting Started on your Journey
- Curriculum & Resources. Learn about the curriculum and discover some useful resources
- Understanding Solidity. Learn the Fundamentals of Solidity
- Solidity at a Glance. A Look at the Solidity Language from a Beginner’s Perspective
- Data Types. Learn the Basic Solidity Data Types
- Functions. Learn the Syntax of Writing Functions in Solidity
- Contract Communication. Learn to Communicate Between Contracts
- Libraries. DRY up your code with Solidity Libraries
- Addresses & Accounts. Learn about the address data type and Solidity execution context
- Contract to Contract. Learn how to communicate between contracts
- Events. Defining and Emitting Contract Events
- Solidity Challenges. Test Your Skills!
- Sum and Average. Can you find the sum and average of the arguments?
Project

Web3.university Platform

Web3.university
via Web3.university Platform
03.02.2020
Online Educational Course “How To Create Your First Smart Contract”
The content of the modules:
- What are Smart Contracts?
- Deploy Your First Smart Contract
- What is Gas and How is it Used?
- Interact With Your Smart Contract
- Structure of a Smart Contract
- Submit Your Smart Contract to Etherscan
- Smart Contract Security Challenges
- Integrate Your Contract With a Frontend
- Additional Resources
Project
Hello World smart contract from the Ethereum Foundation
// Specifies the version of Solidity, using semantic versioning.
// Learn more: https://solidity.readthedocs.io/en/v0.5.10/layout-of-source-files.html#pragma
pragma solidity >=0.7.3;
// Defines a contract named `HelloWorld`.
// A contract is a collection of functions and data (its state). Once deployed, a contract resides at a specific address on the Ethereum blockchain. Learn more: https://solidity.readthedocs.io/en/v0.5.10/structure-of-a-contract.html
contract HelloWorld {
//Emitted when update function is called
//Smart contract events are a way for your contract to communicate that something happened on the blockchain to your app front-end, which can be 'listening' for certain events and take action when they happen.
event UpdatedMessages(string oldStr, string newStr);
// Declares a state variable `message` of type `string`.
// State variables are variables whose values are permanently stored in contract storage. The keyword `public` makes variables accessible from outside a contract and creates a function that other contracts or clients can call to access the value.
string public message;
// Similar to many class-based object-oriented languages, a constructor is a special function that is only executed upon contract creation.
// Constructors are used to initialize the contract's data. Learn more:https://solidity.readthedocs.io/en/v0.5.10/contracts.html#constructors
constructor(string memory initMessage) {
// Accepts a string argument `initMessage` and sets the value into the contract's `message` storage variable).
message = initMessage;
}
// A public function that accepts a string argument and updates the `message` storage variable.
function update(string memory newMessage) public {
string memory oldMsg = message;
message = newMessage;
emit UpdatedMessages(oldMsg, newMessage);
}
}
Learn.microsoft.com Platform

Microsoft
via Learn.microsoft.com Platform
01.02.2020
Online Educational Course “Write Ethereum smart contracts by using Solidity”
The content of the modules:
- Introduction
- What is a smart contract?
- Exercise – Install Truffle
- Exercise – Install the Truffle for VS Code extension
- Exercise – Write a smart contract
- Exercise – Test your smart contract
- Knowledge check
- Summary
Project

Learn.microsoft.com Platform

Microsoft
via Learn.microsoft.com Platform
01.02.2020
Online Educational Course “Learn how to use Solidity”
The content of the modules:
- Introduction
- What is Solidity
- Understand the language basics
- Explore value types
- Explore reference types
- Exercise – Write your first contract
- Knowledge check
- Summary
Project



















