@goplausible/algorand-mcp 3.0.7

package/dist/resources/knowledge/taxonomy/algokit:cli:tutorials:algokit-template.md

@@ -0,0 +1,220 @@
+# Creating AlgoKit Templates
+
+This README serves as a guide on how to create custom templates for AlgoKit, a tool for initializing Algorand smart contract projects.
+Creating templates in AlgoKit involves the use of various configuration files and a templating engine to generate project structures that are tailored to your needs.
+This guide will cover the key concepts and best practices for creating templates in AlgoKit.
+We will also refer to the official [`algokit-python-template`](https://github.com/algorandfoundation/algokit-python-template) as an example.
+
+## Table of Contents
+
+- [Quick Start](#quick-start)
+- [Overview of AlgoKit Templates](#overview-of-algokit-templates)
+  - [Copier/Jinja](#copierjinja)
+  - [AlgoKit Functionality with Templates](#algokit-functionality-with-templates)
+- [Key Concepts](#key-concepts)
+  - [.algokit.toml](#algokittoml)
+  - [Python Support: pyproject.toml](#python-support-pyprojecttoml)
+  - [TypeScript Support: package.json](#typescript-support-packagejson)
+  - [Bootstrap Option](#bootstrap-option)
+  - [Predefined Copier Answers](#predefined-copier-answers)
+  - [Default Behaviors](#default-behaviors)
+  - [Generators](#generators)
+- [Recommendations](#recommendations)
+- [Conclusion](#conclusion)
+
+## Quick Start
+
+For users who are keen on getting started with creating AlgoKit templates, you can follow these quick steps:
+
+1. Click on `Use this template`->`Create a new repository` on [algokit-python-template](https://github.com/algorandfoundation/algokit-python-template) Github page. This will create a new reference repository with clean git history, allowing you to start modifying and transforming the base python template into your own custom template.
+2. Modify the cloned template according to your specific needs. You can refer to the remainder of this tutorial for an understanding of expected behaviors from the AlgoKit side, Copier - the templating framework, and key concepts related to the default files you will encounter in the reference template.
+
+## Overview of AlgoKit Templates
+
+AlgoKit templates are essentially project scaffolds that can be used to initialize new smart contract projects. These templates can include code files, configuration files, and scripts. AlgoKit uses Copier along with the Jinja templating engine to create new projects based on these templates.
+
+### Copier/Jinja
+
+AlgoKit uses Copier templates. Copier is a library that allows you to create project templates that can be easily replicated and customized. It's often used along with Jinja. Jinja is a modern and designer-friendly templating engine for Python programming language. It's used in Copier templates to substitute variables in files and file names. You can find more information in the [Copier documentation](https://copier.readthedocs.io/) and [Jinja documentation](https://jinja.palletsprojects.com/).
+
+### AlgoKit Functionality with Templates
+
+AlgoKit provides the `algokit init` command to initialize a new project using a template. You can either pass the template name using the `-t` flag or select a template from a list.
+
+## Key Concepts
+
+### .algokit.toml
+
+This file is the AlgoKit configuration file for this project which can be used to specify the minimum version of the AlgoKit. This is essential to ensure that projects created with your template are always compatible with the version of AlgoKit they are using.
+
+Example from `algokit-python-template`:
+
+```toml
+[algokit]
+min_version = "v1.1.0-beta.4"
+```
+
+This specifies that the template requires at least version `v1.1.0-beta.4` of AlgoKit.
+
+### Python Support: `pyproject.toml`
+
+Python projects in AlgoKit can leverage a wide range of tools for dependency management and project configuration. While Poetry and the `pyproject.toml` file are common choices, they are not the only options.
+If you opt to use Poetry, you'll rely on the pyproject.toml file to define the project's metadata and dependencies. This configuration file can utilize the Jinja templating syntax for customization.
+
+Example snippet from `algokit-python-template`:
+
+```toml
+[tool.poetry]
+name = "{{ project_name }}"
+version = "0.1.0"
+description = "Algorand smart contracts"
+authors = ["{{ author_name }} <{{ author_email }}>"]
+readme = "README.md"
+
+...
+```
+
+This example shows how project metadata and dependencies are defined in `pyproject.toml`, using Jinja syntax to allow placeholders for project metadata.
+
+### TypeScript Support: `package.json`
+
+For TypeScript projects, the `package.json` file plays a similar role as `pyproject.toml` can do for Python projects. It specifies metadata about the project and lists the dependencies required for smart contract development.
+
+Example snippet:
+
+```json
+{
+  "name": "{{ project_name }}",
+  "version": "1.0.0",
+  "description": "{{ project_description }}",
+  "scripts": {
+    "build": "tsc"
+  },
+  "devDependencies": {
+    "typescript": "^4.2.4",
+    "tslint": "^6.1.3",
+    "tslint-config-prettier": "^1.18.0"
+  }
+}
+```
+
+This example shows how Jinja syntax is used within `package.json` to allow placeholders for project metadata and dependencies.
+
+### Bootstrap Option
+
+When instantiating your template via AlgoKit CLI it will optionally prompt the user to automatically run [algokit bootstrap](https://github.com/algorandfoundation/algokit-cli/blob/main/docs/features/bootstrap.md) after the project is initialized and can perform various setup tasks like installing dependencies or setting up databases.
+
+- `env`: Searches for and copies an `.env*.template` file to an equivalent `.env*` file in the current working directory, prompting for any unspecified values. This feature is integral for securely managing environment variables, as it prevents sensitive data from inadvertently ending up in version control.
+  By default, Algokit will scan for network-prefixed `.env` variables (e.g., `.env.localnet`), which can be particularly useful when relying on the [Algokit deploy command](https://github.com/algorandfoundation/algokit-cli/blob/deploy-command/docs/features/deploy.md). If no such prefixed files are located, Algokit will then attempt to load default `.env` files. This functionality provides greater flexibility for different network configurations.
+
+- `poetry`: If your Python project uses Poetry for dependency management, the `poetry` command installs Poetry (if not present) and runs `poetry install` in the current working directory to install Python dependencies.
+- `npm`: If you're developing a JavaScript or TypeScript project, the `npm` command runs npm install in the current working directory to install Node.js dependencies.
+- `all`: The `all` command runs all the aforementioned bootstrap sub-commands in the current directory and its subdirectories. This command is a comprehensive way to ensure all project dependencies and environment variables are properly set up.
+
+### Predefined Copier Answers
+
+When initializing a new project, Copier can prompt the user for input, which is then passed to the template as variables. This is useful for customizing the new project based on user input.
+
+Example:
+
+```yaml
+# copier.yaml
+project_name:
+  type: str
+  help: What is the name of this project.
+  placeholder: "algorand-app"
+```
+
+This would prompt the user for the project name, and the input can then be used in the template using the Jinja syntax `{{ project_name }}`.
+
+#### Default Behaviors
+
+When creating an AlgoKit template, there are a few default behaviors that you can expect to be provided by algokit-cli itself without introducing any extra code to your templates:
+
+- **Git**: If Git is installed on the user's system and the user's working directory is a Git repository, AlgoKit CLI will commit the newly created project as a new commit in the repository. This feature helps to maintain a clean version history for the project. If you wish to add a specific commit message for this action, you can specify a `commit_message` in the `_commit` option in your `copier.yaml` file.
+
+- **VSCode**: If the user has Visual Studio Code (VSCode) installed and the path to VSCode is added to their system's PATH, AlgoKit CLI will automatically open the newly created VSCode window unless user provides specific flags into the init command.
+
+- **Bootstrap**: AlgoKit CLI is equipped to execute a bootstrap script after a project has been initialized. This script, included in AlgoKit templates, can be automatically run to perform various setup tasks, such as installing dependencies or setting up databases. This is managed by AlgoKit CLI and not within the user-created codebase. By default, if a `bootstrap` task is defined in the `copier.yaml`, AlgoKit CLI will execute it, unless the user opts out during the prompt.
+
+By combining predefined Copier answers with these default behaviors, you can create a smooth, efficient, and intuitive initialization experience for the users of your template.
+
+### Executing Python Tasks in Templates
+
+If you need to use Python scripts as tasks within your Copier templates, ensure that you have Python installed on the host machine.
+By convention, AlgoKit automatically detects the Python installation on your machine and fills in the `python_path` variable accordingly.
+This process ensures that any Python scripts included as tasks within your Copier templates will execute using the system's Python interpreter.
+It's important to note that the use of `_copier_python` is not recommended. Here's an example of specifying a Python script execution in your `copier.yaml` without needing to explicitly use `_copier_python`:
+
+```yaml
+- "{{ python_path }} your_python_script.py"
+```
+
+If you'd like your template to be backwards compatible with versions of `algokit-cli` older than `v1.11.3` when executing custom python scripts via `copier` tasks, you can use a conditional statement to determine the Python path:
+
+```yaml
+- "{{ python_path if python_path else _copier_python }} your_python_script.py"
+# _copier_python above is used for backwards compatibility with versions < v1.11.3 of the algokit cli
+```
+
+And to define `python_path` in your Copier questions:
+
+```yaml
+# Auto determined by algokit-cli from v1.11.3 to allow execution of python script
+# in binary mode.
+python_path:
+  type: str
+  help: Path to the sys.executable.
+  when: false
+```
+
+### Working with Generators
+
+After mastering the use of `copier` and building your templates based on the official AlgoKit template repositories, you can enhance your proficiency by learning to define `custom generators`. Essentially, generators are smaller-scope `copier` templates designed to provide additional functionality after a project has been initialized from the template.
+
+For example, the official [`algokit-python-template`](https://github.com/algorandfoundation/algokit-python-template/tree/main/template_content) incorporates a generator in the `.algokit/generators` directory. This generator can be utilized to execute auxiliary tasks on AlgoKit projects that are initiated from this template, like adding new smart contracts to an existing project. For a comprehensive understanding, please consult the [`architecture decision record`](../architecture-decisions/2023-07-19_advanced_generate_command.md) and [`algokit generate documentation`](../features/generate.md).
+
+#### How to Create a Generator
+
+Outlined below are the fundamental steps to create a generator. Although `copier` provides complete autonomy in structuring your template, you may prefer to define your generator to meet your specific needs. Nevertheless, as a starting point, we suggest:
+
+1. Generate a new directory hierarchy within your template directory under the `.algokit/generators` folder (this is merely a suggestion, you can define your custom path if necessary and point to it via the algokit.toml file).
+2. Develop a `copier.yaml` file within the generator directory and outline the generator's behavior. This file bears similarities with the root `copier.yaml` file in your template directory, but it is exclusively for the generator. The `tasks` section of the `copier.yaml` file is where you can determine the generator's behavior. Here's an example of a generator that copies the `smart-contract` directory from the template to the current working directory:
+
+```yaml
+_task:
+  - "echo '==== Successfully initialized new smart contract 🚀 ===='"
+
+contract_name:
+  type: str
+  help: Name of your new contract.
+  placeholder: "my-new-contract"
+  default: "my-new-contract"
+
+_templates_suffix: ".j2"
+```
+
+Note that `_templates_suffix` must be different from the `_templates_suffix` defined in the root `copier.yaml` file. This is because the generator's `copier.yaml` file is processed separately from the root `copier.yaml` file.
+
+3. Develop your `generator` copier content and, when ready, test it by initiating a new project for your template and executing the generator command:
+
+```bash
+algokit generate
+```
+
+This should dynamically load and display your generator as an optional `cli` command that your template users can execute.
+
+## Recommendations
+
+- **Modularity**: Break your templates into modular components that can be combined in different ways.
+- **Documentation**: Include README files and comments in your templates to explain how they should be used.
+- **Versioning**: Use `.algokit.toml` to specify the minimum compatible version of AlgoKit.
+- **Testing**: Include test configurations and scripts in your templates to encourage testing best practices.
+- **Linting and Formatting**: Integrate linters and code formatters in your templates to ensure code quality.
+- **Algokit Principle**: for details on generic principles on designing templates refer to [algokit design principles](https://github.com/algorandfoundation/algokit-cli/blob/main/docs/algokit.md#guiding-principles).
+
+## Conclusion
+
+Creating custom templates in AlgoKit is a powerful way to streamline your development workflow for Algorand smart contracts, whether you are using Python or TypeScript. Leveraging Copier and Jinja for templating, and incorporating best practices for modularity, documentation, and coding standards, can result in robust, flexible, and user-friendly templates that can be a valuable asset to both your own projects and the broader Algorand community.
+
+Happy coding!

package/dist/resources/knowledge/taxonomy/algokit:cli:tutorials:intro.md

@@ -0,0 +1,171 @@
+# AlgoKit Quick Start Tutorial
+
+AlgoKit is the primary tool used by the Algorand community to develop smart contracts on the Algorand blockchain. It provides the capabilities to develop, test and deploy Algorand smart contracts within minutes! This guide is intended to help you setup AlgoKit and to start developing your application.
+
+## Quick start videos 📹
+
+If you prefer videos, take a look at this 10 minute guide to getting started.
+
+[![Learn How to Build on Algorand in 10 Minutes](../imgs/algokit-intro-video-thumbnail.jpg)](https://www.youtube.com/embed/dow6U8DxOGc)
+
+Detailed video guides for both [Windows](https://www.youtube.com/embed/22RvINnZsRo) and [Mac](https://www.youtube.com/embed/zsurtpCGmgE) are also available.
+
+> Please note, the videos above are to be refreshed to cover v2.0 features. For now, its best to follow the instructions below to get started.
+
+## Prequisites ✅
+
+This guide presents installing AlgoKit using an OS agnostic procedure. For OS specific instructions take a look that the [AlgoKit install](https://github.com/algorandfoundation/algokit-cli/blob/main/README.md#install) guide.
+
+Before proceeding, ensure you have the following components installed:
+
+- [Python 3.10](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://docs.docker.com/desktop/install/mac-install/) (or [Podman](https://podman.io/getting-started/installation/), see [details](../features/localnet.md#podman-support))
+- [VSCode](https://code.visualstudio.com/download)
+
+## Install AlgoKit 🛠
+
+To install AlgoKit, run the following command from a terminal.
+
+```shell
+pipx install algokit
+```
+
+After the installation completes, **restart the terminal**.
+
+For more detailed installation documentation, see the [official installation guide](https://github.com/algorandfoundation/algokit-cli#install).
+
+> Please note, `pipx` is only one of the supported installation methods. You can also install AlgoKit via `brew` and _soon_ `winget` and `snap` as pre-build binaries. Refer to the official installation guide.
+
+## 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.3 # or higher
+```
+
+## Start a LocalNet 🌐
+
+AlgoKit supports using a [local version of the Algorand blockchain](../features/localnet.md). 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 see 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. The templates are basic starter applications for various Algorand development scenarios. To read more about templates checkout AlgoKit detailed documentation.
+
+For now we'll use the `python` template, which is a lightweight starting point for learning Algorand smart contract development using Algorand Python. You can initialize a project using this template by running:
+
+```shell
+algokit init -t python -a preset_name "starter"
+```
+
+Next, you will be prompted for the name of your project. Finally, select the default value for the rest of the prompts (enter).
+
+Once finished, (if you have it installed) VS Code should automatically be opened with the initialised project and you will be prompted to install appropriate VS Code extensions. This starter app will contain one smart contract (built using the [Algorand Python](https://algorandfoundation.github.io/puya/) language) named `contract.py`, in the `smart_contracts/hello_world` folder, with one method (`hello`) that takes a `String` and returns a `String`. Notice that within the contract folder, there is a `deploy_config.py` which defines the parameters for deployment of your smart contract to the target chain (Algorand TestNet, Algorand MainNet, Algorand LocalNet or else).
+
+![AlgoKit Playground Contract](../imgs/algokitplayground.png)
+
+## AlgoKit Project structure 🏗
+
+The structure of your fresh algokit project instance will look similar to below:
+
+```bash
+.
+├── .algokit.toml # Configuration for AlgoKit projects in the workspace.
+├── README.md # Quick start guide for the AlgoKit Workspace.
+├── {your_workspace|project_name}.code-workspace
+└── projects
+    └── {your_project_name} # Root directory for the smart contract project. To add more projects into your algokit workspace run 'algokit init' from the root of your workspace repository.
+        ├── README.md # Quick start on Algorand Python smart contract template based project.
+        ├── .algokit # Hidden folder for AlgoKit AVM debugger and custom generators.
+        ├── .algokit.toml # Project-specific commands and custom generator references.
+        ├── poetry.lock
+        ├── poetry.toml # Dependency definitions for {your_project_name}.
+        ├── pyproject.toml # Project definitions for {your_project_name}.
+        └── smart_contracts
+            ├── README.md # Guide for adding new smart contracts.
+            ├── ...
+            ├── hello_world # Contract logic for 'hello_world'.
+            │   ├── contract.py # Contract logic.
+            │   └── deploy_config.py # Deployment logic for 'hello_world'.
+            └── helpers # Helper functions for contract build and deployment.
+```
+
+Additionally, each official smart contract template includes an interactive codespace walkthrough powered by [CodeTour](https://marketplace.visualstudio.com/items?itemName=vsls-contrib.codetour).
+
+To start the interactive walkthrough, install the extension and click on the green play button in the left bottom corner of the `Explorer` pane as demonstrated on the screenshot below (See `Getting Started with Your AlgoKit Project`).
+
+![CodeTour Play Button](../imgs/algokitcodetour.png)
+
+Upon execution, the walkthrough will guide you through the key components of your fresh AlgoKit project, which is an important prerequisite to learn before running and deploying your first smart contract. Certainly, not because its hard to learn, but because it will save you a lot of time and effort having the correct foundations.
+
+## Run the Demo Application 🏃‍♂️
+
+Once the `Algorand Python` based project is created, you can get started by building and deploying your first smart contract. There are a few possible ways to do so as demonstrated on the following video.
+
+[![Watch the video](https://ipfs.algonode.xyz/ipfs/Qmc9mRaPoDyhUFmek4ETxVfKUKzUg9pf3Tss5xwkBGdQis)](https://ipfs.algonode.xyz/ipfs/Qma6gNqxsSFc9Jbh8kBTZyVLv5gqFj1xnrsjoeT6MAAwCw/)
+
+The App ID of the deployed contract and its Algorand address is displayed, followed by the message returned from the smart contract call (`Hello, Python`).
+
+1. Start LocalNet
+2. Build the smart contract. Notice how a folder named `artifacts` is created with the [AVM (Algorand Virtual Machine)](https://developer.algorand.org/docs/get-details/dapps/avm/) related artifacts for deploying your smart contract.
+3. Deploy and call the `HelloWorld` smart contract (from `contract.py` file).
+
+After execution, the `App ID` of the deployed contract and its Algorand address are displayed, followed by the message returned from the smart contract call (`Hello, world`).
+
+At this point you have deployed a simple contract to a LocalNet Algorand network (running in your Docker environment) and called it successfully!
+
+Additionally, you can find the native AVM related artifacts and the appropriate smart contract manifest JSON files have been output to the `artifacts` folder. Note that in this example, AVM bytecode is compiled using the `PuyaPy` compiler, which is what `Algorand Python` relies on to compile your Python smart contract code to TEAL ([Transaction Execution Approval Language](https://developer.algorand.org/docs/get-details/dapps/avm/teal/)).
+
+### Using AlgoKit CLI to build and deploy contracts 🛠️
+
+When using official AlgoKit templates via `algokit init`, you can manage your projects using the AlgoKit CLI at the convenience of your terminal.
+
+For example, to achieve the same results as in the demo earlier, build and deploy the `HelloWorld` contract from the `contract.py` file by running the following command from the terminal:
+
+```shell
+algokit project run build
+```
+
+This command will recompile your python contracts from `contract.py` and produce the necessary artefacts for deploying your contract.
+
+```shell
+algokit project deploy localnet
+```
+
+This will then deploy to your LocalNet instance and display the same output as in the earlier demo.
+
+> Please note, as highlighted in the [structure](#algokit-project-structure) section above, the `project run ...` commands are defined in the respective `.algokit.toml` file under `[project]` sections.
+
+## Next steps 🚶‍♂️
+
+We have only covered a tiny fraction of the capabilities of the AlgoKit CLI and its related ecosystem of templates and utilities for an efficient developer experience.
+
+- To get the most out of `AlgoKit`, we recommend to get started with learning more about AlgoKit and what you can do with it by checking out our extensive [AlgoKit CLI documentation](../algokit.md).
+- Explore the `README.md` files at the root of any project created via `algokit init`. All official AlgoKit templates include detailed quick started guides, an interactive code tour and various presets which can be customized to your needs.
+- To learn more about `Algorand Python`, take a look at the [documentation](https://algorandfoundation.github.io/puya/).
+- To learn more about the commands demonstrated in this tutorial, refer to [`init`](../features/init.md) and [`project`](../features/project.md) to get a comprehensive understanding of their further capabilities.
+- If you'd like to learn more on structuring your `AlgoKit Project` as a monorepo, refer to `workspace` mode as described in [`init`](../features/init.md#workspaces-vs-standalone-projects). You can also pass the `--no-workspace` flag to setup a standalone algokit project, if preferred.
+- If you'd like to **create your own** `AlgoKit` template, refer to the [template tutorial](./algokit-template.md).
+- 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/algokit:cli:tutorials:smart-contracts.md

@@ -0,0 +1,14 @@
+# Smart Contract Tutorial
+
+_TODO_
+
+[mental model image]
+
+- Lifecycle
+- Deploy-time immutability and permanence controls
+- Deployment automation
+- ...
+
+## Next steps
+
+- Read the architecture decision

package/dist/resources/knowledge/taxonomy/algokit:docs:testnet_api.md

@@ -0,0 +1,157 @@
+# AlgoKit TestNet Dispenser API Documentation
+
+## Overview
+
+The AlgoKit TestNet Dispenser API provides functionalities to interact with the Dispenser service. This service enables users to fund and refund assets.
+
+## Base URLs
+
+-   **Production Instance (publicly available):**
+    `https://api.dispenser.algorandfoundation.tools`
+
+## Authorization
+
+All API endpoints require an `Authorization` header containing a valid JWT token.
+
+> Refer to [algokit dispenser](https://github.com/algorandfoundation/algokit-cli/blob/main/docs/features/dispenser.md#login) command documentation to learn how to obtain a valid JWT token by executing `algokit dispenser login --ci` command.
+
+## Endpoints
+
+### 1. `POST /fund/{assetID}`
+
+Funds a user's wallet with a specified asset.
+
+**URL Parameters:**
+
+| Parameter | Description                                                              |
+| --------- | ------------------------------------------------------------------------ |
+| `assetID` | ID of the asset for which the funding limit is sought. Use `0` for ALGO. |
+
+**Request Body:**
+
+| Parameter | Description                         |
+| --------- | ----------------------------------- |
+| receiver  | Address of the wallet to be funded. |
+| amount    | Amount of the asset to be funded.   |
+
+**Response Body:**
+
+```json
+{
+    "txID": "string",
+    "amount": "number"
+}
+```
+
+| Parameter | Description                                                              |
+| --------- | ------------------------------------------------------------------------ |
+| `txID`    | ID of the fund transaction from the dispenser to the requesting address. |
+| `amount`  | Amount of the asset to be funded.                                        |
+
+### 2. `GET /fund/{assetID}/limit`
+
+Fetches the funding limit for a specified asset.
+
+**URL Parameters:**
+
+| Parameter | Description                                                              |
+| --------- | ------------------------------------------------------------------------ |
+| `assetID` | ID of the asset for which the funding limit is sought. Use `0` for ALGO. |
+
+**Response Body:**
+
+```json
+{
+    "amount": "number"
+}
+```
+
+| Parameter | Description                                         |
+| --------- | --------------------------------------------------- |
+| `amount`  | Current daily amount limit for the requested asset. |
+
+### 3. `POST /refund`
+
+Allows refunding a transaction. A status code `200` indicates a successful refund.
+
+**Request Body:**
+
+```json
+{
+    "refundTransactionID": "string"
+}
+```
+
+| Parameter           | Description                   |
+| ------------------- | ----------------------------- |
+| refundTransactionID | ID of the refund transaction. |
+
+---
+
+## Error Handling
+
+If an error occurs, the API returns a specific status and error code.
+
+**Error Codes Table:**
+
+| Status Code | Error Code               | Description                       |
+| ----------- | ------------------------ | --------------------------------- |
+| 400         | `dispenser_out_of_funds` | Dispenser is out of funds         |
+| 403         | `forbidden`              | Dispenser access is forbidden     |
+| 400         | `fund_limit_exceeded`    | Dispenser fund limit exceeded     |
+| 400         | `missing_params`         | Missing required input parameters |
+| 403         | `authorization_error`    | Authorization error               |
+| 400         | `txn_expired`            | Transaction expired               |
+| 400         | `txn_invalid`            | Invalid transaction               |
+| 400         | `txn_already_processed`  | Transaction already processed     |
+| 404         | `txn_not_found`          | Transaction not found             |
+| 400         | `invalid_asset`          | Unsupported asset ID              |
+| 500         | `unexpected_error`       | Unexpected internal error         |
+
+For more detailed error information, please refer to the error code in the response body.
+
+## Common Error Response
+
+All error responses have the following common format:
+
+```json
+{
+    "code": "string",
+    "message": "string"
+}
+```
+
+| Error Parameter | Description                                       |
+| --------------- | ------------------------------------------------- |
+| `code`          | Error code as described in the error codes table. |
+| `message`       | Error message.                                    |
+
+### `missing_params` error response
+
+```json
+{
+    "code": "missing_params",
+    "message": "string",
+    "parameters": ["string"]
+}
+```
+
+| Error Parameter | Description                 |
+| --------------- | --------------------------- |
+| `parameters`    | List of missing parameters. |
+
+### `fund_limit_exceeded` error response
+
+```json
+{
+    "code": "dispenser_fund_limit_exceeded",
+    "message": "string",
+    "limit": "number",
+    "resetsAt": "string"
+}
+```
+
+| Error Parameter | Description                                         |
+| --------------- | --------------------------------------------------- |
+| `limit`         | Current daily amount limit for the requested asset. |
+| `resetsAt`      | Timestamp when the daily limit resets.              |

package/dist/resources/knowledge/taxonomy/algokit:lora:README.md

@@ -0,0 +1,61 @@
+<div align="center">
+<a href="https://github.com/algorandfoundation/algokit-lora"><img src="https://bafybeigi4s7alfr7fdir5mdi6xzmichoubnwndol4ts6ktz52y3qvd5soe.ipfs.nftstorage.link/" width=60%></a>
+</div>
+
+<p align="center">
+    <a target="_blank" href="https://github.com/algorandfoundation/algokit-lora/blob/main/README.md"><img src="https://img.shields.io/badge/docs-repository-00dc94?logo=github&style=flat.svg" /></a>
+    <a target="_blank" href="https://developer.algorand.org/algokit/"><img src="https://img.shields.io/badge/learn-AlgoKit-00dc94?logo=algorand&mac=flat.svg" /></a>
+    <a target="_blank" href="https://github.com/algorandfoundation/algokit-lora"><img src="https://img.shields.io/github/stars/algorandfoundation/algokit-lora?color=00dc94&logo=star&style=flat" /></a>
+    <a target="_blank" href="https://developer.algorand.org/algokit/"><img  src="https://api.visitorbadge.io/api/visitors?path=https%3A%2F%2Fgithub.com%2Falgorandfoundation%2Falgokit-lora&countColor=%2300dc94&style=flat" /></a>
+</p>
+
+---
+
+Algorand AlgoKit lora is a live on-chain resource analyzer, that enables developers to explore and interact with a configured Algorand network in a visual way.
+
+## What is lora?
+
+AlgoKit lora is a powerful visual tool designed to streamline the Algorand local development experience.
+It acts as both a network explorer and a tool for building and testing your Algorand applications.
+
+You can access lora by visiting [https://lora.algokit.io](https://lora.algokit.io) in your browser or by running `algokit explore` when you have the [AlgoKit CLI](https://github.com/algorandfoundation/algokit-cli) installed.
+
+## Why did we build lora?
+
+An explorer is an essential tool for making blockchain data accessible and enables users to inspect and understand on-chain activities. Without these tools, it's difficult to interpret data or gather the information and insights to fully harness the potential of the blockchain. Therefore it makes sense to have a high quality, officially supported and fully open-source tool available to the community.
+
+Before developing lora, we evaluated the existing tools in the community, but none fully met our desires.
+
+As part of this evaluation we came up with several design goals, which are:
+
+- **Developer-Centric User Experience**: Offer a rich user experience tailored for developers, with support for LocalNet, TestNet, and MainNet.
+- **Open Source**: Fully open source and actively maintained.
+- **Operationally Simple**: Operate using algod and indexer directly, eliminating the need for additional setup, deployment, or maintenance.
+- **Visualize Complexity**: Enable Algorand developers to understand complex transactions and transaction groups by visually representing them.
+- **Contextual Linking**: Allow users to see live and historical transactions in the context of related accounts, assets, or applications.
+- **Performant**: Ensure a fast and seamless experience by minimizing requests to upstream services and utilizing caching to prevent unnecessary data fetching. Whenever possible, ancillary data should be fetched just in time with minimal over-fetching.
+- **Support the Learning Journey**: Assist developers in discovering and learning about the Algorand ecosystem.
+- **Seamless Integration**: Use and integrate seamlessly with the existing AlgoKit tools and enhance their usefulness.
+- **Local Installation**: Allow local installation alongside the AlgoKit CLI and your existing dev tools.
+
+## Key features
+
+- Explore blocks, transactions, transaction groups, assets, accounts and applications on LocalNet, TestNet or MainNet.
+- Visualise and understand complex transactions and transaction groups with the visual transaction view.
+- View blocks in real time as they are produced on the connected network.
+- Monitor and inspect real-time transactions related to an asset, account, or application with the live transaction view.
+- Review historical transactions related to an asset, account, or application through the historical transaction view.
+- Access detailed asset information and metadata when the asset complies with one of the ASA ARCs.
+- Connected to your Algorand wallet and perform context specific actions.
+- Fund an account in LocalNet or TestNet.
+- Visually deploy, populate, simulate and call an app by uploading an ARC-4, ARC-32 or ARC-56 app spec via App lab.
+- Craft, simulate and send transaction groups using Transaction wizard.
+- Seamless integration into the existing AlgoKit ecosystem.
+
+## Roadmap
+
+- Installable app with tighter AlgoKit tooling integration.
+
+## Contributing
+
+See the [contributing page](./CONTRIBUTING.md) to learn about making improvements to the CLI tool itself, including developer setup instructions.

package/dist/resources/knowledge/taxonomy/algokit:utils:python:README.md

@@ -0,0 +1,35 @@
+# AlgoKit Python Utilities
+
+A set of core Algorand utilities written in Python and released via PyPi that make it easier to build solutions on Algorand. 
+This project is part of [AlgoKit](https://github.com/algorandfoundation/algokit-cli).
+
+The goal of this library is to provide intuitive, productive utility functions that make it easier, quicker and safer to build applications on Algorand. 
+Largely these functions wrap the underlying Algorand SDK, but provide a higher level interface with sensible defaults and capabilities for common tasks.
+
+> **Note**
+> If you prefer TypeScript there's an equivalent [TypeScript utility library](https://github.com/algorandfoundation/algokit-utils-ts).
+
+[Install](https://github.com/algorandfoundation/algokit-utils-py#install) | [Documentation](https://algorandfoundation.github.io/algokit-utils-py/html/index.html)
+
+## Install
+
+This library can be installed using pip, e.g.:
+
+```
+pip install algokit-utils
+```
+
+## Guiding principles
+
+This library follows the [Guiding Principles of AlgoKit](https://github.com/algorandfoundation/algokit-cli/blob/main/docs/algokit.md#guiding-principles).
+
+## Contributing
+
+This is an open source project managed by the Algorand Foundation. 
+See the [AlgoKit contributing page](https://github.com/algorandfoundation/algokit-cli/blob/main/CONTRIBUTING.MD) to learn about making improvements.
+
+To successfully run the tests in this repository you need to be running LocalNet via [AlgoKit](https://github.com/algorandfoundation/algokit-cli):
+
+```
+algokit localnet start
+```