## **GETTING STARTED**

**Welcome**

Welcome to the developer resources section! Here you will find references to the resources that will help you with developing on Cardano.

**Getting started**

- To get started, head over to the [Developer portal](https://developers.cardano.org/). There, you will find guides and tutorials on how to [install](https://developers.cardano.org/docs/get-started/cardano-node/installing-cardano-node) and run the Cardano node and [create simple transactions](https://developers.cardano.org/docs/get-started/create-simple-transaction).
- Alternatively, explore the [Cardano course](https://cardano-course.gitbook.io/cardano-course) material.


**INTERFACING WITH CARDANO**

There are various ways to interact with the Cardano node:

- Via the official command-line interface (CLI) – [cardano-cli](https://github.com/IntersectMBO/cardano-cli)
- Via a proxy interface like [Ogmios](https://ogmios.dev/) (JSON/WebSocket) or the [submit-api](https://github.com/IntersectMBO/cardano-node/tree/master/cardano-submit-api) (CBOR/HTTP)
- Via an SDK/library such as [cardano-api](https://github.com/IntersectMBO/cardano-api) (Haskell), [Pallas](https://github.com/txpipe/pallas) (Rust), [Yaci](https://github.com/bloxbean/yaci) (Java), or [ouroboros-network-js](https://github.com/StricaHQ/ouroboros-network-js) (JavaScript).

You can also rely on third-party services and managed API query layers such as [Blockfrost](https://blockfrost.io/), [Koios](https://www.koios.rest/), Maestro, or [FreeLoaderz](https://freeloaderz.gitbook.io/freeloaderz-docs/).

For more tools, refer to the most commonly used [builder tools](https://developers.cardano.org/tools) on the developer portal or see this [list of community-built developer tools](https://www.essentialcardano.io/article/a-list-of-community-built-developer-tools-on-cardano).

![](https://i.imgur.com/NPcHZoK.png)

**NATIVE TOKENS**

To start working with native tokens, see:

- [Developer portal native token tutorials](https://developers.cardano.org/docs/native-tokens/)
- [Ledger explanations about native tokens.](https://cardano-ledger.readthedocs.io/en/latest/explanations/index.html)

You can also explore Cardano assets using a variety of [explorer tools](https://docs.cardano.org/about-cardano/new-to-cardano/cardano-tracking-tools#exploring-assets).

**SMART CONTRACTS**

To start working with smart contracts, see:

- [Developer portal smart contract tutorials](https://developers.cardano.org/docs/smart-contracts/)
- [Plutus Core documentation.](https://plutus.readthedocs.io/en/latest/)

There are also many languages you can use to develop smart contracts:

- [Aiken](https://github.com/aiken-lang/aiken) (DSL)
- [Plutarch](https://github.com/Plutonomicon/plutarch-plutus) (Haskell-based eDSL)
- [PlutusTx](https://github.com/IntersectMBO/plutus/tree/master/plutus-tx) (Haskell)
- [Plu-ts](https://github.com/HarmonicLabs/plu-ts) (TypeScript)
- [OpShin](https://github.com/OpShin/opshin) (Python)
- [Scalus](https://github.com/nau/scalus) (Scala)
- [Marlowe](https://github.com/input-output-hk/marlowe-cardano) (DSL). 

**TOOLS**

Explore Cardano's ecosystem:

- [A list of community-built developer tools on Cardano](https://www.essentialcardano.io/article/a-list-of-community-built-developer-tools-on-cardano)
- [Builder tools](https://developers.cardano.org/tools/)
- [Cardano Cube](https://www.cardanocube.com/cardano-ecosystem-interactive-map)
- [CTimelines](https://www.ctimelines.io/)
- [Built on Cardano](https://builtoncardano.com/).

 **GOING FUTHER**

- If you’re beginning your developer journey with Cardano, check out the [Cardano course](https://cardano-course.gitbook.io/cardano-course/) learning material. It includes simple tutorials on how to get started.
- And if you want to know more about blockchain, distributed ledgers, and Cardano, check out the [Cardano Academy video course](https://learn.academy.cardanofoundation.org/landing)!

Keep navigating this section to learn more about native tokens, smart contracts, and scalability solutions on Cardano. You will also find release notes, links to the ecosystem builder tools, and weekly development updates.

GETTING STARTED

INTRODUCTION

## **THE CARDANO NODE VIDEO COURSE**


<p align="right"><small>Instructor: Carlos Lopez de Lara, product owner at <a href="https://iohk.io/" target="_blank" rel="noopener noreferrer">Input Output</a>.</small></p>
<table><thead><tr><th>Video</th><th>Summary</th></tr></thead><tbody><tr><td><a href="https://www.youtube.com/playlist?list=PLNEK_Ejlx3x2ut-Pq-hi0NFVsgKB3EddR" target="_blank" rel="noopener noreferrer">Cardano node course</a></td><td>Introduction to the course.</td></tr><tr><td><a href="https://www.youtube.com/watch?v=csqvbw3F_BU&amp;list=PLNEK_Ejlx3x2ut-Pq-hi0NFVsgKB3EddR&amp;index=1" target="_blank" rel="noopener noreferrer">Building the node with Cabal</a></td><td>Step-by-step demonstration of the whole installation, with prerequisites.</td></tr><tr><td><a href="https://www.youtube.com/watch?v=iREukg3-JSM&amp;list=PLNEK_Ejlx3x2ut-Pq-hi0NFVsgKB3EddR&amp;index=2&amp;pp=iAQB" target="_blank" rel="noopener noreferrer">Building the node with Nix</a></td><td>Another full demonstration, this time using Nix.</td></tr><tr><td><a href="https://www.youtube.com/watch?v=YlUljmlCPYs&amp;list=PLNEK_Ejlx3x2ut-Pq-hi0NFVsgKB3EddR&amp;index=3&amp;pp=iAQB" target="_blank" rel="noopener noreferrer">Running the node</a></td><td>Running the node and connecting to a network.</td></tr><tr><td><a href="https://www.youtube.com/watch?v=8ZYuiRxPAZc&amp;list=PLNEK_Ejlx3x2ut-Pq-hi0NFVsgKB3EddR&amp;index=4&amp;pp=iAQB" target="_blank" rel="noopener noreferrer">Generating keys and addresses</a></td><td>A detailed explanation of generating the different types of keys and addresses used in Cardano.</td></tr><tr><td><a href="https://www.youtube.com/watch?v=rbst_uiGpI4&amp;list=PLNEK_Ejlx3x2ut-Pq-hi0NFVsgKB3EddR&amp;index=5&amp;pp=iAQB" target="_blank" rel="noopener noreferrer">Simple transactions with the build-raw command</a></td><td>Carlos describes the two commands used to build a transaction, and demonstrates the hard way; using the <code>build-raw</code> command.</td></tr><tr><td><a href="https://www.youtube.com/watch?v=AVz_zsDd6wE&amp;list=PLNEK_Ejlx3x2ut-Pq-hi0NFVsgKB3EddR&amp;index=6&amp;pp=iAQB" target="_blank" rel="noopener noreferrer">Simple transaction with the build command</a></td><td>A demonstration of the power and convenience of using the <code>build</code> command.</td></tr><tr><td><a href="https://www.youtube.com/watch?v=m0BmjjNt19w&amp;list=PLNEK_Ejlx3x2ut-Pq-hi0NFVsgKB3EddR&amp;index=7&amp;pp=iAQB" target="_blank" rel="noopener noreferrer">Register stake address and delegate to a stake pool</a></td><td>Carlos explains certificates and demonstrates the process of delegating ada to the stake pool using the Cardano command line interface.</td></tr><tr><td><a href="https://www.youtube.com/watch?v=Czwc4U3B5k8&amp;list=PLNEK_Ejlx3x2ut-Pq-hi0NFVsgKB3EddR&amp;index=8&amp;pp=iAQB" target="_blank" rel="noopener noreferrer">Protocol parameters 1/4</a></td><td>Parameters, one of four. These videos explain what the protocol parameters are, and how they influence the behavior of Cardano.</td></tr><tr><td><a href="https://www.youtube.com/watch?v=Czwc4U3B5k8&amp;list=PLNEK_Ejlx3x2ut-Pq-hi0NFVsgKB3EddR&amp;index=9&amp;pp=iAQB" target="_blank" rel="noopener noreferrer">Protocol parameters 2/4</a></td><td>Parameters, two of four.</td></tr><tr><td><a href="https://www.youtube.com/watch?v=Czwc4U3B5k8&amp;list=PLNEK_Ejlx3x2ut-Pq-hi0NFVsgKB3EddR&amp;index=10&amp;pp=iAQB" target="_blank" rel="noopener noreferrer">Protocol parameters 3/4</a></td><td>Parameters, three of four.</td></tr><tr><td><a href="https://www.youtube.com/watch?v=Czwc4U3B5k8&amp;list=PLNEK_Ejlx3x2ut-Pq-hi0NFVsgKB3EddR&amp;index=11&amp;pp=iAQB" target="_blank" rel="noopener noreferrer">Protocol parameters 4/4</a></td><td>Parameters, four of four.</td></tr><tr><td><a href="https://www.youtube.com/watch?v=7YyCJ3fDN0I&amp;list=PLNEK_Ejlx3x2ut-Pq-hi0NFVsgKB3EddR&amp;index=12&amp;pp=iAQB" target="_blank" rel="noopener noreferrer">Peer-to-peer (P2P) networking</a></td><td>P2P networking; a detailed explanation of Dynamic P2P networking and its advantages.</td></tr><tr><td><a href="https://www.youtube.com/watch?v=hOFVL6gjFrw&amp;list=PLNEK_Ejlx3x2ut-Pq-hi0NFVsgKB3EddR&amp;index=13&amp;pp=iAQB" target="_blank" rel="noopener noreferrer">P2P networking; topology and configuration</a></td><td>P2P networking; how to configure the topology and configuration files for the different types of nodes.</td></tr><tr><td><a href="https://www.youtube.com/watch?v=6AQaPdmxnfo&amp;list=PLNEK_Ejlx3x2ut-Pq-hi0NFVsgKB3EddR&amp;index=14&amp;pp=iAQB" target="_blank" rel="noopener noreferrer">Creating a stake pool. The setup</a></td><td>Creating a stake pool; recommended hardware layout and software configuration.</td></tr><tr><td><a href="https://www.youtube.com/watch?v=xydi4_pqOdo&amp;list=PLNEK_Ejlx3x2ut-Pq-hi0NFVsgKB3EddR&amp;index=15&amp;pp=iAQB" target="_blank" rel="noopener noreferrer">Creating a stake pool. Generating stake pool keys</a></td><td>Creating a stake pool; a detailed demonstration and explanation of generating the required keys and other artifacts.</td></tr><tr><td><a href="https://www.youtube.com/watch?v=9UK_EFG-nkA&amp;list=PLNEK_Ejlx3x2ut-Pq-hi0NFVsgKB3EddR&amp;index=16&amp;pp=iAQB" target="_blank" rel="noopener noreferrer">Creating a stake pool. Registering the stake pool</a></td><td>Creating a stake pool; using the artifacts created earlier to complete the registration.</td></tr><tr><td><a href="https://www.youtube.com/watch?v=1CaMmsgFPnw&amp;list=PLNEK_Ejlx3x2ut-Pq-hi0NFVsgKB3EddR&amp;index=17&amp;pp=iAQB" target="_blank" rel="noopener noreferrer">Creating a stake pool. RTS, topology, and systemd</a></td><td>Creating a stake pool; the Haskell runtime options, and how to extend and override them. Details of the topology files and the startup scripts. Using systemd to restart your node as required.</td></tr><tr><td><a href="https://www.youtube.com/watch?v=t5BOFmy6IYg&amp;list=PLNEK_Ejlx3x2ut-Pq-hi0NFVsgKB3EddR&amp;index=18&amp;pp=iAQB" target="_blank" rel="noopener noreferrer">Stake snapshots</a></td><td>How to request test funds from the faucet. Details of stake distribution snapshots.</td></tr><tr><td><a href="https://www.youtube.com/watch?v=NCdsk75-7NA&amp;list=PLNEK_Ejlx3x2ut-Pq-hi0NFVsgKB3EddR&amp;index=19&amp;pp=iAQB" target="_blank" rel="noopener noreferrer">Stake pool operations. Useful commands 1/2</a></td><td>Stake pool operations; useful commands for managing your stake pool; video one of two.</td></tr><tr><td><a href="https://www.youtube.com/watch?v=NCdsk75-7NA&amp;list=PLNEK_Ejlx3x2ut-Pq-hi0NFVsgKB3EddR&amp;index=20&amp;pp=iAQB" target="_blank" rel="noopener noreferrer">Stake pool operations. Useful commands 2/2</a></td><td>Stake pool operations; useful commands two of two.</td></tr><tr><td><a href="https://www.youtube.com/watch?v=iqAmwhk7djE&amp;list=PLNEK_Ejlx3x2ut-Pq-hi0NFVsgKB3EddR&amp;index=21&amp;pp=iAQB" target="_blank" rel="noopener noreferrer">Monitoring with Prometheus</a></td><td>Stake pool operations; how to install and configure Prometheus to monitor your Cardano node.</td></tr><tr><td><a href="https://www.youtube.com/watch?v=biUHK1UDkAY&amp;list=PLNEK_Ejlx3x2ut-Pq-hi0NFVsgKB3EddR&amp;index=22&amp;pp=iAQB" target="_blank" rel="noopener noreferrer">Cardano governance</a></td><td>Carlos discusses the history and mechanism of implementing Cardano updates.</td></tr><tr><td><a href="https://www.youtube.com/watch?v=2oAonlDUcNY&amp;list=PLNEK_Ejlx3x2ut-Pq-hi0NFVsgKB3EddR&amp;index=23&amp;pp=iAQB" target="_blank" rel="noopener noreferrer">Creating a local cluster</a></td><td>Creating a local cluster; using the <code>create-cardano</code> command.</td></tr><tr><td><a href="https://www.youtube.com/watch?v=8Sp2ljOrXXw&amp;list=PLNEK_Ejlx3x2ut-Pq-hi0NFVsgKB3EddR&amp;index=24&amp;pp=iAQB" target="_blank" rel="noopener noreferrer">Local cluster from Byron to Shelley</a></td><td>Creating a local cluster; moving from genesis to Byron to Shelley.</td></tr><tr><td><a href="https://www.youtube.com/watch?v=0svni-Dy4zM&amp;list=PLNEK_Ejlx3x2ut-Pq-hi0NFVsgKB3EddR&amp;index=25&amp;pp=iAQB" target="_blank" rel="noopener noreferrer">Creating a stake pool on the local cluster</a></td><td>Creating a local cluster; providing funds, keys, and configuration files for a new stake pool.</td></tr><tr><td><a href="https://www.youtube.com/watch?v=LNUzmhdGPbY&amp;list=PLNEK_Ejlx3x2ut-Pq-hi0NFVsgKB3EddR&amp;index=26&amp;pp=iAQB" target="_blank" rel="noopener noreferrer">Bringing the d parameter down</a></td><td>Creating a local cluster; submitting a proposal to bring the decentralization parameter (d) down from 1 to 0.80.</td></tr><tr><td><a href="https://www.youtube.com/watch?v=mFyutul_5mU&amp;list=PLNEK_Ejlx3x2ut-Pq-hi0NFVsgKB3EddR&amp;index=27&amp;pp=iAQB" target="_blank" rel="noopener noreferrer">From Shelley to Alonzo</a></td><td>Creating a local cluster; moving our local cluster from the Shelley era to Alonzo.</td></tr></tbody></table>




**Cardano node tests**

Node tests are CLI-based system and end-to-end tests for the Cardano node. Node tests are open source for Cardano node users running the CLI, SPOs, third-party tool developers, and others to test Cardano functionality from the end-user perspective.

You can access [Cardano node tests documentation here](https://tests.cardano.intersectmbo.org/).



THE CARDANO NODE VIDEO COURSE

## **TRANSACTION TUTORIALS**

A transaction is an event created, signed, and sent by a user to modify the ledger's state. It is commonly used to transfer ada or other tokens from one user to another. Additionally, it can serve various purposes, such as token creation, delegation registration to a stake pool, or interaction with smart contracts, among others. The process to modify the ledger through a transaction is as follows:

- **Creating the transaction**. A transaction includes a set of data that specifies how you intend to modify the ledger. The fundamental components of a transaction include UTXOs, from which the funds are sourced, and destination addresses to which you want to send funds along with the desired amount of tokens. There are various tools available to assist in creating transactions, such as wallets and `cardano-cli`.
 
- **Signing the transaction**. A user who owns the funds to be spent must provide authorization for the transaction through a signature. If the funds are held in a smart contract address, the authorization is carried out by executing the smart contract itself. Various tools are available to assist in signing transactions, including wallets and `cardano-cli`.

- **Submitting the transaction**. For a transaction to be reflected in the ledger, the user must submit it. These transactions are received by stake pools, validated, and then added to the ledger within a block.


Each transaction includes an identifier known as `TxId`, and after completing these three steps, you can view transaction's content in the Cardano Explorer, accessible at https://explorer.cardano.org, for example.

**Transaction tutorials index**

In this section, you will find tutorials on how to create:

- [Minting transactions](https://docs.cardano.org/development-guidelines/transaction-tutorials/minting-transaction/)
- [Staking transactions](https://docs.cardano.org/development-guidelines/transaction-tutorials/stake-transaction/)
- [Withdrawing transactions](https://docs.cardano.org/development-guidelines/transaction-tutorials/withdraw-transaction/)
- [Transactions with funds redelegation](https://docs.cardano.org/development-guidelines/transaction-tutorials/redelegate-transaction/)
- [Transactions for multiple purposes](https://docs.cardano.org/development-guidelines/transaction-tutorials/multiple-purposes/)

**For additional references, see:**

- [Building and signing transactions](https://github.com/input-output-hk/cardano-node-wiki/blob/main/docs/reference/building-and-signing-tx.md)
- [Diagnosing transaction problems and troubleshooting](https://github.com/input-output-hk/cardano-node-wiki/blob/main/docs/reference/diagnosing-transactions.md)
- [Transaction metadata](https://github.com/input-output-hk/cardano-node-wiki/blob/main/docs/reference/tx-metadata.md)
- [Scripts](https://github.com/input-output-hk/cardano-node-wiki/blob/main/docs/reference/simple-scripts.md)
- [Multi-asset support](https://github.com/input-output-hk/cardano-node-wiki/blob/main/docs/reference/native-tokens/01-multi-assets.md)
- [Cardano governance update proposals](https://github.com/input-output-hk/cardano-node-wiki/blob/main/docs/reference/cardano-governance.md)
- [Creating Cardano testnets](https://github.com/input-output-hk/cardano-node-wiki/blob/main/docs/reference/create-cardano.md)

**Plutus scripts**

- [About Plutus scripts](https://github.com/input-output-hk/cardano-node-wiki/blob/main/docs/reference/plutus/babbage-script-example.md) (Plutus V2 examples)
- [Plutus spending script](https://github.com/input-output-hk/cardano-node-wiki/blob/main/docs/reference/plutus/plutus-spending-script-example.md)
- [Babbage certifying script example](https://github.com/input-output-hk/cardano-node-wiki/blob/main/docs/reference/plutus/babbage-certifying-script-example.md)
- [Babbage withdrawing script example](https://github.com/input-output-hk/cardano-node-wiki/blob/main/docs/reference/plutus/babbage-withdrawing-script-example.md)

**Note**: For more information about Plutus, tutorials, and how-to guides go to [Plutus Docs](https://plutus.readthedocs.io/en/latest/).

**Vasil tutorials**

The tutorials below provide explainers of the CIPs introduced with Vasil functionality. Examples include the usage of Plutus v2 scripts:

- [How to use reference inputs](https://github.com/perturbing/vasil-tests/blob/main/reference-inputs-cip-31.md)
- [How to use inline datums](https://github.com/perturbing/vasil-tests/blob/main/inline-datums-cip-32.md)
- [How to reference scripts](https://github.com/perturbing/vasil-tests/blob/main/referencing-scripts-cip-33.md)
- [How to use collateral outputs](https://github.com/perturbing/vasil-tests/blob/main/collateral-output-cip-40.md)

TRANSACTION TUTORIALS

## **MINTING TRANSACTIONS**

The ability to create and manage custom tokens is one of the distinguishing features of the Cardano blockchain. Minting refers to the process of 'producing new tokens, either as part of an initial coin offering (ICO) or ongoing token issuance'. Minting transactions enable users to generate or burn tokens according to predefined rules. This tutorial explores the details of minting transactions on Cardano.

Consider a scenario where Bob wants to give Alice a token, but only Bob has the minting authority for that token. To achieve this, Bob needs to create a script that defines the minting and burning rules. There are two approaches to accomplish this: using Plutus policy scripts or simple multi-signature scripts. In this case, the tutorial suggests using a simple multi-signature script since the rule is straightforward: only Bob can mint the token.

Before you begin, ensure that you have all the necessary components ready. First, you need to generate new keys for the script itself. The process for obtaining script keys is as follows:


```
$ cardano-cli address key-gen \
    --verification-key-file transactions-tutorial-policy/policy.vkey \
    --signing-key-file transactions-tutorial-policy/policy.skey
```

Before creating the script, you need to get the key hash of the new keys:

```
$ cardano-cli address key-hash \
    --payment-verification-key-file transactions-tutorial-policy/policy.vkey
8ebd5f9c84fc25ae4506c7d0b687b2f7e82fe3f891036833e7f25c9b

```

You can now create the script by writing the following code into transactions-tutorial-policy/policy.script:

```
{
    “keyHash”: “8ebd5f9c84fc25ae4506c7d0b687b2f7e82fe3f891036833e7f25c9b”,
    “type”: “sig”
}
```

You can get the PolicyId with the following command:

```
$ cardano-cli transaction policyid \
    --script-file transactions-tutorial-policy/policy.script 
C38b0924e32e677f7787f0a0247b177588ec135db927688d8a63310a
```

It is also helpful to store it in an environment variable:


`export POLICY_ID=C38b0924e32e677f7787f0a0247b177588ec135db927688d8a63310a`

Now, you need to create a token name, which has to be in hexadecimal (54657374546F6B656E):

`export TOKEN_NAME=54657374546F6B656E`

Build the transaction:


```
cardano-cli transaction build \
    --tx-in f947f84f1156995afd695247a8dc8a508fd40d371ce0afb801029769a0104874#0 \
    --mint "1 $(echo $POLICY_ID).$(echo $TOKEN_NAME)" \
    --testnet-magic 1 \
    --change-address $(cat bob.addr) \
    --mint-script-file ../cardano/transactions-tutorial-policy/policy.script \
    --out-file minting.tx \
    --tx-out "$(cat alice.addr)+1047330+1 $(echo $POLICY_ID).$(echo $TOKEN_NAME)"
```

MINTING TRANSACTIONS

## **STAKING TRANSACTIONS**

Staking is a fundamental feature of Cardano, allowing you to earn rewards by delegating ada to stake pools. This tutorial shows how to delegate your ada to a stake pool, withdraw rewards, or stop delegating your ada if you decide to switch to another stake pool.

To delegate ada, first, you need to generate a stake key pair. This involves creating a `stake.vkey` and `stake.skey`, in addition to your regular payment key pair (`payment.vkey` and `payment.skey`), and obtaining a new address called `stake.addr`, similar to your `payment.addr`.

Assuming you already have your `payment.vkey` and `payment.skey`, which you can easily generate using the `cardano-cli address key-gen` command, proceed by creating the `stake.vkey` and `stake.skey`:

```
cardano-cli stake-address key-gen \
    --verification-key-file stake.vkey \
    --signing-key-file stake.skey
```

Now you have your payment key pair and stake key pair. The next step is to build the `payment.addr` and `stake.addr` files:

```
# payment.addr
cardano-cli address build \
    --payment-verification-key-file payment.vkey \
    --stake-verification-key-file stake.vkey \
    --out-file payment.addr
```

Note that the example includes the `--stake-verification-key-file` argument. This command is used to create an address that includes its staking part. Addresses without a staking part are primarily used for sending and receiving ada, as well as interacting with DApps. Some examples may omit this argument, but it's crucial for delegation and participating in the staking process.

```
# stake.addr
cardano-cli stake-address build \
    --stake-verification-key-file stake.vkey \
    --out-file stake.addr
```

This command uses only the stake verification file.

Before proceeding with delegation, it's essential to create two new certificates: a registration certificate and a delegation certificate. These files are required to register the stake key on the blockchain and indicate your intention to delegate ada.

This command generates a certificate, which indicates the intention to register the stake key:

```
# registration.cert
cardano-cli stake-address registration-certificate \
    --stake-verification-key-file stake.vkey \
    --out-file reg.cert
```

Create a delegation certificate:

```
# delegate.cert
cardano-cli stake-address delegation-certificate \
    --stake-verification-key-file stake.vkey \
    --stake-pool-id pool18pn6p9ef58u4ga3wagp44qhzm8f6zncl57g6qgh0pk3yytwz54h \
    --out-file delegation.cert
```

At this stage of the tutorial, you should have already selected a stake pool. The example features ADACT (PoolId: pool18pn6p9ef58u4ga3wagp44qhzm8f6zncl57g6qgh0pk3yytwz54h). You can list all pools using the command `cardano-cli query stake-pools` or visit https://preview.cardanoscan.io/pools to select the pool that best suits your needs. Please note that the example uses the `preview` testnet. If you're using another testnet or mainnet, make sure that the pool ID is on the correct network.

Now that you have the `reg.cert` and `delegation.cert` files, you can proceed to the next step. You need to send a transaction containing the certificates. There are two options: sending them individually or sending them together. The example shows how to send them both at the same time.

Start by querying the funds of `payment.addr`:

```
cardano-cli query utxo --address $(cat payment.addr)
                           TxHash                                 TxIx        Amount
--------------------------------------------------------------------------------------
142c46bb93b9c80140a6302e4a8a360e6f46f55aaf001c825ca790bb23572754     0        10000000000 lovelace + TxOutDatumNone
```


If there are no funds in the address, you can request them from the [faucet](https://docs.cardano.org/cardano-testnet/tools/faucet/). Make sure you select the right testnet.

It's time to build, sign, and submit your transaction.

The command below introduces two new arguments of transaction creation: `--witness-override` and `certificate-file`. The first one specifies that the transaction will require two signatures. Therefore, transaction fees will be higher. `certificate-file` adds your new certificates to the transaction:

```
cardano-cli transaction build \
    --witness-override 2 \
    --tx-in 142c46bb93b9c80140a6302e4a8a360e6f46f55aaf001c825ca790bb23572754#0 \
    --certificate-file reg.cert \
    --certificate-file delegation.cert \
    --change-address $(cat payment.addr) \
    --out-file delegateTx.raw
```

In the signing phase, you need to add two signatures: `payment.skey` and `stake.skey`:

```
cardano-cli transaction sign \
    --tx-body-file delegateTx.raw \
    --signing-key-file payment.skey \
    --signing-key-file stake.skey \
    --out-file delegateTx.signed
	
cardano-cli transaction submit \
    --tx-file delegateTx.signed
Transaction successfully submitted.
```

Once the transaction is submitted and processed, you have successfully delegated your ada. Now, let's take a look at your delegation and rewards:

```
cardano-cli query stake-address-info --address $(cat stake.addr)
[
    {
        "address": "stake_test1uq954t492tmusk2dy9z505g3cz3sfpnh0swsqjmzk47rasqyn8uqp",
        "delegation": "pool18pn6p9ef58u4ga3wagp44qhzm8f6zncl57g6qgh0pk3yytwz54h",
        "rewardAccountBalance": 0
    }
]
```

After a few days, you will receive rewards, and the next part of the tutorial demonstrates how to withdraw them.



STAKING TRANSACTIONS

## **WITHDRAWING TRANSACTIONS**

This part of the tutorial will demonstrate how easy it is to claim rewards using the `cardano-cli`. First, you need to ensure that you already have rewards available in your stake address. Check it with the following command:

```
$ cardano-cli query stake-address-info --address $(cat stake.addr)
[
    {
        "address": "stake_test1uq954t492tmusk2dy9z505g3cz3sfpnh0swsqjmzk47rasqyn8uqp",
        "delegation": "pool18pn6p9ef58u4ga3wagp44qhzm8f6zncl57g6qgh0pk3yytwz54h",
        "rewardAccountBalance": 29385845
    }
]

```

In this case, you have ~29 ada. You also need some of your own ada to pay the fees, so you need to query your payment address:

```
$ cardano-cli query utxo --address $(cat payment.addr)
                           TxHash                                 TxIx        Amount
--------------------------------------------------------------------------------------
afb33e353a9880b7cbd9e5eb2cbffa024d1b3b938ee2c739e53dd187094e8f0d     0        10000000 lovelace + TxOutDatumInline ReferenceTxInsScriptsInlineDatumsInBabbageEra (HashableScriptData "\216y\159\CAN*\255" (ScriptDataConstructor 0 [ScriptDataNumber 42]))
afb33e353a9880b7cbd9e5eb2cbffa024d1b3b938ee2c739e53dd187094e8f0d     1        9987657206 lovelace + TxOutDatumNone

```

Use the second UTXO with TxIx=1. You're ready to create your withdrawal transaction:

```
cardano-cli transaction build \
    --tx-in afb33e353a9880b7cbd9e5eb2cbffa024d1b3b938ee2c739e53dd187094e8f0d#1 \
    --withdrawal $(cat stake.addr)+29385845 \
    --change-address $(cat payment.addr) \
    --out-file withdrawal-tx.raw
```

Note that this transaction will take funds from the stake address, so it will need to be signed with the stake.skey file:

```
cardano-cli transaction sign \
    --tx-file withdrawal-tx.raw \
    --signing-key-file payment.skey \
    --signing-key-file stake.skey \
    --out-file withdrawal-tx.signed

cardano-cli transaction submit --tx-file withdrawal-tx.signed
```

Finally, verify that you have received your rewards in your payment address:

```
$ cardano-cli query utxo --address $(cat payment.addr)
                           TxHash                                 TxIx        Amount
--------------------------------------------------------------------------------------
2b1bfc342c1f5531df4cfa220eac79574142c7263d97885d2ad8588ca1a7e22b     0        10016871698 lovelace + TxOutDatumNone
afb33e353a9880b7cbd9e5eb2cbffa024d1b3b938ee2c739e53dd187094e8f0d     0        10000000 lovelace + TxOutDatumInline ReferenceTxInsScriptsInlineDatumsInBabbageEra (HashableScriptData "\216y\159\CAN*\255" (ScriptDataConstructor 0 [ScriptDataNumber 42]))
```

WITHDRAWING TRANSACTIONS

## **REDELEGATION**

This tutorial will show how to redelegate your stake to another stake pool. There can be multiple reasons to redelegate your stake, but the most common ones are:

- Original stake pool is no longer available
- You've discovered a more convenient option
- You have your own stake pool and you want to delegate your stake to it.

To do that, you need to create a new certificate that you are sending in a transaction, as in the first part of the tutorial:

```
cardano-cli stake-address delegation-certificate \
    --stake-verification-key-file stake.vkey \
    --stake-pool-id pool1vzqtn3mtfvvuy8ghksy34gs9g97tszj5f8mr3sn7asy5vk577ec \
    --out-file new-delegation.cert
```

Now the delegation certificate contains the `--stake-pool-id` of the new stake pool. It means that you're ready to build your transaction, selecting the UTXO from which you will pay the fee:

```
$ cardano-cli query utxo --address $(cat payment.addr)
                           TxHash                                 TxIx        Amount
--------------------------------------------------------------------------------------
2b1bfc342c1f5531df4cfa220eac79574142c7263d97885d2ad8588ca1a7e22b     0        10016871698 lovelace + TxOutDatumNone
afb33e353a9880b7cbd9e5eb2cbffa024d1b3b938ee2c739e53dd187094e8f0d     0        10000000 lovelace + TxOutDatumInline ReferenceTxInsScriptsInlineDatumsInBabbageEra (HashableScriptData "\216y\159\CAN*\255" (ScriptDataConstructor 0 [ScriptDataNumber 42]))
```

Build:

```
cardano-cli transaction build \
    --witness-override 2 \
    --tx-in 2b1bfc342c1f5531df4cfa220eac79574142c7263d97885d2ad8588ca1a7e22b#0 \
    --change-address $(cat payment.addr) \
    --certificate new-delegation.cert \
    --out-file new-delegation.tx

Sign:

cardano-cli transaction sign \
    --tx-file new-delegation.tx \
    --signing-key-file payment.skey \
    --signing-key-file stake.skey \
    --out-file new-delegation.signed

cardano-cli transaction submit --tx-file new-delegation.signed 
```

If you check your stake address details, you'll see that you have delegated your stake to a new stake pool and you have zero rewards for now:

```
$ cardano-cli query stake-address-info --address $(cat stake.addr)
[
    {
        "address": "stake_test1uq954t492tmusk2dy9z505g3cz3sfpnh0swsqjmzk47rasqyn8uqp",
        "delegation": "pool1vzqtn3mtfvvuy8ghksy34gs9g97tszj5f8mr3sn7asy5vk577ec",
        "rewardAccountBalance": 0
    }
]
```

REDELEGATION

## **MULTIPLE PURPOSE**

Cardano allows more complex transactions. So far you've seen various types of transactions: simple script, minting, staking, delegating, etc. But Cardano provides the flexibility to create more complex transactions and mix all the types of transactions needed. For example, adding metadata to minting transactions, or adding a staking component to a simple script transaction. This tutorial shows how to send a transaction with multiple purposes.

In this tutorial, you will learn how to:

- Withdraw funds from a script
- Mint a token
- Withdraw delegated funds
- Set metadata for the transaction

As mentioned in the minting tutorial, one way to mint a token is by creating a script derived from a keyHash. For that, you first need to generate new keys and a `key hash` using the following commands:

```
cardano-cli address key-gen \
    --verification-key-file script.vkey \
    --signing-key-file script.skey

cardano-cli address key-hash --payment-verification-key-file script.vkey
54a318b79a805f4f4cf0562a27302e93ed5b2e657cccdf4f6a8330ef
```

Having the key hash, you can create the script as follows:

```
cat payment.script
{
    "keyHash": "54a318b79a805f4f4cf0562a27302e93ed5b2e657cccdf4f6a8330ef",
    "type": "sig"
}

```

You also need to create the address and the policy ID of the script:

```
cardano-cli address build --payment-script-file payment.script 
addr_test1wzgd97kc864w62ulela5ykw8m64z2nu4wjejacyfp6u7qwqyz9v9m
```

```
cardano-cli transaction policyid --script-file payment.script
90d2fad83eaaed2b9fcffb4259c7deaa254f9574b32ee0890eb9e038
```

**First transaction**

First of all, you need to fund the script address using `payment.addr` funds:

```
cardano-cli query utxo --address $(cat payment.addr)
                           TxHash                                 TxIx        Amount
--------------------------------------------------------------------------------------
12bc01bca615bb4cbe5f36b06d86092ad3c8a10e6a37e09f94a5f006f3aaf230     0        10040283782 lovelace + TxOutDatumNone
```

In this transaction, the example sets a `tx-out-inline-datum` file that only contains the number 42. This is essential since you wouldn't be able to get the funds from the script if it does not have a datum:

```
cardano-cli transaction build --tx-in 12bc01bca615bb4cbe5f36b06d86092ad3c8a10e6a37e09f94a5f006f3aaf230#0 --tx-out $(cat payment.script.addr)+10000000 --change-address $(cat payment.addr) --tx-out-inline-datum-file datum.json --out-file 1st.tx

cat datum.json
{
  "constructor": 0,
    "fields": [{"int": 42}]
}
```

**Second transaction**

In this transaction, you can query the UTXO details:

```
cardano-cli query utxo --address $(cat  payment.script.addr)
                           TxHash                                 TxIx        Amount
--------------------------------------------------------------------------------------
04dfd8feaf87f82c8ec771954179879b22b5f693ed86d78a749111eed2de7879     0        10000000 lovelace + TxOutDatumInline ReferenceTxInsScriptsInlineDatumsInBabbageEra (HashableScriptData "\216y\159\CAN*\255" (ScriptDataConstructor 0 [ScriptDataNumber 42]))

```

```
cardano-cli query utxo --address $(cat  payment.addr)
                           TxHash                                 TxIx        Amount
--------------------------------------------------------------------------------------
04dfd8feaf87f82c8ec771954179879b22b5f693ed86d78a749111eed2de7879     1        10030116301 lovelace + TxOutDatumNone
```

You can also verify that you have available rewards:

```
cardano-cli query stake-address-info --address $(cat stake.addr)
[
    {
        "address": "stake_test1uq954t492tmusk2dy9z505g3cz3sfpnh0swsqjmzk47rasqyn8uqp",
        "delegation": "pool1vzqtn3mtfvvuy8ghksy34gs9g97tszj5f8mr3sn7asy5vk577ec",
        "rewardAccountBalance": 15192167
    }
]

```

Now you can build the transaction with multiple purposes:

```
cardano-cli transaction build \
    --tx-in 04dfd8feaf87f82c8ec771954179879b22b5f693ed86d78a749111eed2de7879#1 \
    --tx-in 04dfd8feaf87f82c8ec771954179879b22b5f693ed86d78a749111eed2de7879#0 \
    --tx-in-script-file payment.script \
    --change-address $(cat payment.addr) \
    --mint "1 $(cat payment.script.policyid).746F6B656E" \
    --mint-script-file payment.script \
    --withdrawal $(cat stake.addr)+15192167 \
    --metadata-json-file metadata.json \
    --out-file 2nd.tx
```

You can see multiple things happening in this transaction:

- There are two UTXOs to be spent
- One is from a script, and the other is from a payment
- You are minting a token and this only can be done by defining the `mint-script-file` - the rules to mint that token
- You are withdrawing funds from the delegation
- Finally, you are setting a metadata file

Finally, you can verify the result of signing and submitting the transaction:

The payment address now has:

- The new token minted
- Funds that were in the script address
- Rewards from delegation

```
cardano-cli query utxo --address $(cat payment.addr)
                           TxHash                                 TxIx        Amount
--------------------------------------------------------------------------------------
c260ebce5868a56ce559f5277e6ca2d47b0eecb5b851b957fcb40a2194f67b29     0        10055118943 lovelace + 1 90d2fad83eaaed2b9fcffb4259c7deaa254f9574b32ee0890eb9e038.746f6b656e + TxOutDatumNone

```

The script address does not have any funds.

```
cardano-cli query utxo --address $(cat payment.script.addr)
                           TxHash                                 TxIx        Amount
--------------------------------------------------------------------------------------

```

We no longer have rewards from delegating:

```
cardano-cli query stake-address-info --address $(cat stake.addr)
[
    {
        "address": "stake_test1uq954t492tmusk2dy9z505g3cz3sfpnh0swsqjmzk47rasqyn8uqp",
        "delegation": "pool1vzqtn3mtfvvuy8ghksy34gs9g97tszj5f8mr3sn7asy5vk577ec",
        "rewardAccountBalance": 0
    }
]
```

And the best part, it was only done in one transaction.

MULTIPLE PURPOSE

NATIVE TOKENS

## **PLUTUS**

**info**

To start developing with Plutus, see:

- [Plutus Core documentation](https://plutus.readthedocs.io/en/latest/index.html)
- [Developer portal Plutus overview](https://developers.cardano.org/docs/smart-contracts/plutus)
- 'Plutus resources' below for more details.

Plutus is the native smart contract language for Cardano. It is a Turing-complete language written in Haskell, and Plutus smart contracts are effectively Haskell programs. By using Plutus, you can be confident in the correct execution of your smart contracts. It draws from modern language research to provide a safe, full-stack programming environment based on Haskell, the leading purely-functional programming language.

**Plutus smart contracts**

Plutus smart contracts consist of parts that run on the blockchain (on-chain code) and parts that run on a user’s machine (off-chain or client code). Off-chain code can be written using the Plutus Application Framework (PAF), and this code is then compiled by the GHC (Glasgow Haskell Compiler), whereas on-chain code is compiled by the Plutus compiler into Plutus Core.

**Accounting model used by Plutus**

Cardano uses the [extended UTXO accounting model (EUTXO)](https://ucarecdn.com/3da33f2f-73ac-4c9b-844b-f215dcce0628/EUTXOhandbook_for_EC.pdf) which extends the unspent (U) transaction (TX) output (O) accounting model (UTXO) (used by Bitcoin). In the UTXO model, a transaction has inputs and outputs, where the **inputs** are unspent outputs from previous transactions. As soon as an **output** is used as input in a transaction, it becomes spent and can never be used again. The output is specified by an address (a public key or public key hash) and a value (consisting of an ada amount and optional, additional native token amounts).

EUTXO extends the UTXO model by allowing output addresses to contain complex logic to decide which transactions can unlock them, and by adding custom data to all outputs. This model offers unique advantages over other accounting models. The success or failure of transaction validation depends only on the transaction itself and its inputs and not on anything else on the blockchain. Consequently, the validity of a transaction can be checked off-chain before the transaction is sent to the blockchain. A transaction can still fail if some other transaction concurrently consumes an input that the transaction is expecting. However, if all inputs are still present, the transaction is guaranteed to succeed.

**Plutus Core**

Plutus Core is the scripting language used by Cardano to implement the EUTXO model. It is a functional language similar to Haskell, and a large subset of Haskell can be used to write Plutus Core scripts. As a smart contract author, you don’t write any Plutus Core; rather, all Plutus Core scripts are generated by a Haskell compiler plugin.

These scripts will be executed by nodes during transaction validation ‘live’ on the chain. They will either lock EUTXOs in the form of validator scripts or as minting policies, which control the minting and burning of native tokens.

In practice, when developing smart contracts, you will write validator scripts in Haskell, which will then be automatically compiled into Plutus Core using a GHC plug-in called Plutus Tx.

**Plutus and native tokens**

Each native token comes with its own minting policy, which determines the conditions under which tokens can be minted and burnt. Users can write minting policies in Haskell and compile them to Plutus Core. During the minting or burning process, the Plutus Core policy script is executed in the context of the minting or burning transaction, and the script will have to approve or forbid the action. This feature further accelerates the growth of non-fungible tokens (NFTs) on Cardano by enabling the creation of much more complex minting policies and allowing the creation of NFTs in a trustless manner.

**Advantages of Plutus**

Plutus provides considerable security advantages. It delivers an easier, more robust way to show that your smart contracts are correct and will not encounter the problems found in previous smart contract language design.

Plutus enables a novel integrated approach to smart contract and distributed application development that is more convenient and safer than previous alternatives. Both the on-chain and off-chain code are based on the same language. You use a uniform code base, which the Plutus toolchain then automatically separates into on-chain and off-chain code and packages for deployment.

Additionally, in contrast to Ethereum, Plutus supports user-defined tokens (both fungible and non-fungible) natively which does not require an accompanying smart contract.

**Plutus developer resources**

**Plutus Core**

Plutus Core is the scripting language embedded in the Cardano ledger. It forms the basis of the Plutus Platform – an application development platform for developing decentralized applications (DApps) on the Cardano blockchain.

Developer resources:

- [Plutus Core GitHub repository](https://github.com/IntersectMBO/plutus): includes the implementation, specification, and mechanized metatheory of Plutus Core as well as Plutus Tx – the compiler from Haskell to Plutus Core.

**Associated links:**

- [Talks](https://github.com/IntersectMBO/plutus#talks)
- [Specifications and design](https://github.com/IntersectMBO/plutus#specifications-and-design)
- [Academic papers](https://github.com/IntersectMBO/plutus#academic-papers)

**Official Haskell language server implementation**

Haskell language server implementation is an implementation of a server for the Language Server Protocol (LSP). A language server talks to a client, who can ask the server to perform various operations, such as reporting errors or providing code completions.

**Developer resources:**

[Haskell language server documentation](https://haskell-language-server.readthedocs.io/en/latest/index.html)

**Haskell course**

Plutus Core is written in Haskell. To use Plutus, it is essential to know the basics of Haskell. To help with the onboarding journey, IOG's education team created the Haskell course for beginners. You can find the repository with explainers, links to lectures, and more below.

- [Haskell course.](https://github.com/input-output-hk/haskell-course#haskell-course)

**Plutus user documentation**

This section includes references to Plutus user documentation such as explanations, tutorials, how-to guides, etc.

**Documentation:**

- [Plutus Core and Plutus Tx user guide](https://plutus.readthedocs.io/en/latest/): introduces the Plutus Core programming language and programming with Plutus Tx. Documentation includes explanations, tutorials, how-to instructions, troubleshooting, and reference information:

- [explanations](https://plutus.readthedocs.io/en/latest/explanations/index.html)
- [tutorials](https://plutus.readthedocs.io/en/latest/tutorials/index.html)
- [how-to guides](https://plutus.readthedocs.io/en/latest/howtos/index.html)
- [troubleshooting](https://plutus.readthedocs.io/en/latest/troubleshooting.html)
- [reference](https://plutus.readthedocs.io/en/latest/reference/index.html)

- [Video presentation on the Plutus Platform](https://www.youtube.com/watch?v=usMPt8KpBeI&feature=youtu.be): in this session from the 2020 Cardano Summit, Michael Peyton-Jones walks us through working with Plutus, while 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.

**Plutus Pioneer Program**

- [Plutus Pioneer Program](https://github.com/input-output-hk/plutus-pioneer-program#readme): includes lectures, examples, and exercises
- [Plutus Pioneer Program notes and documentation](https://plutus-pioneer-program.readthedocs.io/en/latest/)
- ['plutus-pioneer-program' questions on Cardano Stack Exchange](https://cardano.stackexchange.com/questions/tagged/plutus-pioneer-program)
- [Plutus Pioneer Discord](https://discord.com/channels/826816523368005654/826836848520200233)

**Plutus Pioneer community notes:**

- [How to prepare for the Plutus Pioneer Program](https://www.essentialcardano.io/article/how-to-prepare-for-the-plutus-pioneer-program)
- [Essential Resources and Documentation for the Plutus Pioneer Program](https://www.essentialcardano.io/article/essential-resources-and-documentation-for-the-plutus-pioneer-program)
- [Plutus Pioneer Program Part 1: Understanding the eUTXO Model and Coding the first Smart Contract](https://www.essentialcardano.io/article/plutus-pioneer-program-part-1-understanding-the-eutxo-model-and-coding-the-first-smart-contract)
- [Plutus Pioneer Program - Part 2: How to “deploy” a Smart Contract in Cardano](https://www.essentialcardano.io/article/plutus-pioneer-program-part-2-how-to-deploy-a-smart-contract-in-cardano)
- [Plutus Pioneer Program - Part 3: How to Mint and Burn Tokens and NFTs in Cardano](https://www.essentialcardano.io/article/plutus-pioneer-program-part-3-how-to-mint-and-burn-tokens-and-nfts-in-cardano)
- [Plutus Pioneer Program - Part 4: State Machine with Plutus (1/2)](https://www.essentialcardano.io/article/plutus-pioneer-program-part-4-state-machine-with-plutus-12)
- [Plutus Pioneer Program - Part 5: State Machine with Plutus (2/2)](https://www.essentialcardano.io/article/plutus-pioneer-program-part-5-state-machine-with-plutus-22)

**Plutus community resources**

This section provides links to Plutus community resources.

If you are a community member engaged with Plutus development, please raise a pull request to add more relevant links and information.

- [Cardano forum for Plutus discussions](https://forum.cardano.org/c/developers/cardano-plutus/148)
- [Plutus community docs](https://www.essentialcardano.io/article/plutus-community-docs-a-new-documentation-site-for-devs-by-devs) article
- [Plutus community docs](https://plutus-community.readthedocs.io/en/latest/)

**Discussions & support:**

- [IOG Technical Discord](https://discord.com/channels/826816523368005654/897221118111400007)
- [Cardano Stack Exchange](https://cardano.stackexchange.com/)
- [Cardano Forum](https://cardano.stackexchange.com/)

**Plutus tooling**

There are different tools that developers can use to evaluate and deploy smart contracts on Cardano:

- [An extended list of community-built developer tools on Cardano](https://www.essentialcardano.io/article/a-list-of-community-built-developer-tools-on-cardano): includes NFT creation tools, smart contract platforms, software libraries, APIs, interfaces, SDKs, digital product platforms, data services, blockchain integration, automation tools, decentralized protocols, enterprise apps, stake pool tooling, and more.

- **Emurgo**

- [Cardano serialization library](https://github.com/Emurgo/cardano-serialization-lib#readme)

- **Plutonomicon**

- [Plutonomicon - independent community Plutus documentation](https://github.com/Plutonomicon/plutonomicon/blob/main/README.md)
- [Plutonomicon - GitHub repositories](https://github.com/Plutonomicon)
- [Plutonomicon - cardano-transaction-lib](https://github.com/Plutonomicon/cardano-transaction-lib#readme)

- **OpShin**

- [opshin - Pythonic smart contract tooling](https://github.com/OpShin)
- [Smart contract benchmark](https://github.com/OpShin/plutus-bench)
- [Generic smart contract optimization CLI](https://github.com/OpShin/plutonomy-cli)

- **Harmonic**

- [HarmonicPool (Harmonic) - GitHub repositories](https://github.com/HarmonicPool)

- **TxPipe**

- [Aiken](https://github.com/txpipe/aiken)
- [Oura](https://github.com/txpipe/oura)
- [Scrolls](https://github.com/txpipe/scrolls)
- [Pallas](https://github.com/txpipe/pallas#readme)
- [Demeter Run](https://demeter.run/) - a cloud environment with all the tools for building DApps on Cardano

- **dcSpark**

- [Carp](https://github.com/dcSpark/carp/tree/main/docs)
- [Cardano Multiplatform lib](https://github.com/dcSpark/cardano-multiplatform-lib)

- **MLabs**

- [Plutlib](https://github.com/mlabs-haskell/plutip)

- **dQuadrant**

- [Kuber](https://github.com/dQuadrant/kuber#readme)

- **CardanoSolutions**

- [Kupo](https://github.com/CardanoSolutions/kupo#readme)
- [Ogmios](https://github.com/CardanoSolutions/ogmios#readme)

- **Other tools**

- [Blockfrost](https://github.com/blockfrost)
- [Helios](https://github.com/Hyperion-bt/Helios#readme)
- [Koios](https://koios.rest/)
- [Lucid](https://github.com/spacebudz/lucid#readme)

PLUTUS

## **MARLOWE**

**info**

To get started with Marlowe, find the various resources on the [documentation website](https://docs.marlowe.iohk.io/docs/introduction):

- [Tutorials](https://docs.marlowe.iohk.io/tutorials)
- [Concepts](https://docs.marlowe.iohk.io/tutorials/concepts/overview)
- [Guides](https://docs.marlowe.iohk.io/tutorials/guides/overview)
- [Playbooks](https://docs.marlowe.iohk.io/tutorials/playbooks/overview)
- [Videos](https://docs.marlowe.iohk.io/tutorials/videos)
- [Contract gallery](https://docs.marlowe.iohk.io/docs/examples/examples-contract-gallery)
- [Developer tools.](https://docs.marlowe.iohk.io/docs/developer-tools/overview)


Marlowe is a set of open source tools designed to simplify the creation, testing, and deployment of secure smart contracts on the Cardano blockchain. It caters to developers, regardless of their expertise in software development, by offering intuitive solutions to create, utilize, and monetize smart contracts with ease.

Marlowe contracts are unique due to their foundation in peer-reviewed research. Formal proofs, extensive testing, and analysis tools provide strong assurances for the safety of Marlowe contracts.

Supported programming languages in Marlowe include Marlowe itself, Haskell, JavaScript, and TypeScript. Marlowe also includes a Blockly editor for visual programming.

**Marlowe features**

The deployment of Marlowe onto the mainnet includes the following features:

- **Marlowe language**: a domain-specific language (DSL) that includes a web-based platform to build and run smart contracts.
- **Marlowe Playground**: a simulator that allows testing smart contracts before deployment to ensure the code behaves as intended.
- **Marlowe Runtime**: the application backend for managing Marlowe contracts on the Cardano blockchain.
- **Marlowe Runtime APIs**: easy-to-use, higher-level APIs that enable developers to build and deploy enterprise and Web3 DApp solutions.
- **Marlowe CLI**: provides capabilities to work with Marlowe's Plutus validators and run Marlowe contracts manually.
- **Marlowe starter kit**: provides tutorials for developers to learn and run simple Marlowe contracts on the Cardano blockchain.
- **Demeter Run integration**: allows using the starter kit without installing any software.
- **Updated documentation website**: significantly expanded, updated, and integrated into the updated Marlowe website.

MARLOWE

## **AIKEN**

**info**

To get started with Aiken, see:

- [Aiken website](https://aiken-lang.org/)
- [GitHub repository](https://github.com/aiken-lang/aiken)

Aiken is a modern programming language and toolchain for developing smart contracts on the Cardano blockchain. It draws inspiration from various modern languages, like Gleam, Rust, and Elm, renowned for their friendly error messages and an overall excellent developer experience.

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

As a language, Aiken is purely functional with static typing and type inference. This means most of the time, the compiler is smart enough to determine the type of something without requiring user annotation. It also allows the creation of custom types resembling records and enums. Aiken does not include higher-kinded types or type classes because it aims for simplicity.

On-chain scripts are typically small in size and scope compared to other kinds of applications being developed today. Consequently, they do not necessitate as many features as general-purpose languages that must tackle far more complex issues.

Aiken is easier than Plutus to get started with for those who are less familiar with functional languages like Haskell. Similar to Plutus, Aiken scripts are compiled down to the untyped Plutus Core (UPLC).

AIKEN

SMART CONTRACTS

## **HYDRA**

Hydra is a layer 2 scaling solution for Cardano rooted in peer-reviewed research that increases transaction throughput and ensures cost efficiency while maintaining rigorous security.

Hydra Head is the first protocol of the Hydra family of protocols, which embodies the foundation for more advanced deployment scenarios relying on isomorphic, multi-party state channels. Each Hydra Head works as an off-chain mini ledger shared between a small group of participants. Developers can use Hydra Heads to add specialized, complex protocols on top of Cardano.

**Developer documentation**

- [Hydra Head documentation.](https://hydra.family/head-protocol/)

**Further reading**

- [Hydra – Cardano’s solution for ultimate layer 2 scalability](https://iohk.io/en/blog/posts/2021/09/17/hydra-cardano-s-solution-for-ultimate-scalability/) blog post
- [Implementing Hydra Heads: the first step towards the full Hydra vision](https://iohk.io/en/blog/posts/2022/02/03/implementing-hydra-heads-the-first-step-towards-the-full-hydra-vision/) blog post
- [Hydra: Fast Isomorphic State Channels](https://iohk.io/en/research/library/papers/hydra-fast-isomorphic-state-channels/) research paper
- [Interhead Hydra: Two Heads are Better than One](https://iohk.io/en/research/library/papers/interhead-hydra-two-heads-are-better-than-one/) research paper.

HYDRA

## **MITHRIL**

Mithril is a stake-based multi-signature scheme that leverages the existing Cardano network to provide certified snapshots of all or part of the blockchain state. These snapshots can be useful in multiple use cases such as secure voting, data exchange, and synchronization between applications, sidechains, light wallets, etc.

The first application of Mithril allows faster bootstrapping of Cardano nodes. As each node has a full copy of the blockchain and needs to verify each block from the history, it takes a significant amount of time to start a new node from scratch. With Mithril, it is possible to start a node from a predefined state, with the same security guarantees that the chain itself provides, but much faster.

**Developer documentation**

- [Mithril documentation.](https://mithril.network/doc/)

**Further reading**

- [Mithril nears mainnet release](https://iohk.io/en/blog/posts/2023/07/20/mithril-nears-mainnet-release/) blog post
- [Mithril proof of concept is now open-source](https://iohk.io/en/blog/posts/2022/08/29/mithril-proof-of-concept-is-now-open-source/) blog post
- [Mithril: a stronger and lighter blockchain for better efficiency](https://iohk.io/en/blog/posts/2021/10/29/mithril-a-stronger-and-lighter-blockchain-for-better-efficiency/) blog post
- [Mithril: Stake-based Threshold Multisignatures](https://iohk.io/en/research/library/papers/mithril-stake-based-threshold-multisignatures/) research paper.

MITHRIL

SCALABILITY SOLUTIONS

## **RELEASE NOTES**

Here is the latest release information for the Cardano components. Component dependencies and compatibility information can be found in the [compatibility matrix](https://docs.cardano.org/developer-resources/release-notes/comp-matrix). Release notes for specific components are available on each component's release page.

Cardano node configuration details (for mainnet and testnets) are available on the [Cardano environments page](https://book.world.dev.cardano.org/environments.html).


<h2 class="anchor anchorWithStickyNavbar_LWe7" id="latest-cardano-component-releases">Latest Cardano component releases<a href="#latest-cardano-component-releases" class="hash-link" aria-label="Direct link to Latest Cardano component releases" title="Direct link to Latest Cardano component releases">​</a></h2>
<table><thead><tr><th>Name</th><th>Version</th><th>Release date</th></tr></thead><tbody><tr><td><a href="https://github.com/IntersectMBO/cardano-node" target="_blank" rel="noopener noreferrer">Cardano node</a></td><td><a href="https://github.com/IntersectMBO/cardano-node/releases/tag/10.1.4" target="_blank" rel="noopener noreferrer">10.1.4</a></td><td>7 January, 2025</td></tr><tr><td><a href="https://github.com/IntersectMBO/cardano-db-sync" target="_blank" rel="noopener noreferrer">Cardano DB Sync</a></td><td><a href="https://github.com/IntersectMBO/cardano-db-sync/releases/tag/13.6.0.4" target="_blank" rel="noopener noreferrer">13.6.0.4</a></td><td>3 December, 2024</td></tr><tr><td><a href="https://github.com/cardano-foundation/cardano-rosetta" target="_blank" rel="noopener noreferrer">Cardano Rosetta</a></td><td><a href="https://github.com/cardano-foundation/cardano-rosetta/releases/tag/2.4.3" target="_blank" rel="noopener noreferrer">2.4.3</a></td><td>9 January, 2025</td></tr><tr><td><a href="https://github.com/cardano-foundation/cardano-rosetta-java" target="_blank" rel="noopener noreferrer">Cardano Rosetta Java</a></td><td><a href="https://github.com/cardano-foundation/cardano-rosetta-java/releases/tag/1.1.5" target="_blank" rel="noopener noreferrer">1.1.5</a></td><td>9 January, 2025</td></tr><tr><td><a href="https://github.com/cardano-foundation/cardano-graphql" target="_blank" rel="noopener noreferrer">Cardano GraphQL</a></td><td><a href="https://github.com/cardano-foundation/cardano-graphql/releases/tag/8.3.3" target="_blank" rel="noopener noreferrer">8.3.3</a></td><td>9 January, 2024</td></tr><tr><td><a href="https://github.com/IntersectMBO/cardano-addresses" target="_blank" rel="noopener noreferrer">Cardano addresses</a></td><td><a href="https://github.com/IntersectMBO/cardano-addresses/releases/tag/3.12.0" target="_blank" rel="noopener noreferrer">3.12.0</a></td><td>17 August, 2022</td></tr><tr><td><a href="https://github.com/cardano-foundation/cardano-wallet" target="_blank" rel="noopener noreferrer">Cardano wallet</a></td><td><a href="https://github.com/cardano-foundation/cardano-wallet/releases/tag/v2025-01-09" target="_blank" rel="noopener noreferrer">v2025-01-09</a></td><td>9 January, 2025</td></tr><tr><td><a href="https://github.com/IntersectMBO/bech32" target="_blank" rel="noopener noreferrer">Bech32</a></td><td><a href="https://github.com/IntersectMBO/bech32/releases/tag/v1.1.7" target="_blank" rel="noopener noreferrer">1.1.7</a></td><td>20 May, 2024</td></tr></tbody></table></div></article><nav class="pagination-nav docusaurus-mt-lg" aria-label="Docs pages"><a class="pagination-nav__link pagination-nav__link--prev" href="/developer-resources/scalability-solutions/mithril"><svg width="24" height="25" viewBox="0 0 24 25" fill="none" xmlns="http://www.w3.org/2000/svg" class="rotated-arrow"><path d="M16.627 13.42H5.25a.726.726 0 0 1-.535-.215.725.725 0 0 1-.215-.535c0-.213.072-.39.215-.534a.725.725 0 0 1 .535-.216h11.377l-5.17-5.17a.706.706 0 0 1-.22-.521c.002-.2.081-.377.236-.532A.784.784 0 0 1 12 5.472a.7.7 0 0 1 .527.225l6.34 6.34a.827.827 0 0 1 .256.633.828.828 0 0 1-.256.633l-6.34 6.34a.716.716 0 0 1-.514.213.749.749 0 0 1-.54-.213.736.736 0 0 1-.232-.534c0-.202.077-.38.232-.535l5.154-5.154Z" fill="currentColor"></path></svg><div class="pagination-labels-wrapper"><div class="pagination-nav__sublabel">

RELEASE NOTES

COMPATIBILITY MATRIX

Welcome to the developer resources section! Here you will find references to the resources that will help you with developing on Cardano.

Cardano Developer Resources

Course Details

Level

Ratings

Modules

Lessons

Holder $WORK Price

Contact Us

Documentation

Navigation