Introduction to

Smart Contracts

Slides and code partially from

Jason Weathersby, Algorand

With Examples on Algorand

Fabrice Benhamouda

Agenda

• General overview of smart contracts
• Deep dive in Algorand smart contracts:
• Overview: storage and application call transactions
• Send tokens out: escrow / inner transactions
• Receive tokens: transaction groups / atomic transfer
• Case study: crowdfunding
• Deep dive on runtime architecture and TEAL/PyTeal (programming language)
• Fees, min balance, cost, and other constraints
• Quick comparison with Ethereum
• Wallets for dApps and Demo of a real-world DApp
• Advanced topics on Algorand

2

General Overview

of Smart Contracts

What is a Smart Contract

4

Smart Contract

In Development

Smart Contract

Blockchain State

Algorand

Blockchain

Deploy

• Small Program that lives on the chain
• Can interact with data on chain

Smart Contract

Smart Contract

Example of Use of Smart Contracts

• DeFi Apps (decentralized finance)
• Exchange / Automated Market Maker
• Lending
• …
• Crowdfunding
• Voting
• Decentralized name services
• Lottery*
• …

5

What a Smart Contract Can Do?

• ✅ Read & write data/state on the blockchain
• E.g., votes, ownership of an asset, properties of an asset, DeFi exchange rate, …
• ✅ Receive tokens from other accounts
• E.g., receive tokens for a crowdfunding campaign
• ✅ Send tokens it owns to another accounts
• E.g., send the tokens to the project owner if the campaign is successful
• ✅ Interact with other smart contracts
• Reading data (e.g., result of a vote, on-chain price, oracle) or taking actions (e.g., voting, exchange of tokens)

6

What a Smart Contract Cannot Directly Do?

• ⛔ Interact directly with the outside world (and other blockchains)
• ⛔ Directly access a website, weather, price EUR/USD, …
• ⛔ Insurance smart contract that automatically reimburses customers after storm
• Where does the info about storm/damage come from?
• ✅ but: may be useful for transparency
• ✅ but: oracles and bridges allow some interactions but require new components & trust

​

7

​

​

Smart Contract

​

​

Smart Contract

What a Smart Contract Cannot Directly Do?

• ⛔ Work on any secret information
• Everything a smart contract does is PUBLIC
• ⛔ Smart contract to store medical data
• ✅ but: secrets on the blockchain may later provide such a solution
• ✅ but: combined with zkSNARKs can provide transaction privacy

​

• ⛔ Internal direct access to randomness
• Smart contracts are deterministic
• ✅ but: randomness oracles exist

​

8

Smart Contract

How to Interact with Smart Contracts?

9

Application Transaction

Deployment and Interaction

​

⇓

​

Transactions

Smart Contract

Blockchain State

Algorand

Blockchain

Smart Contract

Smart Contract

Algorand Smart Contracts

Overview: storage and transaction types

Accounts & Smart Contracts

• Accounts (sometimes called “wallets”)
• Basic accounts defined by signature public key
• Hold token balances
• Hold “local state” of smart contracts
• Issue transactions: (for basic accounts, using secret key)
• Transfer tokens
• Only way tokens can leave the account
• Call/deploy/update/delete/… smart contracts

11

Account address

=public key for basic accounts

​

PU3KOXQX5OGSUHEBWQTSVI47QZJSRX5RY3IJI3RNFDWCX5LJKBP5L43XAQ

Smart Contract

​

Application ID

=

68633014

• Smart Contracts = Applications
• Program living on chain
• Accounts can send transactions to deploy/call/update/delete/… apps

≠

(on Algorand)

= 25-word mnemonic:�

attract tourist harbor warfare employ harbor unfair code coach nest zero tool game blur heavy stock novel giggle quiz grunt note endless day abandon cage

Account

12

Address of the account

Transaction of the account

Balances of the account

Application call transaction

Transfer of asset USDC

Transfer of Algos

https://testnet.algoexplorer.io/address/WEXUURW6DLWY6TURZYKDUKY2B67OPJX7SFMQ2LHBF5BPS2LVLJ4IPNABL4

Application

13

Application ID

https://testnet.algoexplorer.io/application/68633014

Don’t Get Confused

• Stateless Smart Contracts
• Contract accounts
• Smart signatures
• Delegated Logic Signature

14

≠

At the end of the presentation only

Smart Contract

=

Application

Full Blockchain vs State

• Full blockchain:
• List of all blocks
• Each block contains transactions
• Very large:
• Algorand Feb 2022 > 900GB (https://howbigisalgorand.com)
• Ethereum Feb 2022 > 9TB (https://etherscan.io/chartsync/chainarchive)

15

State of the blockchain

​

can computed

​

from all the transactions

…

Transactions

Transaction 1

Transaction 2

Transaction 3

…

• State of the Blockchain:
• Database stored in each node
• Much smaller than full ledger
• Accounts ➤
• Balance of tokens
• Consensus keys
• …
• Applications ➤ state

Effect of a Transaction

16

Alice sends

2 Algos to Bob

State

Full Blockchain

Alice

NX2J4…

Bob

GVD7Z…

2 Algos

Before

After

(ignoring transaction fees and many more details)

State size = the same*

Blockchain size increased

​

*some operations increase the state size

Global State

Application can store data in

• Global State:
• Up to 64 key ➤ value pairs
• (“key + value” at most 128 bytes)
• ✅ Example of key ➤ value pair:
• “tally_vote_yes” ➤ 120
• “tally_vote_no” ➤ 250
• “admin” ➤ C6G2TUQWZ7VIDVY5UUKBTNT4L7EY4V3NTABCZAEBSGSRD62QDWIQL76IXY

17

State

• ⛔ Impossible to store in global state:
• The list of all voters
• The list of all the votes

Local and Global State

Application can store data in

• Global State:
• Up to 64 key ➤ value pairs
• ✅ Examples:
• “tally_vote_yes” ➤ 120
• “tally_vote_no” ➤ 250
• Local State:
• Per account that “opts-in” �to the application �(special transaction)
• Up to 16 key ➤ value pairs
• ✅ Examples:
• “registered_voter” ➤ 1
• “vote” ➤ yes

18

Everything stored on chain in the state.

State

Local and Global State: Access Restrictions

19

Even with secret key of U,

it is impossible to change the local storage of A for U,

without making an application call to A

Some More Details

20

Application Transaction

Smart Contract

TEAL

​

Global State

​

​

Local State Account 1

​

Approval Program

Clear Program

TEAL

Generated, signed, sent using SDK

(Python, JS, Go, Java, …)

​

(Uses an algod endpoint)

Written in TEAL

Or generated by a PyTEAL

script (written in Python)

​

(No SDK, no algod endpoint)

Transaction Sub-Types for Application

21

Smart Contract

NoOp

TEAL

​

TEAL

​

Approval Program

Clear Program

OptIn

DeleteApplication

UpdateApplication

CloseOut

Clear

Used to Communicate With Smart Contract

Graceful clear

local storage

Force clear

local storage

Allocate

local storage

Default call

+ creation if AppID=0

Algorand Smart Contracts

Inner transactions / smart contracts as escrow

Application Account = Smart Contract Escrow

23

Application

Account

deploy/create

ASA

Smart Contract

control

transfer

creator

call

transaction

user/account

App ID

E.g, 68633014

Algorand Address

E.g, C6G2TUQWZ7VID…

Sending Tokens out of the Application Account

24

​

Application Transaction

​

Global State

​

​

Local State User 1

​

​

Local State User 1

​

​

Local State User 1

​

​

Local State User 1

​

Inner Transaction

Application

Account

​

Smart Contract

• Normal account�⇒ transactions signed by secret key
• Application account�⇒ transactions issued by smart contract as inner transaction

Summary of Smart Contracts / Applications

• ✅ Read & write data/state on the blockchain
• 👍 Using global and local state
• Can also read balances of accounts
• ✅ Receive tokens from other accounts
• 👍 In their application account
• ✅ Send tokens it owns to another accounts
• 👍 Via inner transactions from their application account
• ✅ Interact with other smart contracts
• 👍 (v6) Via inner transactions application calls from their application account

25

How does the smart

contract knows it

received the tokens?

Algorand Smart Contracts

Understanding ASA, Group Transactions / Atomic Transfer

Algorand Standard

Assets ASA

• Algo = native token
• ASA = custom token
• Anyone can create their own ASA
• Same fee as Algos txs
• Example: loyalty program, stable coin USDC
• Equivalent on Ethereum:
• ERC-20, ERC-721, ERC-1155
• ASA pros: lower tx fees and no smart contracts

27

Create your token in one click on https://algodesk.io !

Atomic Transfers / Group Transactions

28

Alice

Bob

Atomic transfer:

​

Either all transactions succeed

Or all transactions fail

​

(work for up to 16 transactions)

ASA

1 Algo

20 USDC

Any transaction can be part of atomic transfer

​

Can include up to 16 transactions

Allow a Smart Contract to Receive Tokens

29

Alice

1 Algo

Application call

Application

Account

​

Smart Contract

Smart contract can inspect

the transactions in their atomic group.

​

(Note: smart contracts can only act when triggered by an application call transaction and cannot inspect transactions outside of their own group.)

Algorand Smart Contracts

Case Study: Crowdfunding

Crowdfunding

• Like https://www.kickstarter.com but decentralized
• A creator proposes a project with:
• A fund goal to reach
• An end date for funding
• Donators can then fund the project
• At the end:
• If fund goal achieved: all the funds go to the creator = received address
• If fund goal not achieved: users are reimbursed

31

Crowdfunding — Creation and Funding

32

Global State

​

Fund Start Date

Fund End Date

Fund Goal�Current Funding Received

Receiver Address

​

App transaction create

Sets dates, Fund goal, fund receiver and creator

​

Payment Tx

From Donator to Smart Contract Escrow

​

App transaction optin

before Fund end date

​

Atomic group

Local State

of each User

​

Giving Amount

1

2

Application

Account

Smart Contract

Crowdfunding — Payout / Reimbursement (after fund end)

33

Global State

​

Fund Start Date

Fund End Date

Fund Goal�Current Funding Received

Receiver Address

App transaction noop

​

Pay the project

if fund goal reached

​

App transaction noop

​

Reimburse user funds

if fund goal not reached

​

Local State

of each User

​

Giving Amount

3

4

Application

Account

Smart Contract

Payouts and reimbursements

made via Inner Transactions from

Application Accounts

If Current Funding Received >= Fund Goal

If Current Funding Received < Fund Goal

(transaction to be sent by each user)

Algorand Smart Contracts

Runtime Architecture and TEAL

Smart Contract Runtime Architecture

35

Application Array

Arguments Array

Per Transaction

Transaction Submission

Accounts Array

Assets Array

TEAL — Transaction Execution Approval Language

• Stack-based language
• Turing Complete (if memory was infinite)
• Looping and Subroutines
• Return True (=1) or False (=0) (accept/reject)
• Two types: uint64 / byte arrays []byte
• Support for 512-bit integers as []byte
• PyTEAL library to write in python

36

hello

Stack

Push

= add on top

Pop

= remove the top

Simple Stack Example

37

https://developer.algorand.org/docs/get-details/dapps/avm/teal/opcodes/#_7

TEAL Basic Opcodes for State

38

Opcode Reference

Document

…

State

TEAL Scratch Space

256 position of scratch space to store temporary values

39

Opcode Reference Document

State Demo

40

https://github.com/fabrice102/smart-contracts/tree/fabrice/upenn/devrel/fabrice-upenn

Every time called, increment a global counter

41

42

TEAL: Jumps and Loops

43

// loop 1 - 10

// init loop var

int 0

loop:

int 1

+

​

// implement loop code

// …

​

// check upper bound

int 10

<=

bnz loop

TEAL Opcodes and Pseudo-Opcodes (advanced)

• Opcodes:
• Converted directly to machine code or bytecode
• Examples: >=, +, *, …
• Reference document

​

• Pseudo-Opcodes:
• Converted to simpler opcodes
• Examples: int, byte, addr, …
• Reference document

44

>=

0x10

0x8105

pushint 5

int 5

intcblock 5

…

intc_0

0x200105…22

or

PyTeal — Python Library

45

def app():

handle_noop = Seq(

Assert(Txn.application_args[0] == Bytes("payme")),

InnerTxnBuilder.Begin(),

InnerTxnBuilder.SetFields({

TxnField.type_enum: TxnType.Payment,

TxnField.amount: Int(5000),

TxnField.receiver: Txn.sender()

}),

InnerTxnBuilder.Submit(),

Int(1)

)

​

return Cond(

[Txn.application_id() == Int(0), Approve()],

[Txn.on_completion() == OnComplete.NoOp, Return(handle_noop)]

)

​

​

if __name__ == '__main__':

print(compileTeal(app(), mode=Mode.Application, version=5))

​

#pragma version 5

txn ApplicationID

int 0

==

bnz main_l4

txn OnCompletion

int NoOp

==

bnz main_l3

err

main_l3:

txna ApplicationArgs 0

byte "payme"

==

assert

itxn_begin

int pay

itxn_field TypeEnum

int 5000

itxn_field Amount

txn Sender

itxn_field Receiver

itxn_submit

int 1

return

main_l4:

int 1

return

outputs

PyTeal Documentation

46

Documentation

TEAL: Transaction Properties and Global Variables

• global/Global: access to global parameters and group information
• Example: size of the group, timestamp of latest block, …

​

• txn/Txn: access to its own transaction fields
• Example: Check Application Call subtype (txn OnCompletion / Txn.on_completion())

​

• gtxn/Gtxn: access to transaction fields of another transaction in the group
• Example: Check first transaction is a payment to the application account

47

Checking Type of Transaction

48

gtxn 0 TypeEnum

int pay

==

TEAL Program

Gtxn[0].type_enum() == TxnType.Payment

PyTEAL Program

Transaction 0 in the group

is a payment transaction

Application Transaction Sub-Types

49

txn OnCompletion

int NoOp

==

TEAL Program

Txn.on_completion() == OnComplete.NoOp

PyTEAL Program

Current application call is NoOp

Global Variables

50

50

global LatestTimestamp

int 1643691600

>=

TEAL Program

Global.latest_timestamp() >=

Int(1643691600)

PyTEAL Program

Previous round was after*

02/01/2022, 00:00 EST

Timestamp = 1643691600

* LatestTimestamp is best effort and may not be 100% accurate

TEAL: Checking Payment to Application Account

51

Payment of 2 Algos to

Application Account

Atomic

Application Call

**It is recommended not to enforce the atomic group size (as done in this simplified example) as it prevents “composition”. Instead look at previous transaction.

Seq([

Assert(Global.group_size() == Int(2)),

Assert(Gtxn[0].type_enum() == TxnType.Payment),

Assert(Gtxn[0].amount() == Int(2000000)),

Assert(Gtxn[0].receiver() == Global.current_application_address()),

…

])

PyTEAL Program

global GroupSize

int 2

==

assert

​

gtxn 0 TypeEnum

int pay

==

assert

TEAL Program

gtxn 0 Amount

int 2000000

==

assert

​

gtxn 0 Receiver

global CurrentApplicationAddress

==

assert

TEAL: Inner Transactions

• Up to 16 inner transactions
• From the application account
• Shows up as inner transactions within application transaction
• Recipient must be in the accounts array

• Example: payment of 1.42 Algos to the application called

52

52

Seq([

InnerTxnBuilder.Begin(),

InnerTxnBuilder.SetFields({

TxnField.type_enum: TxnType.Payment,

TxnField.amount: Int(1420000),

TxnField.receiver: Txn.sender(),

}),

InnerTxnBuilder.Submit(),

…

])

PyTEAL Program

itxn_begin

int pay

itxn_field TypeEnum

int 1420000

itxn_field Amount

txn Sender

itxn_field Receiver

itxn_submit

TEAL Program

TEAL: Subroutines

• Internal functions

​

• Use:
• Reduce code size
• Improve code quality

​

• Not visible from the outside
• An application call cannot call �a subroutine directly

53

@Subroutine(TealType.uint64)

def isEvenSubRoutine(i):

return i % Int(2) == Int(0)

�Seq([

Assert(isEvenSubRoutine(Gtxn[0].amount())),

Assert(isEvenSubRoutine(Gtxn[1].amount())),

…

]

PyTEAL Program

gtxn 0 Amount

callsub sub0

assert

gtxn 1 Amount

callsub sub0

assert

…

…

TEAL Program

sub0: // isEvenSubRoutine

store 0

load 0

int 2

%

int 0

==

retsub

54

54

@Subroutine(TealType.uint64)

def isEvenSubRoutine(i):

return i % Int(2) == Int(0)

�Seq([

Assert(isEvenSubRoutine(Gtxn[0].amount())),

Assert(isEvenSubRoutine(Gtxn[1].amount())),

…

]

PyTEAL Program

gtxn 0 Amount

callsub sub0

assert

gtxn 1 Amount

callsub sub0

assert

…

…

TEAL Program

sub0: // isEvenSubRoutine

store 0

load 0

int 2

%

int 0

==

retsub

​

def isEvenPyFunc(i):

return i % Int(2) == Int(0)

�Seq([

Assert(isEvenPyFunc(Gtxn[0].amount())),

Assert(isEvenPyFunc(Gtxn[1].amount())),

…

]

PyTEAL Program

gtxn 0 Amount

int 2

%

int 0

==

assert

�

TEAL Program

gtxn 1 Amount

int 2

%

int 0

==

assert

​

…

Normal Python Function

Subroutine

The code is copy-pasted

for every invocation

TEAL: Application Arguments and “Methods”

• Examples of methods:
• Voting: register, vote. Crowdfunding: fund, withdraw, reimburse
• CANNOT use subroutines
• Use the “Application Arguments” array in the transaction call
• Access as txna ApplicationArgs i or Txn.application_args[i]
• Convention:
• Currently: use the first argument (index 0) as method name
• Very soon: follow the ABI�https://github.com/algorandfoundation/ARCs/blob/main/ARCs/arc-0004.md

55

How to specify which action/method to do in application call?

PyTEAL: Classic Skeleton for Smart Contract

56

def approval_program():

is_creator = Txn.sender() == Global.creator_address()

​

on_vote = Seq([...])� on_register …

� program = Cond(

[Txn.application_id() == Int(0), on_creation],

[Txn.on_completion() == OnComplete.DeleteApplication, Return(is_creator)],

[Txn.on_completion() == OnComplete.UpdateApplication, Return(is_creator)],

[Txn.on_completion() == OnComplete.CloseOut, on_closeout],

[Txn.on_completion() == OnComplete.OptIn, on_register],

[Txn.application_args[0] == Bytes("vote"), on_vote],

)

​

return program

​

if __name__ == "__main__":

with open("approval.teal", "w") as f:

compiled = compileTeal(approval_program(), mode=Mode.Application, version=5)

f.write(compiled)

Only the creator of the app can delete/update it

Logic for all the methods

When the ABI is finalized, the skeleton will change slightly.

Source:�https://pyteal.readthedocs.io/en/stable/examples.html#voting

Quick Summary

57

Application Transaction

(specifies Application Arguments)

Smart Contract

TEAL

​

​

Global State

​

​

Local State

“opted-in” Account 1

​

Approval Program

Clear Program

TEAL

Generated, signed, sent using SDK

(Python, JS, Go, Java, …)

​

(Uses an algod endpoint)

Written in TEAL

Or generated by a PyTeal

script (written in Python)

​

(No SDK, no algod endpoint)

Smart Contract = Application

= program living on the chain

Current Convention*

First argument = method called

* (pre-ABI)

Everything stored on chain in the state.

Application

Account

Control via inner transactions

PyTeal Simple

Escrow Demo

58

https://github.com/fabrice102/smart-contracts/tree/fabrice/upenn/devrel/fabrice-upenn

Every time method “payme” called (first argument),

send 2.1 Algo to the transaction sender

59

60

Algorand Smart Contracts

Fees, min balance, cost, and other constraints

Fee vs Minimum Balance

• Fee:
• At least 0.001 Algo per transaction (paid by sender)
• Goal: Payment for recording transactions�prevents spamming of transactions
• If congestion, at least fee_per_byte * transaction size

62

Use constants.min_txn_fee

Since Algorand currently support about 1,000 transactions per sec,

congestion is extremely rare

To empty an account, special “close remainder to” transaction.

• Minimum balance: (of accounts)
• Must be kept at all time / deposit
• Deposit for using space in blockchain state (like locker)
• Reimbursed when closing account/smart contract/ASA
• 0.1 Algo at all time�+ 0.1 Algo per ASA created/opted-in�+ ** Algo per smart contract created/opted-in

TEAL: Cost and Constraints

• Each opcode has a cost
• Most opcodes cost = 1
• Constraint: opcode budget
• Cost at most 700 per call
• (Can be pooled over transactions in a group)
• Constraint: program size
• 2k - 8k for total for approval and clear programs
• Other constraints:
• Up to 64 global state key/values, 16 local state key/values per account
• “key+value” size at most 128 bytes
• Up to 16 inner transactions
• More, see Algorand Parameter Tables:�https://developer.algorand.org/docs/get-details/parameter_tables

63

Reach.sh — Alternative to PyTeal with guarantee safety properties

64

Same code targets �both Ethereum and Algorand

Comparison with Ethereum

Smart Contracts

Comparison with Ethereum (1/2)

66

Comparison with Ethereum (2/2)

67

DApps and Wallets

68

Decentralized Applications = DApp

Usually, two parts:

• Smart contract:
• On Algorand: written in TEAL, PyTeal, or Reach
• On Ethereum: written in Solidity or Reach

​

• Frontend:
• Usually a webapp/website
• Connect to the blockchain via a node/API service or through a full backend
• Connect to the user wallet to issue transactions

69

Wallets for DApps

• Wallet that allows signing transactions generated by a DApp website:
• Browser extension: AlgoSigner (Algorand), MetaMask (Ethereum), …
• Website: MyAlgoWallet (Algorand), …
• Connection to wallet application: WalletConnect (Algorand, Ethereum)

​

• Keys kept by the user/wallet: the DApp never sees the key �(the DApp only sees the signed transaction)

​

70

• Alternative: custodial wallets:
• Another party (sometimes the DApp) keeps the key for the user
• Example: Aikon ORE ID

TinyMan Demo

71

https://testnet.tinyman.org/

72

73

74

75

76

77

78

Advanced Algorand Topics

79

Fee Pooling

• Transaction can pay fees for other transaction in a group�including other inner transactions�
• Example to simplify withdrawal of funds from application account:
• Set inner transaction fee to 0 Algo
• Increase the outer transaction fee by 0.001 Algo

• (Inner transaction fees cannot be used to pay for top-level transaction fees to prevent spamming)

80

Account Types

• Basic (ED25519) account
• Address = signature public key
• Transactions approved by signing them with secret key
• Application account
• Address ≈ hash of application ID
• Transactions approved/issued by associated smart contract

81

• Multi-signature account (t-out-of-n multisig)
• Address ≈ hash of threshold t and n public keys pk[1], …, pk[n]
• Transactions approved if at least t signatures with t of the associated secret keys
• Smart signature contract account
• Address ≈ hash of a TEAL program
• Transactions approved if the TEAL program executed

Smart Signatures (former Stateless Smart Contracts)

• Smart signature contract account uses:
• Sending tokens in exchange �of another tokens

82

Alice

Bob

1 Algo

20 USDC

Albert

2 Algos

20 USDC

Alma

1 Algo

20 USDC

Signed by Albert

Signed by Alice

Signed by Alma

Signed by Bob

Signed by Bob

Signed by Bob

Smart signature!

1 Algo

Smart Signatures (former Stateless Smart Contracts)

• Smart signature contract account uses:
• Sending tokens in exchange of another tokens
• Smart contracts can also be used but smart signatures are simpler
• Advanced authorization structure:
• Transactions approved if the CEO approves OR (both the COO and the CTO approve)
• Allow free application call (pay transaction fee) to specific application
• For users without accounts on Algorand / without Algos
• Very complex operations (smart signatures allow for higher cost than smart contracts)

• Smart signature delegated account (aka delegated logicsig)
• A basic or multisig account can sign a TEAL program
• Any transaction approved by the TEAL program can be sent on behalf of the account
• Example of uses:
• Delegate the ability to make low-value transactions to someone else

Rekeying

• Change the address allowed to sign/authorize transactions�without changing the actual account address

​

• After rekey an account has:
• Same address
• A different “authorized address”
• (Warning: closing an account remove the rekeying.)

​

• Uses:
• Increase security: change from basic to multisig, change to more secure basic public key, …
• Rekey to application account: give control of an existing account to a smart contract

84

Use New Accounts Local State to Extend Global State

• To extend global state: 💡use local state of some fresh accounts
• Issue: local state can be cleared at any time

85

2 solutions:

• New accounts are rekeying to application account
• Now only smart contract can clear
• Additional advantage: create
• New accounts are smart signature contract account
• More complex
• Useful if you want some unicity
• Example 1 account = 1 pair of two currencies USDC/Algos, USDT/Algos, …

Resources

• Material for this presentation:�https://github.com/fabrice102/smart-contracts/tree/fabrice/upenn/devrel/fabrice-upenn

​

• Discord: https://discord.com/invite/84AActu3at
• Developer Portal (Documentation and Tutorials): https://developer.algorand.org/
• Forum: https://forum.algorand.org/
• Algorand Office Hours sign up: https://www.algorand.com/developers

​

• List of resources:
• https://github.com/aorumbayev/awesome-algorand
• https://docs.google.com/document/d/1qB-c7zWXSQ8tS7Lk4xz_suZ248SpirAQSpJGz61wsjA/edit?usp=sharing

86

This presentation used resources from Flaticon.com