## **Smart Contracts**

**What are smart contracts?**

Smart contracts are digital agreements defined in code that automate and enforce the terms of a contract without the need for intermediaries, enabling secure and transparent transactions on a blockchain. By leveraging predetermined conditions defined within the smart contract code, the state of a contract can only be updated in a way that follows the rules defined in that contract.

On the Cardano blockchain, the compiled code of smart contracts is stored on, and distributed across, the decentralised network. It is not possible to modify the rules of an existing smart contract, nor is it possible to decompile the stored smart contract code from its compiled state into the original source code.

**Introduction**

As mentioned in the general overview, smart contracts on Cardano work a bit differently from how they do on other blockchains. The key to understanding smart contracts is to first understand the eUTXO model.

Smart contracts are more or less just a piece of code that you write to validate the movement of UTXOs locked in your contract's address. You will lock UTXOs at the address of your script and then the UTXOs can only ever be spent/moved if your script allows the transaction spending it to do so.

**Conceptual overview**

Smart contracts consist of on-chain and off-chain components:

The on-chain component (validator-script) is a script used to validate that each transaction containing any value locked by the script (UTXOs residing on the script's address) conforms to the rules of the contract. Specialised tools and languages are required for creating these scripts.
The off-chain component is a script or application that is used to generate transactions that conform to the rules of the contract. These can be created in almost any language.
Important to note here is that smart contracts heavily rely on the datum attached to a UTXO, using it as part of the contract instance "state" to be used in further transactions. If no datum is attached to a UTXO residing on the contract's address, it can end up being locked there forever.

**On-Chain (Validator scripts)**

Validator scripts are executed automatically when a UTXO residing at the address of the script is attempted to be moved by a transaction. These scripts take a transaction as its input and then outputs either true or false depending on whether the transaction is valid or not according to your rules/logic as defined in the script - thus blocking or allowing a transaction to succeed. If you are moving multiple UTXOs residing on the same script address, the validator-script will run once for each UTXO. This script execution happens on the Cardano node validating your transaction.

This means that in order for the validator-script to execute, a transaction must first move a UTXO to the address of the contract; the address is derived from the contract mathematically. You do not need to upload your contract to the chain, although that is also possible using reference scripts.

You might think of this initial transaction where you move a UTXO to the script address to be the initialisation of a contract instance. Each UTXO residing on the address of the contract can thus be seen as an instance of the contract. Note that there is no restriction on the UTXOs being sent to the script address: anyone can send a UTXO containing no datum, or a 'fake' datum.

**Off-Chain**

The off-chain part is needed in order to locate UTXOs that are locked in your contract and generate transactions that are valid for moving them.

For contracts that require multiple steps to complete, it is common to encode the state of a contract inside of a datum using a specific schema of your own design that is then attached to each transaction. You would then create a 'thread' of UTXOs by designing a validator such that it only allows moving the UTXO to the script address so that the value of the UTXO remains locked in the new UTXO, but with a new datum/state.

**Technical overview**

Smart contracts are really very simple constructs based on validator-scripts which you now know are just some logic/rules created by you to be enforced by the Cardano nodes when they see a transaction attempting to move a UTXO locked inside of your script's address.

Because the validator script has access to read the transaction context (things like who signed it and which assets are being sent to/from where) and datum of the locked UTXO being moved, you can build some very complex contracts this way. For example, Marlowe is a good example of this technique used in practice.

More specifically, the validator scripts are passed these three pieces of information as arguments:

**Datum**: this is a piece of data attached to the output that the script is locking. This is typically used to carry state.

**Redeemer:** this is a piece of data attached to the spending input. This is typically used to provide an input to the script from the spender. For example, your validator can use a function to 'apply' the redeemer contents to the datum and verify that it gets the same result as what the output UTXO datum is set to.

**Context:** this is a piece of data that represents information about the spending transaction. This is used to make assertions about the way the output is being sent (such as “Bob signed it”).

The information contained in the context and thus available for your script to read:

![](https://media.discordapp.net/attachments/980490396356476938/1335697184917815469/image.png?ex=67a11c70&is=679fcaf0&hm=400e1c6233195f827efabdb02740268aa3c33a6beba2a9ac9baf769f693179bf&=&format=webp&quality=lossless&width=758&height=846)

**Basic contract workflow**

**note**

This is only an example! The validator does not need to rely on hashsums - you can have any logic you want here.

You create a validator-script that compares the datum in the UTXO being moved from the contract's address to the hash of the redeemer being used in the transaction moving it. This is your on-chain component.

You create a script, using your language of choice, that creates a transaction moving some amount of ada or other assets to the address of the validator-script. When generating the transaction you specify the datum to be Hash("secret") making sure that only the hashsum of the word "secret" gets stored on-chain. This is your off-chain component.

You sign and submit the transaction to a Cardano node either directly or via one of many available API's such as Blockfrost or Dandelion. Now the ada you sent to the contract is locked by your validator.

The only way for anyone to move this locked ada now is to generate a transaction with the word 'secret' as a redeemer, as the UTXO is locked in the script which will enforce this rule you created where the hashsum of the redeemer must match Hash("secret"). Normally, your datum would be more complicated than this, and the person running the contract might not know how it is supposed to work at all, so they would rely on your off-chain component to create the transaction - often this is something you would provide an API for.

**Multi-step contract workflow**

Expanding on the basic workflow, imagine that you want to create a contract that required multiple steps. Such a contract might be one that requires 3 different people to agree on who should be able to claim the value locked in a contract instance.

Your on-chain component, the validator script, would have to encode logic for allowing two different types of actions: moving the contract forward (step), or moving the UTXO and hence its value to any other address (unlock).

Your off-chain component will need to be able to look at the locked UTXO and decode its datum to see which state the contract is currently in, so that it can correctly generate a transaction for either unlocking the UTXO or driving the contract forward.

**note**

You can also design contracts that never close, but only ever change state, while still allowing funds to be added and withdrawn from the contract.

**Contract instances**

When you have contracts designed to run in multiple steps, the UTXO that represents the current state of a specific instance/invocation of that script is something you need to be able to keep track of.

There is no standard for how to do this as of now, but one way to accomplish this is to be to create a minting-policy that only allows minting of thread token NFTs to the script's address, and then use the NFTs as thread-tokens by having the validator script enforce such NFTs be moved with each transaction.

**Real-world use**

One of the best known examples of real-world use for this type of smart contract on the Cardano blockchain is Marlowe.

For the datum used in transactions validated by the Marlowe validator-script, a custom domain specific language (DSL) was designed to make it easy for end users to create their own financial contracts. The off-chain component takes care of creating transactions that include the contract DSL in the transaction together with the current state, while the validator makes sure that all state transitions are valid according to the custom Marlowe logic.

The redeemer sent as part of the state transition transactions contain the 'input' to script, i.e. it specifies what is being applied to the old state in order to create the new state: the datum in the output transaction. The script can apply the input to the old datum locally and see if the result matches that of the output UTXO being created in the transaction currently being evaluated.

Facilitating the actual use of Marlowe also required creating multiple API's, chain indexers and frontends for interacting with such contracts. Of course not all contracts are as complex, requiring the same amount of infrastructure around them, but it is worth noting that the off-chain components are just as important as the on-chain parts.

**Programming languages**

Cardano introduced smart contracts in 2021 and now supports the development and deployment of smart contracts using multiple different languages.

**tip**

Writing well-designed smart contracts requires you to have a solid understanding of how Cardano works in general. So, make sure that everything on this page makes sense before you start creating contracts. Many topics are described in more detail on the Technical Concepts page as well.

Aiken - for on-chain validator scripts only: a language & toolchain favouring developer experience.

Marlowe - a domain-specific language, it covers the world of financial contracts.
opshin - a programming language for generic Smart Contracts based on Python.

Plutus - a platform to write full applications that interact with the Cardano blockchain.

plu-ts - Typescript-embedded smart contract programming language and a transaction creation library.

Smart Contracts

## **Marlowe**

Get started with Marlowe
Marlowe is a domain-specific language (DSL) that enables users to create blockchain applications that are specifically designed for financial contracts.

If you want to learn Marlowe from the ground up, start with Marlowe Tutorial, or jump right into the Marlowe Playground:

![](https://developers.cardano.org/assets/images/marlowe-playground-ad4f570c50f0d11af5d0095fcb18c65d.jpg)

On the Cardano Forum, you can discuss Marlowe or if you prefer Telegram, there is a special Marlowe Telegram Group.

**The Marlowe platform**

When compared to a Turing-complete language, the Marlowe DSL provides significantly greater security, certainty, guarantees of termination, and behavior correctness.

The design guarantees the following:

Contracts are finite. No recursion or loops.

Contracts will terminate. Timeout on all actions.

Contracts have a defined lifetime.

No assets retained on close.

Conservation of value.

**Marlowe Playground**

The Marlowe Playground is a plug-and-play smart contract builder and simulator that is simple to use, visual, and modular. Build, simulate, and analyze Marlowe contracts in this 4-minute tour of the Marlowe Playground.

<iframe width="560" height="315" src="https://www.youtube.com/embed/EgCqG0hPmwc" title="Creating Marlowe smart contracts using Blockly" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>

Resources for Developing and Deploying Marlowe Contracts
How do I run my Marlowe contract on the Cardano blockchain?
Design your contract using Marlowe Playground.
Press the Send to Simulator button and then press Download as JSON to download your contract in JSON format.

If you want to run your contract at the command line using marlowe-cli, install marlowe-cli and follow the instructions Running Contracts with Marlowe CLI. A video lecture playlist Marlowe CLI provides an overview of the marlowe-cli tool.
If you want to run your contract in a Jupyter notebook, then use git to clone github.com/input-output-hk/marlowe-cardano, run nix develop --command jupyter-lab from the marlowe-cli/ folder, open the notebook Marlowe CLI Lecture 4, and follow the instructions. A video lecture Running a Marlowe Contract with Marlowe CLI demonstrates running a contract from within a Jupyter notebook.
If you want to run your contract from the command-line using the Marlowe Runtime backend, then follow the tutorial for Marlowe Runtime. A video Marlowe Runtime Tutorial demonstrates its use.

If you want to run your contract using Marlowe Lambda, follow the example for using Marlowe Lambda from the command line or study the example web application for Marlowe Lambda. The video Marlowe Lambda in the Browser demonstrate the use of Marlowe Lambda.

**High level technical summary**

Marlowe is implemented for the Cardano blockchain as a validator script that uses the Marlowe DSL in transaction datums for describing the contract states.

The script is implemented in Plutus here and plays a crucial role in validating state transitions for Marlowe contracts. Its purpose is to ensure that transitions caused by transactions comply with both the general rules defined in the Marlowe specification and the current state of the contract, as described in the datum using the Marlowe DSL.

One important rule enforced by the Marlowe validator is that a transaction can only consume a single UTXO and output at most one from the same Marlowe script address. Consequently, a Marlowe contract can be envisioned as a chain of transactions that concludes with a transaction consuming an input from the Marlowe address but producing no output to the same address.

When a transaction consumes the final UTXO of a contract chain without outputting a new UTXO to the same validator address, it indicates the closure of the contract. Such a transaction will contain a redeemer but does not require a datum.

A transaction that consumes the final UTXO and outputs a new one to the same validator address, effectively extending the contract's transaction chain, will also include a redeemer describing the action being applied to the previous state. Additionally, a datum is required to describe the new contract state using the Marlowe DSL. The validator script applies the action to the previous state and returns true (allowing the transaction) only if the transition is permitted by the previous state and results in the provided new state.

Marlowe contracts using the same validator version will utilize the same script address by default. However, it is also possible to derive a staked version of the script address. In this case, only the payment part of the address remains constant for a specific script version. To identify a transaction containing a Marlowe contract, one needs to examine the payment part of the address, which would correlate to a well-known script hash for a validator script version.

**Validator versions**

Currently, there is only a single known implementation of Marlowe available for Cardano: input-output-hk/marlowe-cardano.

The well-known versions of the validator script are specified in the ScriptRegistry.hs file.

Version hashes as of January 20, 2024:

**Marlowe uses two validators**: the semantics validator for the Marlowe DSL and a role-payout validator that allows the holder of a role token to withdraw funds paid by the semantics validator. There is also an optional open-role validator which enables just-in-time assignment of roles to a contract.


**Version	Technical Notes	Hash for Semantics Validator	Hash for Role-Payout Validator	Hash for Open-Role Validator
V5	Optimized using PlutusTx.asData**

	
377325ad84a55ba0282d844dff2d5f0f18c33fd4a28a0a9d73c6f60d	fcb8885eb5e4f9a5cfca3c75e8c7280e482af32dcdf2d13e47d05d27	2722e12a53dfb4fe3742b8a2c0534bd16b0b5ae492a3d76554bbe8a5
v4	Optimized using PlutusTx 1.15	6027a8010c555a4dd6b08882b899f4b3167c6e4524047132202dd984	fdade3b86107bc715037b468574dd8d3f884a0da8c9956086b9a1a51	36a5c7e49a6b11c7fb65fb61db69ed5ceaa35326af9d952fd30185c0
v3	Recompiled with Node 8.1.2 dependencies	d85fa9bc2bdfd97d5ebdbc5e3fc66f7476213c40c21b73b41257f09d	10ec7e02d25f5836b3e1098e0d4d8389e71d7a97a57aa737adc1d1fa	b1d61d0c8a3c0f081a7ccebf0050e3f2c9751e82a4f3953a769dddfb
v2	Changes in response to audit	2ed2631dbb277c84334453c5c437b86325d371f0835a28b910a91a6e	e165610232235bbbbeff5b998b233daae42979dec92a6722d9cda989	
v1	Audited	6a9391d6aa51af28dd876ebb5565b69d1e83e5ac7861506bd29b56b0	49076eab20243dc9462511fb98a9cfb719f86e9692288139b7c91df3	


More resources
Documentation & overview
Official Marlowe documentation
A comprehensive guide to Marlowe's security: audit outcomes, built-in functional restrictions, and ledger security features
GitHub repositories
Marlowe language and semantics
Marlowe Improvement Proposals (MIPs)
Marlowe on Cardano
Marlowe Playground
PureScript implementation of Marlowe
ACTUS in Marlowe
AWS Lambda service for Marlowe Runtime
Developer Discussions
Marlowe on Cardano Forum
#marlowe on Cardano StackExchange
#ask-marlowe on Discord
IOG_Marlowe on Telegram
Discussion of improvements to Marlowe
Discussion of changes to Marlowe's implementation on Cardano
Specifications
Marlowe Specification, Version 3
Marlowe-Cardano Specification
Testing and debugging
The Marlowe Debugging Cookbook
Marlowe Test Report
Tools
Marlowe CLI: a command-line interface for running Marlowe contracts on the Cardano blockchain.
Marlowe Runtime: an application back-end for running Marlowe contracts on the Cardano blockchain.
Marlowe Lambda: an AWS Lambda client for Marlowe Runtime.
Examples
Gallery of Marlowe Contracts on Cardano Mainnet (Real World Marlowe)
Index of example Marlowe contracts and their on-chain execution
Marlowe Debugging Cookbook
Marlowe Runtime Tutorial
Marlowe Runtime examples
Haskell examples of Marlowe contracts
ACTUS contracts in Marlowe
Videos
Marlowe Pioneers 1st Cohort
Welcome
Using Marlowe
Marlowe in Depth
Marlowe Embedded in Haskell and JavaScript

Marlowe and Standardization / ACTUS

[Assurance and Convenience](https://www.youtube.com/playlist?list=PLNEK_Ejlx3x3PArP4vcu4WV0Z5xV0OLhy)

[Marlowe CLI](https://www.youtube.com/playlist?list=PLNEK_Ejlx3x0GbvCw-61e9VfRafBT1JSw)

Using the Marlowe Runtime backend to execute a Marlowe 

[contract on Cardano's preview network](https://www.youtube.com/watch?v=ZmZdgxz2i9A)

[Marlowe Lambda in the Browser](https://www.youtube.com/watch?v=yKhQpIEliBc)

**Presentations**

[Blockchain Essentials](https://www.youtube.com/watch?v=yi8-xaoTQT4)

[Domain-specific languages
](https://www.youtube.com/watch?v=T4W19TdJHMw)

[Financial contracts](https://www.youtube.com/watch?v=1HRaRVyj2BI)

[Onto blockchain](https://www.youtube.com/watch?v=dhcmKmAZslc)

[Escrow onto blockchain](https://www.youtube.com/watch?v=ADMCMDQK7Yo)

[Marlowe in full](https://www.youtube.com/watch?v=Ro8iBh7V7oc)

**Further Tutorials**

[A first contract](https://www.youtube.com/watch?v=es4qpcHxr0I)

[Elaborating the contract](https://www.youtube.com/watch?v=DS_ebkGwmXw)

[Choices and observations](https://www.youtube.com/watch?v=25fnB7C8mPE)

[Writing Marlowe contracts in JavaScript](https://www.youtube.com/watch?v=6tkZ3hlYZ7k)

[Using Haskell in the playground](https://www.youtube.com/watch?v=S0crHs-wTAc)

[Using JavaScript in the playground](https://www.youtube.com/watch?v=Oeuyy5AAQ3o)

[Building Marlowe directly in the playground](https://www.youtube.com/watch?v=9lHkCq0H4pw)

[Building contracts in Blockly](https://www.youtube.com/watch?v=9SKB5MfA_L8)

[Simulation in the playground](https://www.youtube.com/watch?v=3aFoN2wg9oc)

[Oracles in the playground](https://www.youtube.com/watch?v=LsTQEPMxyIU)

[Analysis in the playground](https://www.youtube.com/watch?v=VmoUAifui38)

[ACTUS labs](https://www.youtube.com/watch?v=6PPWFZEfkks)

**Metrics, Adoption, Audit**

[Marlowe Explorer: Scanners for contracts on Mainnet & testnets](https://marlowescan.com/)

[MarloweStat: Statistics for Marlowe contracts on public networks](https://marlowescan.com/)

[[Technical review of Marlowe: Final report (Tweag, 2023-03-24)
](http://data.marlowestat.org/)

](https://github.com/tweag/tweag-audit-reports/blob/main/Marlowe-2023-03.pdf)

[Response to Audit Report for the Marlowe Specification (IOG)](https://github.com/input-output-hk/marlowe/blob/master/response-to-audit-report.md)

Marlowe

## **Plutus**

Get started with Plutus
Plutus is the smart contract platform of the Cardano blockchain. It allows you to write applications that interact with the Cardano blockchain.

Take a look at the Plutus Tutorial if you want to learn Plutus from the beginning or see Plutus resources, where you can find references to all Plutus-related repositories, documentation, and training materials. If you don't know Haskell yet, consider starting with Haskell.

Follow Chris Moreton's content updates. With a high effort he transcribes the lectures of the Plutus Pioneer Program.

Talk to others about Plutus on the Cardano Forum or if you prefer Discord head to the the IOG Technical Discord.

The Plutus platform
In this Video Michael Peyton-Jones starts by walking us through working with Plutus. Plutus allows all programming to be done from a single Haskell library. This lets users build secure applications, forge new assets, and create smart contracts in a predictable, deterministic environment with the highest level of assurance. Furthermore, developers don’t have to run a full Cardano node to test their work.

Jann Müller then takes us through the Plutus Application Platform, where assets can be built and launched. He also demonstrates how tokens can be transferred using a smart contract. With Plutus you can:

Forge new tokens in a lightweight environment

Build smart contracts

Support basic multi-sig scripts


<iframe width="859" height="325" src="https://www.youtube.com/embed/usMPt8KpBeI" title="The Plutus platform" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>


**Further Tutorials**

[Writing a basic Plutus app](https://plutus-apps.readthedocs.io/en/latest/plutus/tutorials/basic-apps.html)

[Using Plutus Tx](https://plutus.readthedocs.io/en/latest/tutorials/plutus-tx.html)

[Writing basic validator scripts](https://plutus.readthedocs.io/en/latest/tutorials/basic-validators.html)

[Writing basic minting policies](https://plutus.readthedocs.io/en/latest/tutorials/basic-minting-policies.html)

[Property-based testing of Plutus contracts](https://plutus-apps.readthedocs.io/en/latest/plutus/tutorials/contract-testing.html)

**How-to guides**

[How to export scripts, datums and redeemers](https://plutus.readthedocs.io/en/latest/howtos/exporting-a-script.html)

[How to write a scalable Plutus app](https://plutus-apps.readthedocs.io/en/latest/plutus/howtos/writing-a-scalable-app.html)

[How to handle blockchain events](https://plutus-apps.readthedocs.io/en/latest/plutus/howtos/handling-blockchain-events.html)

[How to analyse the cost and size of Plutus scripts](https://plutus-apps.readthedocs.io/en/latest/plutus/howtos/analysing-scripts.html)

**Get started with Haskell**

Haskell is the programming language for Plutus contracts. If you are looking for the best guide to Haskell and unsure where to start, we recommend you check out the book or website Learn You a Haskell for Great Good by Miran Lipovača.

Learning Haskell is made easy with this illustrated guide, one of the most engaging ways to learn this fascinating programming language.

Another great learning resource is the online course Haskell and Crypto Mongolia 2020 lectured by Andres Löh, co-founder of the Well-Typed consultancy and Dr. Lars Brünjes, Education Director at IOHK. The course is the suggested starting point for Plutus Pioneers at the beginning of the Plutus Pioneer Program. It's a 10-week, 40 hours/week deep dive into Haskell and Cryptocurrencies.

If you are coming from a Python background, there is an informative project py2hs that explains essential Haskell concepts using Python.

**Get started with the Plutus pioneer program**

The Plutus Pioneer Program was created in order to recruit and train developers in Plutus for the Cardano ecosystem. You can complete this program at your own pace or sign up for an active iteration of the program. By entering the program, you will become part of a group that communicates on Discord and holds live weekly QA sessions. The course teaches you the core principles of how to code in both Haskell and Plutus. It is highly interactive, with weekly videos, exercises, and Q&A sessions and exclusive access to the creators and key experts in the language.

Beside the videos you can also read the book based on the Plutus Pioneer Program. The book is written once an iteration of the Pioneer Program comes to an end. It exists from the 3rd iteration on and can be found in the book/ folder of the Pioneer program github repository.

This course is not for coding beginners. You do not need to be an expert in formal methods, but programming experience and a general aptitude for logical and mathematical thinking are highly advisable. We recommend to get started with Haskell before taking the course. The IOG education team that created the Pioneer program also offers a Haskell course that you can at you own pace.

Prior knowledge of Haskell or functional programming is also recommended, as Plutus is heavily based on Haskell and includes advanced features like Template Haskell, type-level programming, and effect systems.

**Apply for the Plutus Pioneer Program**

**Plutus Project-Based Learning (PPBL)**

Plutus Project-Based Learning is a free course from Gimbalabs that provides a hands-on approach to learning Cardano development. The goal of PPBL is to onboard contributors to real projects.

PPBL is built to complement the Plutus Pioneer Program. Students can complete both courses in any order they choose. Students can prepare for the Plutus Pioneer Program by working through the PPBL course, or they can apply what they have learned in PPP by joining the PPBL course.

PPBL takes a big-picture view of Cardano development so that students can learn to contextualize the role of smart contracts in full-stack Cardano applications. Course embedded projects give students the chance to investigate new design patterns, and to learn about questions at the frontiers of Cardano development.

At weekly Live Coding sessions, students gather to share questions and to build projects together.

The PPBL 2024 Course is currently going live in English, French, Indonesian, Japanese, Spanish, and Vietnamese.

[Get started with the free PPBL 2024 course
](https://www.andamio.io/course/ppbl2024)

**Demeter**

Demeter is a web-based development platform providing a full suite of tools for building Cardano dApps end-to-end. It features starter-kits for a range of different project types including Plutus: Plutus Starter Kit.

Demeter.run provides a free tier of their service where you can get started experimenting with Plutus.

Plutus

## **Aiken**

**Introduction**

Aiken is a new programming language and toolchain for developing smart contracts on the Cardano blockchain. It takes inspiration from many modern languages such as Gleam, Rust, and Elm which are known for friendly error messages and an overall excellent developer experience.

The language is exclusively used for creating the on-chain validator-scripts. You will need to write your off-chain code for generating transactions in another language such as Rust, Haskell, Javascript, Python etc.

**caution
**
Aiken is a still a work in progress and is NOT recommended for use in production.

**Getting started**

Visit the Get started with Aiken to install Aiken from Source or Nix Flakes.

A comprehensive guide for getting started with Aiken can be found on the aiken-lang.org website. For more details about the project you might also want to visit the Aiken git repository.

**Example contract**

This is a basic validator written in Aiken

`use aiken/hash.{Blake2b_224, Hash}
use aiken/list
use aiken/string
use aiken/transaction.{ScriptContext}
use aiken/transaction/credential.{VerificationKey}
 
pub type Datum {
  owner: Hash<Blake2b_224, VerificationKey>,
}
 
pub type Redeemer {
  msg: ByteArray,
}
 
pub fn spend(datum: Datum, redeemer: Redeemer, context: ScriptContext) -> Bool {
  let must_say_hello = string.from_bytearray(redeemer.msg) == "Hello, World!"
 
  let must_be_signed =
    list.has(context.transaction.extra_signatories, datum.owner)
 
  must_say_hello && must_be_signed
}`


**Testing**

Tests can be created directly in Aiken and execute them on-the-fly using the "aiken check" command.

Below is an example of how such tests can be defined

`use aiken/interval.{Finite, Interval, IntervalBound, PositiveInfinity}
 
test must_start_after_succeed_when_lower_bound_is_after() {
  let range: ValidityRange =
    Interval {
      lower_bound: IntervalBound { bound_type: Finite(2), is_inclusive: True },
      upper_bound: IntervalBound { bound_type: PositiveInfinity, is_inclusive: False },
    }
 
  must_start_after(range, 1)
}
 
test must_start_after_suceed_when_lower_bound_is_equal() {
  let range: ValidityRange =
    Interval {
      lower_bound: IntervalBound { bound_type: Finite(2), is_inclusive: True },
      upper_bound: IntervalBound { bound_type: PositiveInfinity, is_inclusive: False },
    }
 
  must_start_after(range, 2)
}
 
test must_start_after_fail_when_lower_bound_is_after() {
  let range: ValidityRange =
    Interval {
      lower_bound: IntervalBound { bound_type: Finite(2), is_inclusive: True },
      upper_bound: IntervalBound { bound_type: PositiveInfinity, is_inclusive: False },
    }
 
  !must_start_after(range, 3)
}`

Links

[Aiken User-Manual](url)

Aiken Github Repository.


Aiken

## **Opshin**

**Introduction**

opshin is a programming language for developing smart contracts on the Cardano blockchain. Its syntax is 100% valid Python code and it ensures that contracts evaluate on-chain exactly as their Python counterpart. This allows unit tests and verification of the Python code using standard tooling available for Python development. Existing IDEs, linters and language servers may be re-used as well. Note that the type system of opshin is much stricter than the type system of Python, so that many optimizations can be implemented and an elevated level of security is provided.

The language interacts closely with the python library PyCardano. The internal data structures are defined with data types compatible to the library and allow a tight combination of off- and on-chain code, all written in Python.

**caution**

opshin is a still a work in progress and is NOT recommended for use in production.

**Getting started**

A complete example on a small written contract and off-chain code to deploy it on-chain can be found in the opshin-starter-kit repository. It contains code that will compile the contract and deploy it to the preview testnet, runnable in demeter.run, in your browser.

**Example contract**

This is a basic validator written in opshin:

`from opshin.prelude import *


@dataclass()
class WithdrawDatum(PlutusData):
    pubkeyhash: bytes


def validator(datum: WithdrawDatum, redeemer: None, context: ScriptContext) -> None:
    sig_present = False
    for s in context.tx_info.signatories:
        if datum.pubkeyhash == s:
            sig_present = True
    assert sig_present, "Required signature missing"`


It checks the presence of a specific signature in the transaction to approve spending funds. We can compile the contract like this

$ python3 -m pip install opshin
$ opshin build contract.py

The result is a directory filled with the contract address, policy ID and data that will be used by off-chain libraries to interact with the contract.

Links
opshin Github Repository.
opshin pioneer program
opshin starter kit
PyCardano Smart Contract documentation.
Edit this page


Opshin

## **plu-ts**

**Introduction**

plu-ts is a Typescript-embedded programming language and library for developing smart contracts on the Cardano blockchain. It is designed for smart contract efficiency while staying as close as possible to the Typescript syntax.

The tool is composed by the eDSL that allows you to create smart contracts and compile them; and an off-chain library that introduces all the types required to interact with the Cardano ledger and create transactions.

**Getting started**

Visit the Get started with plu-ts to install plu-ts using npm and set up your project.

You can find the documentation for plu-ts at pluts.harmoniclabs.tech.

If you need help feel free to open issues at the plu-ts git repository.

**Example contract**

some example projects can be found in the plu-ts documentation;

here we report the Hello plu-ts contract; to see how it works you can follow the example project.

`import { bool, compile, makeValidator, PaymentCredentials, pBool, pfn, Script, ScriptType, PScriptContext, bs, PPubKeyHash } from "@harmoniclabs/plu-ts";

const contract = pfn([
    PPubKeyHash.type,
    bs,
    PScriptContext.type
],  bool)
(( owner, message, ctx ) => {

    const isBeingPolite = message.eq("Hello plu-ts");

    const signedByOwner = ctx.tx.signatories.some( owner.eqTerm );

    return isBeingPolite.and( signedByOwner );
});

// all validators must be untyped once on-chain
export const untypedValidator = makeValidator( contract );

// here we get the raw bytes of the contract
export const compiledContract = compile( untypedValidator );

// the `script` object can be used offchain
export const script = new Script(
    ScriptType.PlutusV2,
    compiledContract
);`



Plu-ts

Smart contracts are digital agreements defined in code that automate and enforce the terms of a contract without the need for intermediaries, enabling secure and transparent transactions on a blockchain.

Create Smart Contracts

Course Details

Level

Ratings

Modules

Lessons

Holder $WORK Price

Contact Us

Documentation

Navigation