A Reality check of September 12th and beyond. How will the world of Cardano dApps look like?

Cardano has released a new feature that enables the smart contract service over the testnet. Smart contracts are the salient features of today's blockchains where business logics e.g. are allowed to develop into the blockchains. These business logics include financial applications like token swap, bidding etc. Cardano is known to be the most emerging blockchain technology because of its innovative transaction model called Extended Unspent Transaction Output (EUTXO).
Extended Unspent Transaction Output Model
Cardano uses the idea of the UTXO model in bitcoin and then extends it with a new innovation known as EUTXO. In the bitcoin UTXO model, transactions consist of two main parts: inputs and outputs. The transaction’s outputs are locked using the hash of the public key known as address. To spend coins, the spender uses the private key corresponding to that public key hash or address. In the creation of a transaction, the UTXO from the output of a previous transaction is used as an input and then the ownership of coins are transferred to the next spender in the form of a new UTXO as an output. Cardano adopts this model with an extra layer of validation and scripts.
In the UTXO model, transaction outputs are locked by some validation scripts instead of public key hash or address. The scripts contain some arbitrary logics and conditions that decide whether to unlock the UTXO or not. When a Cardano node receives a transaction, it executes scripts to validate that given UTXO fulfills the condition to be used as an input. Second feature of UTXO is that outputs can contain arbitrary data in addition to other values (ADA) and address. Together with all this provided information, scripts can generate the results clearly “yes” or “no” whether a transaction’ input is valid or not.
Moreover, Cardano’ ETUXO model also has some advantages over the accounts based models as used in Ethereum. The submitted transaction can become part of the ledger with a high success rate. This is because transactions are validated by the scripts and arbitrary data fields before the submission. Simply, the transaction can be checked by off-chain processing before being sent to the blockchain. However, transactions can be failed because of the appearance of the same transaction concurrently in the blockchain network. Due to this, Cardano’ UTXO has an edge over the Ethereum’s accounting model where a transaction can fail in the middle of execution of smart contract logic. Moreover, transaction execution cost/ fee can be determined off-chain in Cardano as compared to Ethereum.
Haskell Language
It is a functional language. Following is the basic syntax of the Haskell language.
ghci> let a = “C stands for Cardano”
ghci> print a
ghci> C stands for Cardano”
In the above described basic syntax, “a” is considered as the function. Functional language is different as compared to other languages where “a” will be considered as a variable. Cardano has been developed using Haskell. The codes written in Haskell are compiled by a compiler called Haskell Compilation System (GHC).
Programming languages for Smart Contracts
In Cardano, the following three languages are used to write smart contracts.
  1. 1.
    1. 1.
      Known as a purpose built language to provide full-stack programming support for writing smart contacts.
  2. 2.
    1. 1.
      A domain-specific language (DSL) to develop and execute smart contracts
    2. 2.
      It can be embedded in the javascript and haskell
  3. 3.
    1. 1.
      Also a domain-specific language and its salient feature is to develop secure smart contracts based applications in an adversarial environment.
Plutus is a well known and most leading functional programming language to develop smart contracts for real world applications for the Cardano ecosystems. Therefore, Plutus will be discussed in the next sections.
Plutus Core
It is a scripting language that is used to write smart contracts known as Plutus contracts. Also, it is a large subset of Haskell libraries. Therefore, knowledge of Haskell language is required to learn and write Plutus core for applications. There is familiarity between the Plutus scripting language and the Haskell core language. Scripts written by Plutus core are compiled by the Plutus compiler.
Plutus Playground
It is a web based framework that provides User Interface (UI) to compile, evaluate and simulate the functionality of the smart contract. Also, while developing smart contracts, endpoints are defined by a schema. After compilation and evaluation, endpoints enabled the functionality in the form of buttons in the wallets. Moreover, Plutus playground is a standalone environment that works
Plutus Contract
Cardano smart contracts are developed using the Plutus core language. These smart contracts are known as Plutus smart contracts. There are two main parts of Plutus contracts “on-chain code” and “off-chain code”. Both these codes are written in Haskell language. Precisely, on-chain codes run on the blockchain and whereas off-chain codes run on user’ machine. Moreover, the on-chain code in Plutus contract is compiled by Plutus compiler and the off-chain code in the Plutus contract is compiled by the Haskell compiler.
Following are the important terms that are used in the development of smart contracts (Plutus contracts):
An executable program used to interact with the Cardano ledger.
Script output
This is an UTXO locked by a script.
Validator script
To spend the output in EUTXO model, the validator script verified the conditions that are attached with the “script output”. It also determines the address of the output.
This is the data field given in the script output of the EUTXO model.
This is the valid argument for the validator script. To spend a script output, the redeemer arguments are defined in a new transaction.
Plutus Tx
A compiler that compiles the Haskell code into Plutus core.
Smart Contract Deployment
We have not found any reference documentation or tutorial that leads us to the deployment of smart contract on to the Cardano testnet. “The team is concentrating on building the command line interface (CLI) for writing the "Hello World" design of smart contracts” .
In Cardano release 1.29.0 they announced about smart contracts but yet no information how to write and deploy a on Cardano network. On twitter post they announced about new hardfork that on testnet smart contracts are officially available on 1st September 2021 and on mainnet smart contracts are officially available on 12 September 2021
Neither the announcement, or supported documentation mentioned of how to actually deploy the smart contract into the testnet. The only thing supplied was a chain extended screenshot:
If you look at media, and videos a lot of previews of the smart contracts are done on Plutus Playground, but there is no link between Plutus Playground and actual Cardano testnet or mainnet whatsoever. Cardano has been written in Haskell which is a functional programming language, however the issues come when you are on a look out for talent. Even Charles Hoskinson himself mentioned in the video, that no one wants to learn Haskell.
To finalize the thought, in the latest V1.29.0 release, CLI command that is required for smart contract deployment is not there. Which begs the question how are these contracts will get on the blockchain post September 12th?

Example smart contract

This is a sample "Hello world" smart contract written in Plutus Playground:
Once compiled, the contract output looks like this:
And the issue comes up, that due to lack of connection between Plutus Playground and the testnet, the transaction is not traceable on the testnet:

Another Puzzle Smart Contract preview

-- A game with two players. Player 1 thinks of a secret word
-- and uses its hash, and the game validator script, to lock
-- some funds (the prize) in a pay-to-script transaction output.
-- Player 2 guesses the word by attempting to spend the transaction
-- output. If the guess is correct, the validator script releases the funds.
-- If it isn't, the funds stay locked.
import Control.Monad (void)
import qualified Data.ByteString.Char8 as C
import Language.Plutus.Contract
import qualified Language.PlutusTx as PlutusTx
import Language.PlutusTx.Prelude hiding (pure, (<$>))
import Ledger (Address, Validator, ValidatorCtx, Value, scriptAddress)
import qualified Ledger.Constraints as Constraints
import qualified Ledger.Typed.Scripts as Scripts
import Playground.Contract
import qualified Prelude
newtype HashedString = HashedString ByteString deriving newtype PlutusTx.IsData
PlutusTx.makeLift ''HashedString
newtype ClearString = ClearString ByteString deriving newtype PlutusTx.IsData
PlutusTx.makeLift ''ClearString
type GameSchema =
.\/ Endpoint "lock" LockParams
.\/ Endpoint "guess" GuessParams
data Game
instance Scripts.ScriptType Game where
type instance RedeemerType Game = ClearString
type instance DatumType Game = HashedString
gameInstance :: Scripts.ScriptInstance Game
gameInstance = Scripts.validator @Game
$$(PlutusTx.compile [|| validateGuess ||])
$$(PlutusTx.compile [|| wrap ||]) where
wrap = Scripts.wrapValidator @HashedString @ClearString
-- create a data script for the guessing game by hashing the string
-- and lifting the hash to its on-chain representation
hashString :: String -> HashedString
hashString = HashedString . sha2_256 . C.pack
-- create a redeemer script for the guessing game by lifting the
-- string to its on-chain representation
clearString :: String -> ClearString
clearString = ClearString . C.pack
-- | The validation function (Datum -> Redeemer -> ValidatorCtx -> Bool)
validateGuess :: HashedString -> ClearString -> ValidatorCtx -> Bool
validateGuess (HashedString actual) (ClearString guess') _ = actual == sha2_256 guess'
-- | The validator script of the game.
gameValidator :: Validator
gameValidator = Scripts.validatorScript gameInstance
-- | The address of the game (the hash of its validator script)
gameAddress :: Address
gameAddress = Ledger.scriptAddress gameValidator
-- | Parameters for the "lock" endpoint
data LockParams = LockParams
{ secretWord :: String
, amount :: Value
deriving stock (Prelude.Eq, Prelude.Show, Generic)
deriving anyclass (FromJSON, ToJSON, IotsType, ToSchema, ToArgument)
-- | Parameters for the "guess" endpoint
newtype GuessParams = GuessParams
{ guessWord :: String
deriving stock (Prelude.Eq, Prelude.Show, Generic)
deriving anyclass (FromJSON, ToJSON, IotsType, ToSchema, ToArgument)
-- | The "lock" contract endpoint. See note [Contract endpoints]
lock :: AsContractError e => Contract GameSchema e ()
lock = do
LockParams secret amt <- endpoint @"lock" @LockParams
let tx = Constraints.mustPayToTheScript (hashString secret) amt
void (submitTxConstraints gameInstance tx)
-- | The "guess" contract endpoint. See note [Contract endpoints]
guess :: AsContractError e => Contract GameSchema e ()
guess = do
GuessParams theGuess <- endpoint @"guess" @GuessParams
unspentOutputs <- utxoAt gameAddress
let redeemer = clearString theGuess
tx = collectFromScript unspentOutputs redeemer
void (submitTxConstraintsSpending gameInstance unspentOutputs tx)
game :: AsContractError e => Contract GameSchema e ()
game = lock `select` guess
{- Note [Contract endpoints]
A contract endpoint is a function that uses the wallet API to interact with the
blockchain. We can look at contract endpoints from two different points of view.
1. Contract users
Contract endpoints are the visible interface of the contract. They provide a
UI (HTML form) for entering the parameters of the actions we may take as part
of the contract.
2. Contract authors
As contract authors we define endpoints as functions that return a value of
type 'MockWallet ()'. This type indicates that the function uses the wallet API
to produce and spend transaction outputs on the blockchain.
Endpoints can have any number of parameters: 'lock' has two
parameters, 'guess' has one and 'startGame' has none. For each endpoint we
include a call to 'mkFunction' at the end of the contract definition. This
causes the Haskell compiler to generate a schema for the endpoint. The Plutus
Playground then uses this schema to present an HTML form to the user where the
parameters can be entered.
endpoints :: AsContractError e => Contract GameSchema e ()
endpoints = game
mkSchemaDefinitions ''GameSchema
$(mkKnownCurrencies [])
The code above , there is a word guessing game in which one user enters a word and locks some ADA. So when some other user guesses the right word. Then the amount of ADA sent to the second user as reward, as we all know that Cardano is EUTXO based. That’s why, any transaction is submitted only if the transaction has accurate value otherwise the transaction fails before submission. This is the main difference between UTXO and EUTXO.
Once the simulation is completed:
Failed Transaction:
Successful Transaction:


Cardano is definitely making the right moves towards the right direction, but the reality has to be addressed and that's exactly what we've tried to do in this article. September 12th is a major milestone, but we still have a long way to go before we have live dApps on the blockchain. Especially that the Blockchain itself requires additional development to be able to implement the smart contracts onto the chain.
ADAX team will continue our journey and development, and in addition to our recent how-to guide, we'll be supporting the progress and development of the blockchain and the dApps.
If any questions should come - our development team is always ready to step in and support. Please reach out [email protected]