Add algorand roadmap

src/data/roadmaps/algorand/algorand.json

@@ -0,0 +1,160 @@
+[
+  {
+    "phase_id": "1",
+    "phase_name": "Algorand",
+    "topics": [
+      {
+        "topic_id": "what-is-algorand",
+        "topic_name": "What is Algorand?",
+        "subtopics": [
+          {
+            "subtopic_id": "why-algorand",
+            "subtopic_name": "Why Algorand?"
+          },
+          {
+            "subtopic_id": "who-created-algo",
+            "subtopic_name": "Who created ALGO?"
+          },
+          {
+            "subtopic_id": "algorand-consensus",
+            "subtopic_name": "Algorand consesus"
+          },
+          {
+            "subtopic_id": "algorand-networks",
+            "subtopic_name": "Algorand networks"
+          }
+        ]
+      },
+      {
+        "topic_id": "algorand-virtual-machine",
+        "topic_name": "Algorand Virtual Machine",
+        "subtopics": [
+          {
+            "subtopic_id": "what-the-avm-does",
+            "subtopic_name": "What the AVM does"
+          },
+          {
+            "subtopic_id": "avm-architecture",
+            "subtopic_name": "AVM Architecture"
+          },
+          {
+            "subtopic_id": "how-to-program-AVM",
+            "subtopic_name": "How to program AVM?"
+          },
+          {
+            "subtopic_id": "what-is-teal",
+            "subtopic_name": "What is TEAL?"
+          },
+          {
+            "subtopic_id": "teal-architecture",
+            "subtopic_name": "TEAL Architecture"
+          },
+          {
+            "subtopic_id": "algorand-smart-contracts",
+            "subtopic_name": "Algorand Smart Contracts (ASC1)"
+          }
+        ]
+      },
+      {
+        "topic_id": "application-binary-interface",
+        "topic_name": "What is Arc4?",
+        "subtopics": [
+
+        ]
+      }
+    ]
+  },
+  {
+    "phase_id": "Algorand-layer-1-capabilities",
+    "phase_name": "Algorand layer-1 capabilities",
+    "topics": [
+      {
+        "topic_id": "account",
+        "topic_name": "Algorands Account",
+        "subtopics": [
+          {
+            "subtopic_id": "algopy-account",
+            "subtopic_name": "Account on the Algorand network"
+          }
+        ]
+      },
+      {
+        "topic_id": "transaction",
+        "topic_name": "Transaction",
+        "subtopics": [
+          {
+            "subtopic_id": "payment-transaction",
+            "subtopic_name": "Payment Transaction"
+          },
+          {
+            "subtopic_id": "group-transactions",
+            "subtopic_name": "Group Transactions"
+          }
+        ]
+      },
+      {
+        "topic_id": "Algorand-smart-contracts",
+        "topic_name": "Algorand Smart Contracts",
+        "subtopics": [
+          {
+            "subtopic_id": "What-is-a-smart-contract",
+            "subtopic_name": "What's a smart contract?"
+          },
+          {
+            "subtopic_id": "smart-contract-storage",
+            "subtopic_name": "Smart contract storage"
+          },
+          {
+            "subtopic_id": "smart-contract-application",
+            "subtopic_name": "Smart contract high level"
+          }
+          ,
+          {
+            "subtopic_id": "smart-contract-deployment",
+            "subtopic_name": "Smart Contract Deployment"
+          }
+
+        ]
+      },
+      {
+        "topic_id": "algorand-standard-assets",
+        "topic_name": "Algorand Standard Assets(ASA)",
+        "subtopics": [
+          {
+            "subtopic_id": "What-is-an-ASA?",
+            "subtopic_name": "What is an ASA?"
+          },
+          {
+            "subtopic_id": "non-fungible-token?",
+            "subtopic_name": "NFT - non fungible token"
+          },
+          {
+            "subtopic_id": "fungible-tokens",
+            "subtopic_name": "FT - Fungible tokens"
+          },
+          {
+            "subtopic_id": "asset-lifecycle",
+            "subtopic_name": "The lifecycle for assets "
+          }
+        ]
+      }
+    ]
+  }
+  ,
+  {
+    "phase_id": "3",
+    "phase_name": "The Algorand Framework for Developers",
+    "topics": [
+      {
+        "topic_id": "algokit-20",
+        "topic_name": "AlgoKit 2.0",
+        "subtopics": [
+          {
+            "subtopic_id": "what-is-algokit",
+            "subtopic_name": "What is Algokit?"
+          }
+        ]
+      }
+    ]
+  }
+]

src/data/roadmaps/algorand/algorand.md

@@ -0,0 +1,10 @@
+---
+title: "Algorand SDK Roadmap"
+briefTitle: "Algorand"
+description: "Algorand blockchain uses a decentralized Byzantine agreement protocol that uses pure proof of stake (PPOS) with high throughput, fast time to finality, and high security"
+tags: ["protocol"]
+order: 2
+isHidden: false
+github: "https://github.com/algorand"
+documentationLink: "https://algorand-doc.openedu101.com/"    
+---

src/data/roadmaps/algorand/content/algorand-consensus.md

@@ -0,0 +1,2 @@
+
+Algorand uses a Proof-of-Stake (PoS) consensus mechanism, and distributes validator rewards to all holders of its native ALGO cryptocurrency

src/data/roadmaps/algorand/content/algorand-smart-contracts.md

@@ -0,0 +1,7 @@
+# Algorand Smart Contracts (ASC1)
+Algorand Smart Contracts (ASC1) are small programs that perform different tasks on the blockchain and are executed directly on the Algorand network.
+
+There are two main types of smart contracts:
+* Smart contract(Stateful contracts): can be called and interacted with from any node on the Algorand blockchain
+
+* Smart signatures(Stateless contracts): used for transaction signing purposes, particularly for signature delegation

src/data/roadmaps/algorand/content/algorand-virtual-machine.md

@@ -0,0 +1,18 @@
+
+# What is AVM ? 
+
+![Image](https://miro.medium.com/v2/resize:fit:1400/format:webp/1*anoOGTeH-6-mCgqhn0VugA.jpeg)
+
+The Algorand Virtual Machine (AVM) runs on every node and is essential for executing smart contracts on the Algorand blockchain network. 
+
+In the image above, the AVM as a Blackbox acts as the middleman between smart contracts and the Blockchain.
+
+
+
+
+
+# Resources:
+- [@official@AVM documentation](https://developer.algorand.org/docs/get-details/dapps/avm)
+
+- [@article@Understanding the  Algorand Virtual Machine](https://medium.com/@fa_async/understanding-the-algorand-virtual-machine-a-comprehensive-guide-with-diagrams-d533228dd593)
+

src/data/roadmaps/algorand/content/application-binary-interface.md

@@ -0,0 +1,7 @@
+# Application Binary Interface
+
+
+
+
+# Resources:
+- [@article@ARC-4 github documentation](https://github.com/algorandfoundation/puya/blob/main/docs/lg-arc4.md)

src/data/roadmaps/algorand/content/asset-lifecycle.md

@@ -0,0 +1,17 @@
+
+
+# Asset lifecycle
+The lifecycle for assets on Algorand consists of the following steps:
+
+1. **Creation**: Any account on Algorand can create an asset.
+2. **Configure Roles**: Set roles for managers, reserve, clawback, and freeze.
+3. **Transfer**: Assets can be moved from one account to another. The receiver must opt in first to avoid spam.
+4. **Freeze**: Assets can be frozen to stop transactions. This prevents assets from being transferred or used temporarily.
+5. **Clawback**: An issuer can take back tokens from a specific address.
+6. **Destroy**: Assets can be destroyed. This must be done by the asset manager
+
+Each of these steps ensures that assets on the Algorand network are managed securely and efficiently, providing a robust framework for asset lifecycle management.
+
+
+# Resources: 
+- [@type@asset management](https://developer.algorand.org/search/?search_query=asset%20management&category=all-categories)

src/data/roadmaps/algorand/content/avm-architecture.md

@@ -0,0 +1,14 @@
+# AVM architecture 
+
+Smart contracts are written in a higher level language and compiled to bytecode for execution by the Layer-1 Algorand Virtual Machine (AVM)
+
+
+![image](https://images.prismic.io/algorandcom/51beb06e-d212-426a-b379-29e6c080b50e_Screen+Shot+2021-05-18+at+9.42.03+AM.png?auto=compress%2Cformat)
+
+
+
+
+# Resources: 
+- [@article@AVM documentation](https://algorandtechnologies.com/news/algorand-new-approach-to-smart-contract-dev)
+
+- [@video@AVM architecture](https://youtu.be/fTAPLiPcj28?t=691)

src/data/roadmaps/algorand/content/fungible-tokens.md

@@ -0,0 +1,9 @@
+# What are fungible tokens?¶
+
+Fungible tokens, or FTs for short, are a type of asset split into multiple units that are fundamentally the same and interchangeable one-to-one with each other.
+
+
+# Resources: 
+[@official@Create a fungible token](https://developer.algorand.org/docs/get-started/tokenization/ft/)
+
+

src/data/roadmaps/algorand/content/how-to-program-AVM.md

@@ -0,0 +1,18 @@
+# How to program AVM 
+
+
+The AVM runs programs written in bytecode.
+
+These programs, called TEAL programs, have sets of operation codes (opcodes) that define how smart contracts and smart signatures work.
+
+![image](https://miro.medium.com/v2/resize:fit:4800/format:webp/1*O0y4ZFISn7ETsVOVoQxKFw.jpeg)
+
+You need to know programming languages to write smart contracts: 
+
+* Python - Algorand provides language bindings for Python to the AVM.  Developers write their code in Python and access AVM opcodes via a supplied library without having to write directly in Teal.  
+
+
+
+* [Reach](https://docs.reach.sh/#reach-top) simplifies the creation of smart contracts and dApps by using a simplified version of JavaScript. It integrates smart contracts, front-end clients, back-end servers, and their communication into one language. The compiler ensures error-free, secure, and correctly connected components, and includes a tool for automatic application verification.
+
+* [clarity](https://clarity-lang.org/) The Clarity language, supported by Algorand, the Stacks ecosystem, and Hiro PBC, is being integrated into a compiler for layer-1 smart contracts. Clarity emphasizes predictability and security, allowing comprehensive analysis of smart contracts and eliminating common bugs through type checking.

src/data/roadmaps/algorand/content/non-fungible-token.md

@@ -0,0 +1,2 @@
+NFTs are unique digital assets that represent ownership or proof of authenticity of a specific item or piece of content, such as art, music, or virtual real estate, on the blockchain.
+

src/data/roadmaps/algorand/content/smart-contract-application.md

@@ -0,0 +1,3 @@
+# Smart contract aka Apps
+
+The application Transaction communicate with Application Transactions 

src/data/roadmaps/algorand/content/smart-contract-deployment.md

@@ -0,0 +1,22 @@
+# Smart Contract Deployment
+Algokit provide end-to-end  the development experience that support for smart contract development lifecycle:
+
+
+- Development 
+	- You **Write** smart contracts 
+	- You **Transpile** to TEAL Templates
+- Deployment
+1. **Substitute** deploy-time parameters into TEAL Templates to create final TEAL code
+2. **Compile** the TEAL to create byte code using algod
+3. **Deploy** the byte code to one or more Algorand networks (e.g. LocalNet, TestNet, MainNet) to create Application(s).
+
+
+```python
+print("hi")
+
+
+```
+
+
+# Resources 
+- [@article@Smart contrqact deployment](https://github.com/algorandfoundation/algokit-cli/blob/main/docs/architecture-decisions/2023-01-12_smart-contract-deployment.md)

src/data/roadmaps/algorand/content/smart-contract-storage.md

@@ -0,0 +1,20 @@
+# Three types of storage
+
+Algorand Smart Contracts (ASC1) have three types of storage: local storage, global storage, and box storage.
+
+* Local storage is for each account using the smart contract. It keeps data related to that account's use of the contract.
+
+* Global storage is for the whole smart contract application. It keeps data shared by all accounts using the contract.
+
+* Boxes are storage parts that can hold up to 32kb of data. They are used for bigger or more detailed information.
+
+![image](https://miro.medium.com/v2/resize:fit:1400/format:webp/1*PdpiqF6zZfXe7DZf121c7g.jpeg)
+
+Both global and local storage are structured as Key/Value pairs. Each Key/Value pair in storage has a limit of 128 bytes.
+
+
+
+
+
+
+# Resources 

src/data/roadmaps/algorand/content/teal-architecture.md

@@ -0,0 +1,11 @@
+# TEAL Architecture Overview
+
+
+
+![image](https://developer.algorand.org/docs/imgs/teal_overview-1.png)
+
+
+# Resources:
+- [@official@TEAL](https://developer.algorand.org/docs/get-details/dapps/avm/teal/)
+
+

src/data/roadmaps/algorand/content/transaction.md

@@ -0,0 +1,5 @@
+
+Algorand Python provides types for accessing fields of other transactions in a group, as well as creating and submitting inner transactions from your smart contract.
+
+# Resource 
+- [@article@transaction](https://algorandfoundation.github.io/puya/lg-transactions.html)

src/data/roadmaps/algorand/content/what-is-algorand.md

@@ -0,0 +1,11 @@
+
+# What is Algorand?
+
+Algorand is a decentralized network built to solve the Blockchain Trilemma of achieving speed, security, and decentralization simultaneously. 
+
+Launched in June 2019, Algorand is a permissionless, open-source blockchain network upon which anyone can build.
+
+
+Resources:
+
+- [@official@Algorand Documentation](https://developer.algorand.org/docs/)

src/data/roadmaps/algorand/content/what-is-teal.md

@@ -0,0 +1,11 @@
+# Transaction Execution Approval Language (TEAL)
+
+TEAL is a language used to write programs that are converted into bytecode for the Algorand Virtual Machine (AVM). 
+
+
+![image](https://miro.medium.com/v2/resize:fit:1400/format:webp/1*7zjY6yvUuonpKQ3Zsq3eqQ.jpeg)
+
+
+ Developers can write smart contracts using TEAL or Python with the help of the library which provides a convenient way to write TEAL code in Python
+
+