@goplausible/algorand-mcp 3.0.7

package/dist/resources/knowledge/taxonomy/developer:docs:details:useful_resources.md

@@ -0,0 +1,29 @@
+title: Useful Resources
+
+This page contains resources that don't necessarily have their own page or we don't provide comprehensive details on how to use them, but are interesting enough that we encourage you to check them out.
+
+# AlgoDevs YouTube Channel
+
+The [@AlgoDevs YouTube channel](https://www.youtube.com/@algodevs) is focused on short-form developer content that provides a quick way to get up to speed on all things Algorand. These 5-10 minute videos cover topics, like writing PyTeal smart contracts, the Algorand Virtual Machine(AVM), asset creation, transactions, and much more. These videos are actively maintained to be up to date with the current release of Algorand. Make sure to check them out and subscribe.
+
+# Algorand Developer Discord
+
+Join the Algorand developer [Discord](https://discord.gg/algorand) to keep up to date, ask questions, get code examples, comment on new features, and discuss Algorand standards. 
+
+# Smart Contract Bootcamps using AlgoKit
+
+The AlgoDevs provide instructor lead bootcamps on a rotating basis ([registration required](https://developer.algorand.org/bootcamp)). Content ranges from beginner, to intermediate, thru advanced. Video recordings follow each session to catch up on delivered content within the [Algorand Developer Bootcamps on GitHub](https://github.com/algorand-bootcamp) repository.
+
+# ARCs: Algorand Requests for Comments
+
+When it comes to standardising practises this is the place the be. Whether it's proposing a new data structure for common actions, or introducing a new process to achieve uniformity across platforms, this is the place to keep up to date and participate in discussions.
+
+- [GitHub Repository](https://github.com/algorandfoundation/ARCs)
+- [GitHub Discussions](https://github.com/algorandfoundation/ARCs/issues)
+
+# Services for Startups Building on Algorand
+
+| **Partner Service**            | **How to Apply**              | What You Get                       |
+|----------------------------|---------------------------|------------------------------------|
+| [AWS Credits](https://tinyurl.com/algoawscredits)            | Key in code `1cf01` and the Foundation team will do a quick verification of your project before enabling the free credits | 5000 credits for AWS cloud services       |
+| [Google Cloud Credits](https://cloud.google.com/startup/apply?hl=en#application-form) | Complete the application form   | Up to $200K in cloud credits over 2 years |

package/dist/resources/knowledge/taxonomy/developer:docs:get-started:algokit.md

@@ -0,0 +1,263 @@
+title: AlgoKit Quick Start Guide
+
+AlgoKit is a simple, one-stop tool for developers to quickly and easily build and launch secure, automated, production-ready decentralized applications on the Algorand protocol -- now also featuring native support for Python! This empowers developers to write Algorand apps in regular Python, one of the world's most popular programming languages.
+
+In addition, AlgoKit features:
+
+- A library of smart contract templates to kickstart your  build
+- All necessary application infrastructure running locally
+- Toolchain integrations for languages you love, like Python and TypeScript
+- A simplified frontend design experience
+
+## Prerequisites
+
+- [Python 3.12](https://www.python.org/downloads/) or higher
+- [PipX](https://pypa.github.io/pipx/#on-linux-install-via-pip-requires-pip-190-or-later)
+- [Git](https://github.com/git-guides/install-git#install-git)
+- [Docker](https://docker.com/download/)
+- [VSCode](https://code.visualstudio.com/download) (recommended)
+
+## Install AlgoKit
+
+=== "Windows"
+    !!! Note
+        This method will install the most recent python3 version [via winget](https://learn.microsoft.com/en-us/windows/package-manager/winget/). If you already have python 3.12+ installed, you may you may prefer to use `pipx install algokit` as explained within the pipx on any OS section so you can control the python version used.
+
+    - Ensure prerequisites are installed
+        - [Git](https://github.com/git-guides/install-git#install-git-on-windows) (or `winget install git.git`)
+        - [Docker](https://docs.docker.com/desktop/install/windows-install/) (or `winget install docker.dockerdesktop`)
+
+            !!! Info
+                See [our LocalNet documentation](https://github.com/algorandfoundation/algokit-cli/blob/main/docs/features/localnet.md#prerequisites) for more tips on installing Docker on Windows
+
+    - Install Python3 using WinGet
+        - Install python: `winget install python.python.3.12`
+        - Restart the terminal to ensure Python and pip are available on the path
+
+            !!! Info
+                Windows has a feature called **App Execution Aliases** that provides redirects for the Python command that guide users to the Windows Store. unfortunately these aliases can prevent normal execution of Python if Python is installed via other means, to disable them search for **Manage app execution aliases** from the start menu, and then turn off entries listed as **App Installer python.exe** or **App Installer python3.exe**.
+
+        - Install pipx:
+            ```
+            pip install --user pipx
+            python -m pipx ensurepath
+            ```
+        - Restart the terminal to ensure pipx is available on the path
+        - Install AlgoKit via pipx: `pipx install algokit`
+        - If you used AlgoKit before, update it with pipx: `pipx upgrade algokit`
+        - Restart the terminal to ensure AlgoKit is available on the path
+
+=== "macOS"
+    !!! Note
+        This method will install the latest Python3 release as a dependency via Homebrew. If you already have Python 3.10+ installed, you may prefer to use `pipx install algokit` as explained within the OS agnostic tab so you can control the python version used.
+
+    - Ensure prerequisites are installed
+
+        - [Homebrew](https://docs.brew.sh/Installation)
+        - [Git](https://github.com/git-guides/install-git#install-git-on-mac) (should already be available if `brew` is installed)
+        - [Docker](https://docs.docker.com/desktop/install/mac-install/), (or `brew install --cask docker`)
+
+            !!! Info
+                Docker requires MacOS 11+
+
+    - Install using Homebrew `brew install algorandfoundation/tap/algokit`
+    - Restart the terminal to ensure AlgoKit is available on the path
+
+
+=== "Linux"
+    - Ensure prerequisites are installed
+
+        - [Python 3.12+](https://www.python.org/downloads/)
+
+            !!! Info
+                There is probably a better way to install Python than to download it directly, e.g. your local Linux package manager
+
+        - [pipx](https://pypa.github.io/pipx/#on-linux-install-via-pip-requires-pip-190-or-later)
+        - [Git](https://github.com/git-guides/install-git#install-git-on-linux)
+        - [Docker](https://docs.docker.com/desktop/install/linux-install/)
+    - Continue with step 2 in the following section to install via `pipx` on any OS
+
+=== "OS agnostic"
+    To install AlgoKit, run the following command from a terminal.
+
+    ```shell
+    pipx install algokit
+    ```
+
+    If you used AlgoKit before, update it with pipx: `pipx upgrade algokit`
+
+    After the installation completes, **restart the terminal**.
+
+Additional AlgoKit videos are available on the [@AlgoDevs YouTube channel](https://youtube.com/@AlgoDevs).
+
+## Verify the Installation
+
+To verify AlgoKit Installed correctly run the following.
+
+```shell
+algokit --version
+```
+
+Output similar to the following should be displayed:
+
+```shell
+algokit, version 2.0.0
+```
+
+## Start a LocalNet
+
+AlgoKit supports using a [local version of the Algorand blockchain](../../get-details/algokit/features/localnet/). To start an instance of this LocalNet run the following command from the terminal:
+
+```shell
+algokit localnet start
+```
+
+This should start an instance of the LocalNet within docker. If you open the Docker Desktop application you should something similar to the following:
+
+![Docker Desktop LocalNet Instance](../imgs/localnet.png)
+
+## Create an AlgoKit project
+
+Now that AlgoKit is installed, you can rapidly create a new project to get started quickly. This can be done by running:
+
+```shell
+algokit init
+```
+
+This will launch a guided menu system to create a specific project tailored to your needs. You will first be prompted to select a specific template. The templates are basic starter applications for various Algorand development scenarios. To read more about templates checkout AlgoKit detailed documentation. For this guide, we will use the Python smart contract starter template. Select the following options:
+1. `Smart Contracts`
+2. `Python`
+3. name of your project: `DEMO`
+4. Template preset: select `Starter`.
+5. Contract deployment code: select `Python`
+6. algokit project bootstrap: `Y`
+7. git repository: `Y`
+
+Once finished, (if you have it installed) VS Code should automatically be opened with the initialized project and you will be prompted to install appropriate VS Code extensions. This starter app will contain one smart contract (built with [Algorand Python](https://algorandfoundation.github.io/puya/) named `contract.py`, in the `hello_world` folder, with one method (`hello`) that takes a `String` and returns a `String`.
+
+![AlgoKit Starter Contract](../imgs/algokitv2_starter.png)
+
+## Run the Demo Application
+
+Once the starter project is created, you will notice in the `smart_contracts/hello_world` folder a file named `deploy_config.py` which is a simple example of using AlgoKit to deploy and make a call to the `contract.py` smart contract on the LocalNet instance started earlier.
+
+![AlgoKit Starter config ](../imgs/algokit_v2_demo.png)
+
+By hitting F5 you will deploy the `HelloWorld` smart contract and then call it passing the parameter `name` with a value of `world`. You can edit this parameter in the `deploy_config.py` file and it will:
+
+1. Start LocalNet
+2. Build the smart contract
+3. Deploy and call the smart contract (`contract.py`)
+
+If you would like to manually build and deploy the `HelloWorld` smart contract run the following AlgoKit commands:
+
+```shell
+algokit project run build
+algokit project deploy 
+```
+
+This should produce something similar to the following in the VSCode terminal.
+
+```shell
+HelloWorld not found in PDEEWXLITMAPDMDYGP4XUV2EUJVPNZVKR7OUSSFZ63U4XNL2Y25FN5PYN4 account, deploying app.
+HelloWorld (v1.0) deployed successfully, with app id 1002.
+Called hello on HelloWorld (1002) with name=world, received: Hello, world
+```
+
+The App ID of of the deployed contract and its Algorand address is displayed, followed by the message returned from the smart contract call (`Hello, world`).
+
+At this point you have deployed a simple contract to an Algorand network and called it successfully!
+
+Additionally, you can find the native TEAL smart contract code and the appropriate smart contract manifest JSON files have been output to the `artifacts` folder.
+
+![AlgoKit Starter Demo](../imgs/algokitv2_json.png)
+
+These files can be used by tools like [Lora](https://lora.algokit.io/localnet), [goal](https://developer.algorand.org/docs/clis/goal/goal/), etc. to deploy your smart contract to the various Algorand networks.
+
+## Using Lora
+
+Lora is a web-based user interface that let's you visualize accounts, transactions, assets and applications on an Algorand network and also provides ability to deploy and call smart contracts. This works for TestNet, MainNet and also LocalNet. While AlgoKit surfaces both a programming interface and a command line interface for interacting with Algorand, it also allows you to quickly open Lora so you can see what's happening visually.
+
+Lora can be launched from AlgoKit by running the following command from the terminal.
+
+```shell
+algokit explore
+```
+
+By default it will open Lora and point to LocalNet (It will be displayed as `LocalNet` in the upper right hand corner), but you can pass in parameters to point it to TestNet and MainNet too.
+
+This command will launch your default web browser and load the Lora web application.
+
+**Note:** If you are using Safari, then it won't work against LocalNet and you will need to open it in a different browser.
+
+![Lora](../imgs/lora1.png)
+
+### Create / Connect  local account for testing
+
+To issue commands against the LocalNet network you need an account with ALGO in it. Lora gives you three options for connecting to a local wallet: `Connect KMD`, `Connect MNEMONIC`, and `Connect Lute`
+
+- `Connect KMD`: Lora will automatically import KMD wallet.
+
+- `Connect MNEMONIC`: You can manually input a MNEMONIC for an account you own. 
+
+- `Connect Lute`: You can create local accounts from [Lute](https://lute.app/) and connect to them.
+
+In this guide, we will use the KMD wallet.
+
+Select `Connect wallet` located at top right hand side of the webpage and you will be prompted with the three wallet choices. Choose the `Connect KMD` option. This will prompt you to enter the KMD password. If this is your first time building on Algorand, you do not have a KMD password so leave it blank and click `OK`. This will connect the KMD account to Lora so you can use that account for signing transactions from the Lora user interface.
+
+![Lora](../imgs/lora-wallet.png)
+
+### Deploy the Hello World application
+
+1. To deploy your smart contract application, select the `App Lab` menu and click on the `Create` button. 
+![Lora](../imgs/lora2.png)
+
+2. Click `Deploy new` and `Select an ARC-32 JSON app spec file` to browse to the artifacts created in the previous section of this guide. Select the `HelloWorld.arc32.json` manifest file. 
+![Lora](../imgs/lora3.png)
+![Lora](../imgs/lora4.png)
+![Lora](../imgs/lora5.png)
+
+3. This will load the specific manifest file for the Hello World sample application. Click `Next`.
+![Lora](../imgs/lora6.png)
+
+4. You can change the `Name` and the `Version` of your app. We will keep it as it is. Click `Next`.
+![Lora](../imgs/lora7.png)
+
+5. Click the `() Call` button. Then build and add the create transaction by clicking `Add`.
+![Lora](../imgs/lora8.png)
+![Lora](../imgs/lora9.png)
+
+
+6. Click `Deploy` and sign the transaction by clicking `OK` in the KMD pop up to deploy the smart contract to the local Algorand network.
+![Lora](../imgs/lora10.png)
+
+7. You should now see the deployed `HelloWorld` contract on the `App Lab` page. 
+![Lora](../imgs/lora11.png)
+
+8. Now click on the `App ID` inside of the `HelloWorld` card to go to the `Application` page.
+![Lora](../imgs/lora12.png)
+
+10. Inside the `ABI Methods` section, you should see the `hello` method. Click on the drop down and the `Call` button. You will be prompted with a popup allowing you to enter the parameter for the `hello` method and call it. 
+![Lora](../imgs/lora13.png)
+
+
+11. Enter a string in the `value` input and click on `Add`. 
+![Lora](../imgs/lora14.png)
+
+12. You should now see the transaction you just built on the `Application` page. Click `Send` and sign the transaction with your KMD wallet to execute the transaction.
+![Lora](../imgs/lora15.png)
+
+13. You should now see the `Send Result` showing you the details about the transaction you just executed!
+![Lora](../imgs/lora16.png)
+
+1.  You can also click on `Transaction ID` to go to the `Transaction` page and see the full detail of the transaction.
+![Lora](../imgs/lora17.png)
+
+You have now successfully deployed and executed a smart contract method call using Lora!
+
+## Next steps
+
+- To learn more about AlgoKit and what you can do with it, checkout the [AlgoKit documentation](../index.md).
+- To learn more about Python on Algorand, take a look at the [Python documentation](https://algorandfoundation.github.io/puya/).
+- More information on Algorand smart contracts is also available in the [smart contract documentation](https://developer.algorand.org/docs/get-details/dapps/smart-contracts/).

package/dist/resources/knowledge/taxonomy/developer:docs:get-started:basics:what_is_blockchain.md

@@ -0,0 +1,69 @@
+title: What is a blockchain? 
+
+<center>
+![Blockchain versus traditional database](../../imgs/basics-blockchain-vs-traditional.png){: style="width:500px" align=center }
+</center>
+
+A blockchain is a public ledger (or file) of transactional data, distributed across multiple computers (“nodes”) in a network. All of these nodes work together, using the same set of software and rules, to verify transactions to add to the finalized ledger. 
+
+<center>
+![Woman bids on blockchain](../../imgs/basics-woman-bid-blockchain.png){: style="width:500px" align=center }
+<figcaption style="font-size:12px">A woman places a bid on a house using software built on top of a decentralized blockchain.</figcaption>
+</center>
+
+Compare this to a traditional ledger of transactional data that may live in a single database on a few computers that only certain people have access to.
+
+<center>
+![Woman bids in traditional world](../../imgs/basics-woman-bid-traditional.png){: width='500px' }
+<figcaption style="font-size:12px">A woman places a bid on a house using a private agency.</figcaption>
+</center>
+
+The “block” part of “blockchain” refers to a set of transactions that are proposed and verified by the other nodes and eventually added to the ledger. The “chain” part, refers to the fact that each block of transactions also contains proof (a cryptographic hash) of what was in the previous block. This pattern of capturing the previous block’s data in the current block continues all the way back to the start of the network (the genesis block) creating a publicly verifiable and tamperproof record of all transactions, ever. 
+
+<center>
+![Blockchain diagram](../../imgs/blockchain-diagram.png){: width='500px' }
+</center>
+
+Practically, this means that if you try to change even a single record, anywhere in the history of a blockchain, it will be evident and rejected by the network nodes. 
+
+<center>
+![Man attempts to change blockchain record, unsuccessfully](../../imgs/basics-immutable.png){: width='500px' }
+<figcaption style="font-size:12px">A malicious user attempts to change a past blockchain record, unsuccessfully.</figcaption>
+</center>
+
+Compare this to a traditional ledger where a change in a database is entrusted to a limited group and can easily be manipulated either through malicious intent or simply error. 
+
+<center>
+![Traditional bid error](../../imgs/basics-traditional-error.png){: width='500px' }
+<figcaption style="font-size:12px">Example of how a centralized system could unintentionally disqualify user participation.</figcaption>
+</center>
+
+
+
+But how do blocks get added to the chain in the first place? Each node runs software that instructs them how to verify transactions and add new blocks to the chain. These instructions are collectively referred to as the “consensus protocol”.  The nature of these instructions are one of the main distinguishing factors of different blockchains. We will learn more about Algorand’s consensus protocol and how it differs from others’ later in this guide. 
+
+# How will blockchain benefit my application?
+
+_Blockchain, at its core, is a technology that innovates on how we transfer value._ So, if your application exchanges value in some way, blockchain may be a candidate technology to bring your application to the next level. 
+
+But before jumping in, it is important to understand specifically how it might benefit your application so that you can design a system that targets those benefits and doesn’t add unnecessary complexity to other parts of your application. This usually maps to thinking about which components to put “on-chain” versus “off-chain”.
+
+Below are some of the characteristics of blockchains that make them attractive technologies for value-based applications. 
+
+
+<center>
+![Blockchain properties](../../imgs/blockchain-properties.png)
+</center>
+
+Not all of these may be important to your application or some may be more important than others, so a good first question to ask is: 
+
+> “Which of these characteristics is an important property for my use case?” 
+
+If you choose at least one, then ask:
+ 
+> “Is that property lacking or insufficient in my current application design?” 
+
+If the answer to the second question is “yes” to any or all of the properties you chose, then you’re in the right place.
+
+For example, sending a payment across borders through a bank often takes days and is expensive since there are many intermediaries who are involved to ensure that the value is transferred securely. High **costs** and overall poor **efficiency** are the characteristics that stand out in this scenario and that blockchain could improve. That’s not to say that the other characteristics aren’t important. For example, we don’t want lower costs at the expense of security, but if security mattered alone we might say that the current process is good enough (assuming you trust the bank who is making the transfer). In this scenario, blockchain improves deficiencies in the system without making a tradeoff elsewhere.
+

package/dist/resources/knowledge/taxonomy/developer:docs:get-started:basics:whats_a_dapp.md

@@ -0,0 +1,29 @@
+title: What is a dApp?
+
+Decentralized Applications, or dApps, are applications that are run in a decentralized computing system, like a blockchain. This guide will introduce what dApps are and how dApps are architected and implemented on the Algorand blockchain.
+
+<center>
+![dApp world](../../imgs/dapps.png){: style="width:500px" align=center }
+<figcaption style="font-size:12px">A segment of the dApp ecosystem.</figcaption>
+</center>
+
+In the previous section, we discovered some of the properties of blockchain and how they offer paths to innovate on use cases that exchange items of value. A payment application, where users can exchange assets with each other, is a very simple dApp. In this use case, the payment transaction primitive is the only on-chain logic required to transfer those assets. 
+
+But how do we implement a more complex scenario, like bidding in an auction? We could build a website, have users log in, send us their bids, then issue the on-chain transfer of the item to the highest bidder. We’d then have to send the highest bid amount to the seller and return the rest of the funds to all the losing bidders. The problem with this is that your users will have to trust that you won’t run off with their bids, that the code you wrote to hold funds is sound (probably without getting to see it), that you implement world-class security practices so that you won’t get hacked, etc. 
+
+This implementation completely misses the mark on what blockchain promises and we are no better off using the blockchain than just using some of the centralized auction sites that exist already. If you’re a reputable company, then people probably trust you, but if you’re an independent developer, who is trying to build their reputation from scratch, then you’ll have a hard time getting users. And in the former scenario, you are still very much at-risk to attackers who may know that you have a large concentration of funds. The moral of this story is that we need a way to implement this bidding logic, securely, on-chain. 
+
+This is where smart contracts come into play.
+
+# Smart contracts
+
+Smart contracts are on-chain logic programs that can implement highly customized transfer conditions. They can be composed with all other layer-1 features, (including Algos, NFTs, fungible tokens) to produce powerful and sophisticated decentralized applications. 
+
+Let’s return to the auction bidding scenario and use smart contracts to implement on-chain bidding. What this means is that instead of sending bids to an account controlled by a centralized entity, subject to attacks and single points of failure, we can send those bids to a smart contract, governed by code, that is open and publicly verifiable by anyone. And that code won’t unexpectedly change. That doesn’t mean it can’t change, but if it does, it will be public and evident to users. And if you don’t like the idea that it can change, you can even program it from the start to restrict certain changes or disallow all changes to the contract. 
+
+In summary, you go from trusting an entity and _hoping_ that they will do what they promised, to trusting the code and _knowing_ it will do what it promised, regardless of the different actors involved and the different motivations they might have. 
+
+An important sidebar here is that it is critical for smart contract code to be reviewed and audited for security flaws. Badly written code that does not account for all potential attack vectors of course will not secure anything. 
+
+# What language can I use to write smart contracts?
+On Algorand, you can write smart contracts in Python with the PyTeal library. To get started building a dApp, checkout the [Algokit getting started](/docs/get-started/algokit) guide.

package/dist/resources/knowledge/taxonomy/developer:docs:get-started:basics:where_to_start.md

@@ -0,0 +1,43 @@
+title: Where do I start?
+
+# Smart contracts & dApps
+
+If you are interested in building an application([dApp](whats_a_dapp.md)) on Algorand, checkout [Algokit](/docs/get-started/algokit), which is a tool for quickly building, testing, and deploying Algorand smart contracts. 
+
+> [Tell me more about Algorand smart contracts!](/docs/get-details/dapps/smart-contracts/)
+
+
+# Tokenization
+
+This section will walk you through the basics of tokenizing assets on Algorand. We’ll start with showing you how Alice and Bob tokenize their NFT, and then walk through creating fungible tokens. You don’t need to write smart contract code to tokenize assets on Algorand. Assets are a layer-1 primitive, built right into the protocol itself.
+
+> [I want to learn how to mint NFTs.](/docs/get-started/tokenization/nft/){: target="_blank}
+
+> [I want to learn how to create fungible tokens.](/docs/get-started/tokenization/ft){: target="_blank}
+
+-----
+
+# Detailed feature documentation
+
+If you are looking for detailed feature explanations and reference documentation, check out the “Get details” section or just search for what you’re looking for using the search box in the top left corner of the site.
+
+> [Get all the details on layer-1 features and capabilities.](/docs/get-details/){: target="_blank}
+
+-----
+
+# Developer Blog
+
+Here you can find code tutorials and prototypes from the Algorand developer community. This is also where big features will be announced. 
+
+> [See the latest articles and code from Algorand and the community.](../../../../blog/){: target="_blank}
+
+-----
+
+# Participate in Algorand Consensus
+
+Most of this getting started section is targeted towards application developers. If you’re interested in running a MainNet node and participating in Algorand consensus, refer to the "Run a node" section.
+
+> [I want to run a node.](/docs/run-a-node/setup/types/){: target="_blank}
+
+> [I want to participate in Algorand consensus.](/docs/run-a-node/participate/){: target="_blank}
+

package/dist/resources/knowledge/taxonomy/developer:docs:get-started:basics:why_algorand.md

@@ -0,0 +1,119 @@
+title: Why Algorand?
+
+So far, we’ve discussed blockchain technology and the benefits it brings to applications that transfer value. But we made some assumptions about the type of blockchain we’re dealing with when we formed these definitions. In reality, not all blockchains are created equal, and not all of them can provide the same degree of benefit.  
+
+_As a developer, it’s important to do your research and choose a blockchain that you can rely on for all the properties that a blockchain promises._ 
+
+In this section we will outline some of the main categories to evaluate against when choosing a blockchain and we’ll explain how Algorand fares in each of these categories. We are confident that by the end, you’ll determine that the Algorand blockchain is the best place to build your application!
+
+# Quick start videos
+
+If you prefer videos, take a look at this 4 minute video where Algorand's CTO John Woods Introduces Algorand's Latest Developer Video Series and the Pure Proof of Stake Consensus. 
+
+<iframe width="100%" style="aspect-ratio:16/9" src="https://www.youtube-nocookie.com/embed/DWC2Ocz7NEw" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen></iframe>
+
+# Our founding principles
+
+Algorand was founded by Silvio Micali, a Turing award winner, co-inventor of zero-knowledge proofs, and a world-renowned leader in the field of cryptography and information security. He founded Algorand with a vision to democratize finance and deliver on the blockchain promise. 
+
+# The consensus protocol
+
+The problem with many blockchains is they sacrifice at least one of the key properties of **security**, **scalability**, and **decentralization**, known as the blockchain trilemma. Silvio and his team solved the blockchain trilemma by inventing a new **Pure Proof of Stake (PPoS)** consensus protocol, which is the protocol that the Algorand blockchain uses.
+
+Algorand’s consensus protocol works by selecting a block proposer and a set of voting committees at each block round, to propose a block and validate the proposal, respectively. The proposer and committees are randomly chosen from the pool of all token holders (the accounts that hold algos), and the likelihood of being chosen is proportional to the account’s stake in the network (i.e. how many algos it has relative to the whole). There are a bunch of really cool cryptographic algorithms that go into this process, with fancy names like “verifiable random functions” and “cryptographic sortition” to ensure that the vote is fair, no one can collude, and that the overall system is highly secure. We won’t get into the details in this guide, but we highly recommend checking out some of these resources:
+
+* [Silvio explains how Algorand consensus works at a meetup](https://www.youtube.com/watch?v=NykZ-ZSKkxM){: target="_blank" } in Milan (video, simple, longer but worth it).
+* Silvio describes [Algorand’s core technology in a nutshell](https://medium.com/algorand/algorands-core-technology-in-a-nutshell-e2b824e03c77){: target="_blank"} (blog post, simple, worth it).
+* A [simple, introductory video](https://www.youtube.com/watch?v=gACVKaNqxPs){: target="_blank" } on Algorand’s consensus protocol (video, simple, short)
+* [Docs on Algorand consensus](../../get-details/algorand_consensus.md){: target="_blank" } (technical, medium-length, somewhere in between the simple video above and the full whitepaper)
+* [The official Algorand whitepaper](https://algorandcom.cdn.prismic.io/algorandcom%2Fece77f38-75b3-44de-bc7f-805f0e53a8d9_theoretical.pdf){: target="_blank" } (very technical, detailed)
+
+# Proof-of-stake versus proof-of-work
+
+Most blockchains these days fall into the general categories of **proof-of-stake** or **proof-of-work**. 
+
+Simply put, a **proof-of-stake** blockchain gives users who have more stake (who hold more of the underlying currency in the system) more influence in proposing and validating new blocks, usually through some sort of voting mechanism.
+
+<center>
+![Proof-of-stake](../../imgs/basics-pos.png){: width='500px' }
+<figcaption style="font-size:12px">Concept drawing of the voting procedure in proof-of-stake protocols.</figcaption>
+</center>
+
+In **proof-of-work**, nodes race to solve a challenging cryptographic puzzle and serve up their solution alongside a new block proposal (this is referred to as “mining” and these nodes are called “miners”). The winner is rewarded with some of the underlying currency of the system and their block becomes part of the chain. 
+
+<center>
+![Proof-of-work](../../imgs/basics-pow.png){: width='500px' }
+<figcaption style="font-size:12px">Concept drawing of block miners in proof-of-work protocols.</figcaption>
+</center>
+
+Because proof-of-work requires solving a cryptographic puzzle before anyone else, compute power plays a significant part in the strategy to win. This has led to many debates around energy consumption and its effects on the climate. 
+
+Most proof-of-stake protocols, including Algorand’s, do not require large amounts of energy to produce a block. 
+
+# The native currency
+
+Each blockchain has its own native currency that plays a critical role in incentivizing good network behavior. Algorand’s native currency is called the Algo. 
+
+If you hold Algos, you can register to participate in consensus, which means that you will participate in the process of proposing and voting on new blocks. 
+
+The Algo also acts as a utility token. When you’re building an application, you need algos to pay transaction fees and to serve as minimum balance deposits if you want to store data on the blockchain. The cost of these fees and minimum balances is very low, fractions of a penny in most cases.
+
+# Fees
+Fees are calculated based on the size of the transaction and a user can choose to augment a fee to help prioritize acceptance into a block when network traffic is high and blocks are consistently full. There is no concept of gas fees on Algorand. 
+
+The minimum fee for a transaction is only 1,000 microAlgos or 0.001 Algos. 
+
+# Openness
+Earlier, we compared a blockchain ledger that is distributed, to a traditional ledger that is owned by a single entity. Technically, a blockchain ledger could be owned and operated by just a few entities, but this wouldn’t be a very good blockchain since such a centralized set of nodes could easily manipulate the state of the blockchain.
+
+Algorand is completely open and permissionless. Anyone, anywhere in the world, who owns Algos can participate in consensus.
+
+# Decentralization
+Similarly, if all the people who are running nodes are the same company or set of companies then we find ourselves in a similar situation where we aren’t much better off than just having a central database controlled by a select few. 
+
+On Algorand, since the protocol is open and permissionless, nodes can and do exist all over the world.
+
+> See the [Algorand Metrics Dashboard](https://metrics.algorand.org/){: target="_blank" } for a view on node decentralization.
+
+# Transparency
+
+How do you know that anything that we are telling you here is true? You can check for yourself. All of the code for the core protocol is open source. Anyone can review it and contribute to it.
+
+> [The Algorand source code](https://github.com/algorand/go-algorand){: target="_blank" }
+
+# Forking (or lack of)
+Forking is when a blockchain diverges into two separate paths. Sometimes this forking is intentional, like when a significant part of the community wants to change the fundamentals of the protocol. Other times this forking is accidental and occurs when two miners find a block at almost the same time. Eventually, one of the paths will be abandoned, which means that all transactions that occurred since that fork on the abandoned path (the orphaned chain) will be invalid. This has important implications for transaction finality, which we’ll talk about in a bit. 
+
+Since Algorand is pure proof-of-stake and uses a voting mechanism to validate blocks, forking is impossible. In a worst case scenario, if the committee is taking longer to reach agreement, the blockchain will slow down or temporarily stall. 
+
+# Performance
+The speed at which blocks are produced, the amount of transactions that can fit into a block, and when those transactions are considered final are important factors to consider when choosing a blockchain. For Algorand, performance is and will always be a key focus area for the core development team.
+
+## Throughput
+You want to choose a blockchain that can scale and handle high throughput so that your users don’t experience long wait times when interacting with your application.
+
+On Algorand, blocks are produced every 2.85 seconds and can hold up to 25,000 transactions, which results in a throughput of over 10,000 transactions per second (10,000 TPS). 
+
+## Finality
+In proof-of-work blockchains, since forking is a possibility, transactions can’t be considered final until a certain amount of time passes and the likelihood of the transaction being on an orphaned chain is practically zero. This means that the actual throughput of this type of blockchain is caveated by a delay in finality. Downstream processes in an application must take this into account to avoid compounding issues if a transaction ends up being invalid.
+
+As we mentioned earlier, Algorand does not have forking so transactions are final as soon as they are confirmed in a block. A throughput of 10,000 TPS then actually means 10,000 _finalized_ transactions per second.
+
+# Core features
+Algorand makes it easy to tokenize, transfer, and program conditions on any instrument of value. Create fungible and nonfungible tokens with a single transaction (no smart contract code required). Or program sophisticated decentralized applications (dApps) with Algorand smart contracts.
+
+# Developer tools
+Developers can write smart contracts in Python and can use one of four SDKs (Python, JavaScript, Golang, Java) to connect to on-chain assets or applications.
+
+
+# The team & ecosystem
+The Algorand protocol is completely open source, so why can’t anyone just go create a copy and create another Algorand-like blockchain? Well they absolutely can, but then they’ll have to convince everyone why the new one is better. As we’ve seen, the technology is a critical component to a blockchain, but so is the ecosystem built around it. 
+
+Algorand has some of the best researchers and developers in the world actively developing and improving Algorand’s core protocol. The Algorand Foundation invests heavily in strategy around governance and growth of the ecosystem to promote long-term value for all algo holders. This part is not easy to replicate.
+
+# Governance
+The Algorand Foundation, a non-profit organization that launched the Algorand MainNet, governs the Algorand network and is committed to continuing to decentralize it and put more decision-making into the hands of the Algorand community at large.
+
+> Visit the [Algorand Foundation website](https://algorand.foundation/governance){: target="_blank" } for more information.
+
+

package/dist/resources/knowledge/taxonomy/developer:docs:get-started:tokenization:ft.md

@@ -0,0 +1,24 @@
+title: Create a fungible token
+
+# 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. Algos are fungible, but since they are also a utility token for the Algorand network, they are implemented differently from the types of fungible tokens we’ll talk about in this guide.
+
+<center>
+![Examples of FTs](../../imgs/tokenization-fungible-1.png){: style="width:500px" align=center }
+<figcaption style="font-size:12px">Examples of fungible token use cases: local currencies, travel program loyalty points, in-game tokens.</figcaption>
+</center>
+
+Loyalty programs that offer reward points that can be traded in for merchandise or services are considered fungible. Fiat currencies are fungible and can be represented on the blockchain as stablecoins (a token that maintains a steady value usually by having backed reserves or through some stabilization algorithms) or by direct issuance on the blockchain (central bank digital currencies). Tokenized shares in real estate, a company, or a fund are usually fungible too.
+
+Tokenizing a fungible asset is an onramp to all the benefits of a blockchain ecosystem that we learned about in the first section of this getting started guide (security, trust, immutability, efficiency, low costs, composability).
+
+# How to create fungible tokens
+Fungible tokens, like NFTs, are implemented as Algorand Standard Assets (ASAs). Also like NFTs, you do not need to write smart contract code. You just need to specify a few parameters to identify it as an FT (e.g. total count is greater than 1) and attach metadata so that potential owners have the information they need to validate the integrity of the asset. See Algorand Request for Comments for standards used by the Algorand community to properly format properties of an FT.
+
+This asset creation transaction can be created using any of [Algorands SDKs](../../sdks/index.md). Code demonstrating creating an Asset is available in the [ASA documentation](../../get-details/asa.md#creating-an-asset).
+
+
+# Other fungible token resources 
+
+- Detailed documentation on [Algorand Standard Assets (ASAs)](../../../get-details/asa/){: target="blank"} and related [transaction types](../../../get-details/transactions/#asset-configuration-transaction){: target="blank"}.
+

package/dist/resources/knowledge/taxonomy/developer:docs:get-started:tokenization:nft.md

@@ -0,0 +1,41 @@
+title: Create an NFT
+
+# What are NFTs?
+
+Non-fungible tokens, or NFTs for short, are unique assets represented on the blockchain. Digital art and collectibles are types of NFTs that you may have heard about, but they only scratch the surface of what is possible. 
+
+<center>
+![Examples of NFTs](../../imgs/tokenization-nfts.png){: style="width:500px" align=center }
+<figcaption style="font-size:12px">Examples of NFT use cases: Tokenizing the rights to a song to facilitate royalty payments, in-game collectibles, or special edition brand merchandise.</figcaption>
+</center>
+
+If Alice wants to use blockchain to help her scale and grow her art business, because it provides important properties that she cannot achieve otherwise (trust, transparency, efficiency, low costs). The first step for her is to represent her unique art pieces on-chain as NFTs. Let's go ahead and learn how to create an NFT on Algorand.
+
+# How to create NFTs
+NFTs are created using Algorand Standard Assets (ASAs), which are built into the protocol and created using a special type of transaction. This is distinct from some other blockchains where a smart contract is necessary to represent assets. You just need to specify a few parameters to identify it as an NFT and link to the metadata so that potential owners have the information they need to validate the integrity of the asset. For instance, you need to set the total amount of units you want to create for this asset to 1 and set the number of decimals to 0. This ensures you create precisely one unit of your ASA and can't divide the newly minted asset. See [Algorand Request for Comments](https://arc.algorand.foundation/) for standards used by the Algorand community to properly format properties of an NFT.
+
+This asset creation transaction can be created using any of [Algorands SDKs](../../sdks/index.md). Code demonstrating creating an Asset is available in the [ASA documentation](../../get-details/asa.md#creating-an-asset).
+
+
+<center>
+![Alice creates an NFT](../../imgs/tokenization-alice-bob-nft.png){: style="width:500px"}
+<figcaption style="font-size:12px">Alice tokenizes her art piece as an NFT on Algorand.</figcaption>
+</center>
+
+**Composability**
+
+ASAs can be composed with other features on Algorand (like smart contracts) and with applications built on top of Algorand. What makes this possible is the combination of the standard representation of an NFT on the Algorand blockchain, both as an ASA and specifically as a unique ASA, and the openness and permissionless nature of the Algorand blockchain. 
+
+# Fractional NFTS
+
+A fractional NFT is a unique asset that has been divided into multiple, equal shares. When NFTs are selling for millions of dollars, this may be one way to lower the bar for entry and reach more potential buyers who would not have been able to invest in the whole NFT. The other side of the coin (pun intended) is that by increasing your pool of potential buyers, you may see the value of your NFT increase. Need a compelling example? In September 2021, the owner of a meme Doge NFT who paid 4 million dollars for it, fractionalized it and then auctioned off a portion of those fractional shares at a price that revalued their asset at 225 million USD[^1].
+
+[^1]: [https://www.theblockcrypto.com/linked/116464/fractionalized-doge-nft-valued-at-225-million-after-sushiswap-auction](https://www.theblockcrypto.com/linked/116464/fractionalized-doge-nft-valued-at-225-million-after-sushiswap-auction){: target="_blank"}
+
+Maybe Alice should think about fractionalizing her artwork for her next auction!
+ 
+To create a fractional NFT, the total units must be a power of 10, greater than 1, and the number of decimals must be equal to the logarithm in base 10 of the total number of units. The fractional NFT standard is defined as part of [ARC-0003](https://github.com/algorandfoundation/ARCs/blob/main/ARCs/arc-0003.md){: target="_blank"}. 
+# More NFT Resources
+
+- Learn more about NFTs from Algorand's Chief Product Officer: [The Enduring Value of NFTs on Algorand: A Critical Role in the Future of Finance](https://www.algorand.com/resources/blog/the-enduring-value-of-nfts-on-algorand){: target="blank"}
+- Detailed documentation on [Algorand Standard Assets (ASAs)](../../../get-details/asa/){: target="blank"} and related [transaction types](../../../get-details/transactions/#asset-configuration-transaction){: target="blank"}.