Build Smart Contracts for Cardano Blockchain

Explore what a blockchain is and how Cardano enables secure, decentralized transactions through a digital ledger, immutability, and consensus, paving the way for smart contracts.

Explore Cardano, a third-generation open-source proof-of-stake blockchain focused on security, scalability, interoperability, and sustainability. Compare with Bitcoin and Ethereum, and learn about its treasury.

Define smart contracts as automated, self-executing agreements on the Cardano blockchain, enabling tasks like sending funds or managing financial contracts, using Marlowe, Haskell, Plutus, and Glow.

Explore what Haskell is and how it powers smart contracts on the Cardano blockchain. Learn functional syntax, practical coding with Marlowe and Plutus, and equation reasoning.

Create your first Haskell function by defining main and set date with day, month, and year arguments; learn argument precedence and the role of the dollar sign.

Explore argument precedence in Cardano smart contracts by examining how function calls, the dollar sign operator, and parentheses determine evaluation order.

Learn how dollar notation and whitespace operators control function application in Haskell, including precedence, left-to-right evaluation, and substituting parentheses with the dollar sign for nested calls.

Explore the dot notation operator in Haskell and learn function composition by applying one function to another's result, using add numbers and sqrt examples, with precedence and identity function.

Build data types in Haskell using the data keyword, define an animal with constructors like dog or cat, and map them to sounds. Explore type inference and a simple tokenizer.

Explore how Haskell implements loops with recursion and higher-order functions. Build a loop via a recursive main in the IO context using getLine and print, enabled by tail recursion optimization.

Learn to build a Haskell function for Cardano smart contracts that takes and returns a tuple of two integers, doubling each value, and prints a tuple of two strings.

Define a custom token data type with string and int constructors in Haskell, derive show, and implement print token to display string or int variants.

Build lists in haskell by defining a list type, using cons to add elements, and an empty base case. Also test a has one only function to detect single-element lists.

Set up and explore multi value data types by designing a coordinate data type from a point and two integers, deriving show for printing, and applying a coordinate function.

Explore implementing a recursive list algorithm in haskell, using cons to build lists and a recursive add values function to sum all elements with an empty-list base case.

Explore using Haskell's built-in list type with square brackets, including empty and non-empty lists, and implement a recursive sum function get some on integers, demonstrating proper base case.

Define a token data type for digits and letters, derive show and equal, and implement a recursive tokenize function that converts a string into digit or alpha tokens using isDigit.

Develop a recursive isIn function to determine if an element exists in a list, using an empty-list base case and equality checks across strings like Mammoth and numbers.

Learn currying in Haskell by building a two-stage isIn function that checks character membership in a list and returns a boolean. See how currying enables partial application of values.

Learn how to build guards in Haskell by mapping characters to an operator data type with add, minus, multiply, and divide, for smart contracts.

Learn to convert a string to a list in Haskell by mapping each digit with digitToInt and recursing until the end of the string, printing 1000 as a list.

Develop a Fibonacci function in Haskell using guards and recursion, cover base cases and otherwise, and discuss performance limits for larger inputs.

Deep dive into Marlow language and its Haskell integration to build safe, readable financial contracts and smart contracts for Cardano and DEFI.

Explore low-code smart contracts with Marlowe on Cardano. Build, simulate, and test via deposit, pay, and timeout logic in Marlowe, Haskell, and the visual editor in the Marlow playground.

Build a simple Marlowe Haskell contract that deposits ADA from me to you, with a slot-based timeout. Test and simulate in the Marlowe playground and observe contract closure.

Design a Cardano blockchain smart contract in Marlowe Haskell that lets the sender select an amount from 1 to 100, deposit that amount to the recipient, with two timeouts.

Explore how to design an escrow contract in Marlow, with buyer and seller choices, an impartial arbitrator, and timeout and deposit mechanics to ensure secure transactions.

Set up an escrow smart contract in the Marlow playground with the Haskell editor, compile and simulate a 100 ADA buyer deposit and inner contract that closes by slot 15.

Construct the inner contract for a Cardano smart contract by aligning buyer and seller choices with nested cases, if statements, timeouts, and close or arbitrate outcomes.

Define the agreement and arbitrate sections in a Cardano smart contract, applying conditional logic for buyer and third party decisions, trigger payments to the seller, and close the contract.

Define and implement buyer, seller, and mediator choices for pay, refund, or both in a Cardano smart contract, with bound values and an action-building helper.

Define and test choice values for buyer and seller in a Cardano escrow contract using Marlo, and simulate deposits, pay and refund decisions via a neutral third party.

Design and overview a pay employees smart contract on Cardano. A single payer deposits funds and distributes amounts to multiple employees, with a main contract and a payment sub contract.

Build a pay employees contract by defining a list of employees and their amounts in Marlow, using a deposit action to allocate funds to each employee.

Build the deposit action for the pay employees contract by summing a list of integers with a profits deposit and distributing the total to each employee using Marlowe on Cardano.

Define and implement a pay contract that transfers payments to employees using a list of token names and amounts, with a two-step payment flow from head to tail.

Set up a pay and employees smart contract on the Cardano blockchain by defining employee and amount arguments, validating list lengths, and executing profits deposit and payments.

Learn to build a token exchange contract on Cardano using Marlow and the Haskell editor, where buyers and sellers deposit, agree or disagree, and swap tokens with refunds if needed.

Set up a token swap contract in the Marlowe playground by creating a generic contract that accepts buyer and seller inputs, reserves amounts, applies a transaction fee, and verifies agreement.

Build actions for a Cardano smart contract by implementing reserve amount and deposit actions, does agree logic for buyer and seller, and preparing the agreement sub-contract for the trade.

Build an agreement contract for Cardano that swaps tokens between buyer and seller using a pay action and timeouts, testing with simulations and refunds when there is no agreement.

Begin building a fundraiser smart contract in Marlowe with the Haskell editor. Set the number of participants and implement an inner contract plus a fundraiser choice for payout or refund.

Create a pay party contract that validates a choice value by id and fundraiser role against participant count. Then pay the selected participant and close the contract.

Create a refund contract that returns funds to all participants if fundraising fails, iterating refunds based on participant count and enforcing a time limit.

Create a fundraiser contract on Cardano by adding participants and deposits, and generate per-participant contracts with a maximum participant limit and timeouts. Compile and simulate to verify deposits and funding.