@goplausible/algorand-mcp 3.0.7

package/dist/resources/knowledge/taxonomy/devportal-code-examples:README.md

@@ -0,0 +1,31 @@
+# Algorand Developer Portal Code Examples
+
+Welcome to your new AlgoKit project!
+
+This is your workspace root. A `workspace` in AlgoKit is an orchestrated collection of standalone projects (backends, smart contracts, frontend apps and etc).
+
+By default, `projects_root_path` parameter is set to `projects`. Which instructs AlgoKit CLI to create a new directory under `projects` directory when new project is instantiated via `algokit init` at the root of the workspace.
+
+## Prerequisites
+- [Install AlgoKit](https://github.com/algorandfoundation/algokit-cli/tree/main?tab=readme-ov-file#install)
+- Install [Docker](https://www.docker.com/products/docker-desktop/)
+- Install [Node.JS / npm](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm)
+
+## Project Setup
+- Run `algokit project bootstrap all` from the root of this repository to bootstrap all subprojects under the `projects` folder.
+- Open Docker Desktop and then launch AlgoKit localnet by running `algokit localnet start`
+
+## Getting Started
+
+To get started refer to `README.md` files in respective sub-projects in the `projects` directory.
+
+To learn more about algokit, visit [documentation](https://github.com/algorandfoundation/algokit-cli/blob/main/docs/algokit.md).
+
+### GitHub Codespaces
+
+To get started execute:
+
+1. `algokit generate devcontainer` - invoking this command from the root of this repository will create a `devcontainer.json` file with all the configuration needed to run this project in a GitHub codespace. [Run the repository inside a codespace](https://docs.github.com/en/codespaces/getting-started/quickstart) to get started.
+2. `algokit init` - invoke this command inside a github codespace to launch an interactive wizard to guide you through the process of creating a new AlgoKit project
+
+Powered by [Copier templates](https://copier.readthedocs.io/en/stable/).

package/dist/resources/knowledge/taxonomy/devportal-code-examples:projects:python-contract-examples:README.md

@@ -0,0 +1,155 @@
+# python-contract-examples
+
+This project has been generated using AlgoKit. See below for default getting started instructions.
+
+# Setup
+
+### Pre-requisites
+
+- [Python 3.12](https://www.python.org/downloads/) or later
+- [Docker](https://www.docker.com/) (only required for LocalNet)
+
+> For interactive tour over the codebase, download [vsls-contrib.codetour](https://marketplace.visualstudio.com/items?itemName=vsls-contrib.codetour) extension for VS Code, then open the [`.codetour.json`](./.tours/getting-started-with-your-algokit-project.tour) file in code tour extension.
+
+### Initial Setup
+
+#### 1. Clone the Repository
+Start by cloning this repository to your local machine.
+
+#### 2. Install Pre-requisites
+Ensure the following pre-requisites are installed and properly configured:
+
+- **Docker**: Required for running a local Algorand network. [Install Docker](https://www.docker.com/).
+- **AlgoKit CLI**: Essential for project setup and operations. Install the latest version from [AlgoKit CLI Installation Guide](https://github.com/algorandfoundation/algokit-cli#install). Verify installation with `algokit --version`, expecting `2.0.0` or later.
+
+#### 3. Bootstrap Your Local Environment
+Run the following commands within the project folder:
+
+- **Install Poetry**: Required for Python dependency management. [Installation Guide](https://python-poetry.org/docs/#installation). Verify with `poetry -V` to see version `1.2`+.
+- **Setup Project**: Execute `algokit project bootstrap all` to install dependencies and setup a Python virtual environment in `.venv`.
+- **Configure environment**: Execute `algokit generate env-file -a target_network localnet` to create a `.env.localnet` file with default configuration for `localnet`.
+- **Start LocalNet**: Use `algokit localnet start` to initiate a local Algorand network.
+
+### Development Workflow
+
+#### Terminal
+Directly manage and interact with your project using AlgoKit commands:
+
+1. **Build Contracts**: `algokit project run build` compiles all smart contracts. You can also specify a specific contract by passing the name of the contract folder as an extra argument.
+For example: `algokit project run build -- hello_world` will only build the `hello_world` contract.
+2. **Deploy**: Use `algokit project deploy localnet` to deploy contracts to the local network. You can also specify a specific contract by passing the name of the contract folder as an extra argument.
+For example: `algokit project deploy localnet -- hello_world` will only deploy the `hello_world` contract.
+
+#### VS Code 
+For a seamless experience with breakpoint debugging and other features:
+
+1. **Open Project**: In VS Code, open the repository root.
+2. **Install Extensions**: Follow prompts to install recommended extensions.
+3. **Debugging**:
+   - Use `F5` to start debugging.
+   - **Windows Users**: Select the Python interpreter at `./.venv/Scripts/python.exe` via `Ctrl/Cmd + Shift + P` > `Python: Select Interpreter` before the first run.
+
+#### JetBrains IDEs
+While primarily optimized for VS Code, JetBrains IDEs are supported:
+
+1. **Open Project**: In your JetBrains IDE, open the repository root.
+2. **Automatic Setup**: The IDE should configure the Python interpreter and virtual environment.
+3. **Debugging**: Use `Shift+F10` or `Ctrl+R` to start debugging. Note: Windows users may encounter issues with pre-launch tasks due to a known bug. See [JetBrains forums](https://youtrack.jetbrains.com/issue/IDEA-277486/Shell-script-configuration-cannot-run-as-before-launch-task) for workarounds.
+
+## AlgoKit Workspaces and Project Management
+This project supports both standalone and monorepo setups through AlgoKit workspaces. Leverage [`algokit project run`](https://github.com/algorandfoundation/algokit-cli/blob/main/docs/features/project/run.md) commands for efficient monorepo project orchestration and management across multiple projects within a workspace.
+
+## AlgoKit Generators
+
+This template provides a set of [algokit generators](https://github.com/algorandfoundation/algokit-cli/blob/main/docs/features/generate.md) that allow you to further modify the project instantiated from the template to fit your needs, as well as giving you a base to build your own extensions to invoke via the `algokit generate` command.
+
+### Generate Smart Contract 
+
+By default the template creates a single `HelloWorld` contract under inner_transactions folder in the `smart_contracts` directory. To add a new contract:
+
+1. From the root of the project (`../`) execute `algokit generate smart-contract`. This will create a new starter smart contract and deployment configuration file under `{your_contract_name}` subfolder in the `smart_contracts` directory.
+2. Each contract potentially has different creation parameters and deployment steps. Hence, you need to define your deployment logic in `deploy_config.py`file.
+3. `config.py` file will automatically build all contracts in the `smart_contracts` directory. If you want to build specific contracts manually, modify the default code provided by the template in `config.py` file.
+
+> Please note, above is just a suggested convention tailored for the base configuration and structure of this template. The default code supplied by the template in `config.py` and `index.ts` (if using ts clients) files are tailored for the suggested convention. You are free to modify the structure and naming conventions as you see fit.
+
+### Generate '.env' files
+
+By default the template instance does not contain any env files. Using [`algokit project deploy`](https://github.com/algorandfoundation/algokit-cli/blob/main/docs/features/project/deploy.md) against `localnet` | `testnet` | `mainnet` will use default values for `algod` and `indexer` unless overwritten via `.env` or `.env.{target_network}`. 
+
+To generate a new `.env` or `.env.{target_network}` file, run `algokit generate env-file`### Continuous Integration / Continuous Deployment (CI/CD)
+
+This project uses [GitHub Actions](https://docs.github.com/en/actions/learn-github-actions/understanding-github-actions) to define CI/CD workflows, which are located in the [.github/workflows](`../../.github/workflows`) folder.
+
+> Please note, if you instantiated the project with --workspace flag in `algokit init` it will automatically attempt to move the contents of the `.github` folder to the root of the workspace.
+
+### AlgoKit Workspaces
+
+To define custom `algokit project run` commands refer to [documentation](https://github.com/algorandfoundation/algokit-cli/blob/main/docs/features/project/run.md). This allows orchestration of commands spanning across multiple projects within an algokit workspace based project (monorepo).
+
+### Debugging Smart Contracts
+
+This project is optimized to work with AlgoKit AVM Debugger extension. To activate it:
+Refer to the commented header in the `__main__.py` file in the `smart_contracts` folder.
+
+If you have opted in to include VSCode launch configurations in your project, you can also use the `Debug TEAL via AlgoKit AVM Debugger` launch configuration to interactively select an available trace file and launch the debug session for your smart contract.
+
+For information on using and setting up the `AlgoKit AVM Debugger` VSCode extension refer [here](https://github.com/algorandfoundation/algokit-avm-vscode-debugger). To install the extension from the VSCode Marketplace, use the following link: [AlgoKit AVM Debugger extension](https://marketplace.visualstudio.com/items?itemName=algorandfoundation.algokit-avm-vscode-debugger).
+
+#### Setting up GitHub for CI/CD workflow and TestNet deployment
+
+  1. Every time you have a change to your smart contract, and when you first initialize the project you need to [build the contract](#initial-setup) and then commit the `smart_contracts/artifacts` folder so the [output stability](https://github.com/algorandfoundation/algokit-cli/blob/main/docs/articles/output_stability.md) tests pass
+  2. Decide what values you want to use for the `allow_update`, `allow_delete` and the `on_schema_break`, `on_update` parameters specified in [`contract.py`](./smart_contracts/inner_transactions/contract.py).
+     When deploying to LocalNet these values are both set to allow update and replacement of the app for convenience. But for non-LocalNet networks
+     the defaults are more conservative.
+     These default values will allow the smart contract to be deployed initially, but will not allow the app to be updated or deleted if is changed and the build will instead fail.
+     To help you decide it may be helpful to read the [AlgoKit Utils app deployment documentation](https://github.com/algorandfoundation/algokit-utils-ts/blob/main/docs/capabilities/app-deploy.md) or the [AlgoKit smart contract deployment architecture](https://github.com/algorandfoundation/algokit-cli/blob/main/docs/architecture-decisions/2023-01-12_smart-contract-deployment.md#upgradeable-and-deletable-contracts).
+  3. Create a [Github Environment](https://docs.github.com/en/actions/deployment/targeting-different-environments/using-environments-for-deployment#creating-an-environment) named `Test`.
+     Note: If you have a private repository and don't have GitHub Enterprise then Environments won't work and you'll need to convert the GitHub Action to use a different approach. Ignore this step if you picked `Starter` preset.
+  4. Create or obtain a mnemonic for an Algorand account for use on TestNet to deploy apps, referred to as the `DEPLOYER` account.
+  5. Store the mnemonic as a [secret](https://docs.github.com/en/actions/deployment/targeting-different-environments/using-environments-for-deployment#environment-secrets) `DEPLOYER_MNEMONIC`
+     in the Test environment created in step 3.
+  6. The account used to deploy the smart contract will require enough funds to create the app, and also fund it. There are two approaches available here:
+     * Either, ensure the account is funded outside of CI/CD.
+       In Testnet, funds can be obtained by using the [Algorand TestNet dispenser](https://bank.testnet.algorand.network/) and we recommend provisioning 50 ALGOs.
+     * Or, fund the account as part of the CI/CD process by using a `DISPENSER_MNEMONIC` GitHub Environment secret to point to a separate `DISPENSER` account that you maintain ALGOs in (similarly, you need to provision ALGOs into this account using the [TestNet dispenser](https://bank.testnet.algorand.network/)).
+
+#### Continuous Integration
+
+For pull requests and pushes to `main` branch against this repository the following checks are automatically performed by GitHub Actions:
+ - Python dependencies are audited using [pip-audit](https://pypi.org/project/pip-audit/)
+ - Code formatting is checked using [Black](https://github.com/psf/black)
+ - Linting is checked using [Ruff](https://github.com/charliermarsh/ruff)
+ - Types are checked using [mypy](https://mypy-lang.org/)
+- The base framework for testing is [pytest](https://docs.pytest.org/), and the project includes two separate kinds of tests:
+- - `Algorand Python` smart contract unit tests, that are run using [`algorand-python-testing`](https://pypi.org/project/algorand-python-testing/), which are executed in a Python intepreter emulating major AVM behaviour
+- - Python `ApplicationClient` tests that are run against `algokit localnet` and test the behaviour in a real network enviornment
+ - Smart contract artifacts are built
+ - Smart contract artifacts are checked for [output stability](https://github.com/algorandfoundation/algokit-cli/blob/main/docs/articles/output_stability.md).
+ - Smart contract is deployed to a AlgoKit LocalNet instance
+
+> NOTE: By default smart contract artifacts are compiled with `--debug-level` set to 0, to change this, modify the compiler invocation under `smart_contracts/_helpers/build.py`
+
+#### Continuous Deployment
+
+For pushes to `main` branch, after the above checks pass, the following deployment actions are performed:
+  - The smart contract(s) are deployed to TestNet using [AlgoNode](https://algonode.io).
+
+> Please note deployment is also performed via `algokit deploy` command which can be invoked both via CI as seen on this project, or locally. For more information on how to use `algokit deploy` please see [AlgoKit documentation](https://github.com/algorandfoundation/algokit-cli/blob/main/docs/features/deploy.md).
+
+# Tools
+
+This project makes use of Algorand Python to build Algorand smart contracts. The following tools are in use:
+
+- [Algorand](https://www.algorand.com/) - Layer 1 Blockchain; [Developer portal](https://developer.algorand.org/), [Why Algorand?](https://developer.algorand.org/docs/get-started/basics/why_algorand/)
+- [AlgoKit](https://github.com/algorandfoundation/algokit-cli) - One-stop shop tool for developers building on the Algorand network; [docs](https://github.com/algorandfoundation/algokit-cli/blob/main/docs/algokit.md), [intro tutorial](https://github.com/algorandfoundation/algokit-cli/blob/main/docs/tutorials/intro.md)
+- [Algorand Python](https://github.com/algorandfoundation/puya) - A semantically and syntactically compatible, typed Python language that works with standard Python tooling and allows you to express smart contracts (apps) and smart signatures (logic signatures) for deployment on the Algorand Virtual Machine (AVM); [docs](https://github.com/algorandfoundation/puya), [examples](https://github.com/algorandfoundation/puya/tree/main/examples)
+- [AlgoKit Utils](https://github.com/algorandfoundation/algokit-utils-py) - A set of core Algorand utilities that make it easier to build solutions on Algorand.
+- [Poetry](https://python-poetry.org/): Python packaging and dependency management.- [Black](https://github.com/psf/black): A Python code formatter.- [Ruff](https://github.com/charliermarsh/ruff): An extremely fast Python linter.
+
+- [mypy](https://mypy-lang.org/): Static type checker.
+- [pytest](https://docs.pytest.org/): Automated testing.
+- [pip-audit](https://pypi.org/project/pip-audit/): Tool for scanning Python environments for packages with known vulnerabilities.
+- [pre-commit](https://pre-commit.com/): A framework for managing and maintaining multi-language pre-commit hooks, to enable pre-commit you need to run `pre-commit install` in the root of the repository. This will install the pre-commit hooks and run them against modified files when committing. If any of the hooks fail, the commit will be aborted. To run the hooks on all files, use `pre-commit run --all-files`.
+It has also been configured to have a productive dev experience out of the box in [VS Code](https://code.visualstudio.com/), see the [.vscode](./.vscode) folder.
+

package/dist/resources/knowledge/taxonomy/docs:.walletconnect:index.md

@@ -0,0 +1,133 @@
+title: WalletConnect
+
+## What is WalletConnect protocol?
+
+[WalletConnect](https://walletconnect.org/) is an open protocol to communicate securely between mobile wallets and decentralized applications (dApps) using QR code scanning (desktop) or deep linking (mobile); It’s not an app, not a blockchain and has no token. The protocol is implemented directly within the official Algorand Wallet and allows any dApp developer to add it to their application workflows.
+
+## Why should I care?
+
+From an end user standpoint, they really don’t need to understand _how_ it works, but they will need to accept the _connection request_ initiated by the dApp within their mobile wallet. As a dApp developer you’ll want to understand some basics about the protocol for a successful integration and provide a seamless user experience. Algorand provides a [custom WalletConnect schema](./walletconnect-schema.md) and a [quick start guide](#quick-start-for-dapp-devs) for accelerating integrations.
+
+<center>![WalletConnect Header](../../imgs/walletconnect-header.png)</center>
+
+The official Algorand Wallet is among the leading crypto wallets supporting the WalletConnect protocol as the industry standard for secure payment prompts and application call transactions. Importantly, user's private keys never leave their mobile device and are never exposed to connected dApps. Adding a Ledger Nano device to the Algorand Wallet further extends the user's security profile while maintaining connection simplicity enabled by the WalletConnect integration.
+
+## How it works
+
+Communication between the dApp and the mobile wallet (_peers_) happens over a _bridge server_ that relays messages without access to their content. Message contents are symmetrically encrypted through a shared key between the two peers using session data. The connection is initiated by the dApp displaying a QR Code or deep link with a standard WalletConnect URI and is established when the user approves this connection request within their Algorand Wallet. Public bridge servers are maintained by WalletConnect and dApp developers may also deploy their own.
+
+Information exchange between the peers typically consists of an unsigned atomic transaction group from the dApp to the mobile wallet, which is then inspected by the user, signed and returned back to the dApp. The dApp will submit the signed object for confirmation by the Algorand network which will effect balances and state accordingly.
+
+<center>![WalletConnect Header](../../imgs/walletconnect-establishing-connection.png)</center>
+
+## Quick start for dApp devs
+
+The TypeScript sample code below should allow a dApp developer to establish a connection and request a simple payment transaction for signature.
+
+### Install
+
+=== "yarn"
+  ```bash
+  yarn add @walletconnect/client algorand-walletconnect-qrcode-modal algosdk @json-rpc-tools/utils
+  ```
+
+=== "npm"
+  ```bash
+  npm install --save @walletconnect/client algorand-walletconnect-qrcode-modal algosdk @json-rpc-tools/utils
+  ```
+
+!!! Info
+    Developers are encouraged to watch the [walletconnect-monorepo](https://github.com/WalletConnect/walletconnect-monorepo/releases) for new releases. Rebuild and deploy your dApp to utilize new features and performance enhancements. 
+
+### Initiate Connection
+
+```typescript
+import WalletConnect from "@walletconnect/client";
+import QRCodeModal from "algorand-walletconnect-qrcode-modal";
+import algosdk from "algosdk";
+import { formatJsonRpcRequest } from "@json-rpc-tools/utils";
+
+// Create a connector
+const connector = new WalletConnect({
+  bridge: "https://bridge.walletconnect.org", // Required
+  qrcodeModal: QRCodeModal,
+});
+
+// Check if connection is already established
+if (!connector.connected) {
+  // create new session
+  connector.createSession();
+}
+
+// Subscribe to connection events
+connector.on("connect", (error, payload) => {
+  if (error) {
+    throw error;
+  }
+
+  // Get provided accounts
+  const { accounts } = payload.params[0];
+});
+
+connector.on("session_update", (error, payload) => {
+  if (error) {
+    throw error;
+  }
+
+  // Get updated accounts 
+  const { accounts } = payload.params[0];
+});
+
+connector.on("disconnect", (error, payload) => {
+  if (error) {
+    throw error;
+  }
+});
+```
+
+### Sign Transaction
+
+```typescript
+// Draft transaction
+const txn = algosdk.makePaymentTxnWithSuggestedParamsFromObject({
+    from: "ALICEU3WMO5XYJVSODKJSYLFILIXXBEXHKIVSMX7GMGXJAYGFCJKVSQTUE",
+    to: "HZ57J3K46JIJXILONBBZOHX6BKPXEM2VVXNRFSUED6DKFD5ZD24PMJ3MVA",
+    amount: 100000,
+    suggestedParams,
+});
+
+// Sign transaction
+// txns is an array of algosdk.Transaction like below
+// i.e txns = [txn, ...someotherTxns], but we've only built one transaction in our case
+const txns = [txn]
+const txnsToSign = txns.map(txn => {
+  const encodedTxn = Buffer.from(algosdk.encodeUnsignedTransaction(txn)).toString("base64");
+
+  return {
+    txn: encodedTxn,
+    message: 'Description of transaction being signed',
+    // Note: if the transaction does not need to be signed (because it's part of an atomic group
+    // that will be signed by another party), specify an empty singers array like so:
+    // signers: [],
+  };
+});
+
+const requestParams = [txnsToSign];
+
+const request = formatJsonRpcRequest("algo_signTxn", requestParams);
+const result: Array<string | null> = await this.connector.sendCustomRequest(request);
+const decodedResult = result.map(element => {
+  return element ? new Uint8Array(Buffer.from(element, "base64")) : null;
+});
+```
+
+### Close Connection
+
+```TypeScript
+// Delete connector
+connector.killSession();
+```
+
+## Next Steps
+
+A [detailed example](https://github.com/algorand/walletconnect-example-dapp) is offered in React and a [live demo](https://algorand.github.io/walletconnect-example-dapp/) is available on TestNet. 

package/dist/resources/knowledge/taxonomy/docs:.walletconnect:walletconnect-schema.md

@@ -0,0 +1,167 @@
+title: Schema
+
+# Background
+
+- [WalletConnect](https://docs.walletconnect.org/) is an open protocol to communicate securely between mobile wallets and decentralized applications (dApps) using QR code scanning (desktop) or deep linking (mobile). It’s main use case allows users to sign transactions on web apps using a mobile wallet.
+- v1 of WC (currently deployed) has first-party support for Ethereum chains, but it can be extended to other chains through custom message schema. [Binance Chain does this with their custom schema](https://docs.binance.org/guides/concepts/walletconnect.html#protocol-differences).
+
+# Purpose
+
+The purpose of this document is to define a custom WalletConnect schema for Algorand. The schema in this document is based on the [Algorand Foundation’s Wallet Transaction Signing API](https://github.com/algorandfoundation/ARCs/blob/main/ARCs/arc-0001.md), and it attempts to be as similar to that as possible. The main contribution of this document is to define how that schema can be used with WalletConnect.
+
+# Schema
+
+!!! Note
+    All interfaces are defined in TypeScript. These interfaces are designed to be serializable to and from valid JSON objects.
+
+A WalletConnect schema is a set of JSON-RPC 2.0 requests and responses. WalletConnect will send requests to the Algorand Wallet and will receive either signed transactions or failures as responses. All requests adhere to the following structure:
+
+```
+interface JsonRpcRequest {
+  id: number;
+  jsonrpc: "2.0";
+  method: string;
+  params: any[];
+}
+```
+
+A successful request will return a response that adheres to the following structure:
+
+```
+interface JsonRpcResponse {
+  id: number; // will be the same as the request's id
+  jsonrpc: "2.0";
+  result: any;
+}
+```
+
+The Algorand schema consists of the requests and responses below.
+
+## algo_signTxn
+
+This request is used to ask a wallet to sign one or more transactions in an atomic transaction group.
+
+### Request
+
+This request adheres to the following structure:
+
+```
+interface AlgoSignTxnRequest {
+  id: number;
+  jsonrpc: "2.0";
+  method: "algo_signTxn";
+  params: SignTxnParams;
+}
+```
+
+The parameters `SignTxnParams`, are defined as:
+`type SignTxnParams = [WalletTransaction[], SignTxnOpts?];`
+
+!!! Note 
+    `SignTxnParams` is a [tuple with an optional element](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-0.html#optional-elements-in-tuple-types), meaning its length can be 1 or 2.
+
+The first element in the tuple is an array of `WalletTransaction` objects. The length of this array must be between 1 and 16 (inclusive on both ends). Each transaction in the group (even ones not being signed by the wallet) must be an element in this array.
+
+The second element in the tuple is an `SignTxnOpts` object, which is optional.
+
+The `WalletTransaction` and `SignTxnOpts` types are defined as:
+
+```
+interface WalletTransaction {
+  /**
+   * Base64 encoding of the canonical msgpack encoding of a     
+   * Transaction.
+   */
+  txn: string;
+ 
+  /**
+   * Optional authorized address used to sign the transaction when 
+   * the account is rekeyed. Also called the signor/sgnr.
+   */
+  authAddr?: AlgorandAddress;
+ 
+  /**
+   * Optional multisig metadata used to sign the transaction
+   */
+  msig?: MultisigMetadata;
+ 
+  /**
+   * Optional list of addresses that must sign the transactions
+   */
+  signers?: AlgorandAddress[];
+ 
+  /**
+   * Optional message explaining the reason of the transaction
+   */
+  message?: string;
+}
+ 
+interface SignTxnOpts {
+  /**
+   * Optional message explaining the reason of the group of 
+   * transactions.
+   */
+  message?: string;
+  
+  // other options may be present, but are not standard
+}
+```
+
+The above interfaces reference AlgorandAddress and MultisigMetadata types. These are defined as:
+
+```
+/**
+ * AlgorandAddress is a 58-character base32 string that represents an
+ * Algorand address with a checksum.
+ */
+type AlgorandAddress = string;
+ 
+/**
+ * Options for creating and using a multisignature account.
+ */
+interface MultisigMetadata {
+  /**
+   * Multisig version.
+   */
+  version: number;
+ 
+  /**
+   * Multisig threshold value. Authorization requires a subset of 
+   * signatures, equal to or greater than the threshold value.
+   */
+  threshold: number;
+ 
+  /**
+   * List of Algorand addresses of possible signers for this
+   * multisig. Order is important.
+   */
+  addrs: AlgorandAddress[];
+}
+```
+
+A description for each parameter in `WalletTransaction` can be found here: https://github.com/algorandfoundation/ARCs/blob/main/ARCs/arc-0001.md#interface-wallettransaction
+
+### Response
+
+If the wallet approves the request, it will send back the following response:
+
+```
+interface AlgoSignTxnResponse {
+  id: number;
+  jsonrpc: "2.0";
+  result: Array<string | null>;
+}
+```
+
+In this response, result is an array with the same length as the request params. For every integer `i` such that `0 <= i < result.length`:
+
+- If the transaction at index `i` in the group should be signed by the wallet (i.e. `params[0][i].signers` is not an empty array) : `result[i]` will be a base64-encoded string containing the msgpack-encoded signed transaction `params[i].txn`.
+- Otherwise: `result[i]` will be null, since the wallet was not requested to sign this transaction.
+
+If the wallet does not approve signing every transaction whose signature is being requested, the request must fail. A failure like this should be indicated in the rejection message as described [here](https://github.com/algorandfoundation/ARCs/blob/main/ARCs/arc-0001.md#error-standards).
+
+# Future Additions
+
+Possible future additions to the schema may include:
+
+- A request type for wallets to sign a LogicSig program, resulting in a delegated LogicSig spending program for an account.

package/dist/resources/knowledge/taxonomy/docs:README.md

@@ -0,0 +1,12 @@
+# Algorand Developer Documentation (Official)
+
+This is the official repository for the [Algorand Developer Documentation](https://developer.algorand.org/docs/) hosted on the [Algorand Developer Portal](https://developer.algorand.org/).
+
+## Contributing
+Learn how you can contribute in our [Guide to Contributing](./CONTRIBUTING.md).
+
+## License
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+The documentation is licensed under an MIT license. See [LICENSE file](./LICENSE.md) for details.

package/dist/resources/knowledge/taxonomy/docs:scripts:README.md

@@ -0,0 +1,90 @@
+# reformat-all-commands.sh
+
+Calls `reformat.py` and `convert_swagger.py` to populate the "reference-docs" structure. Requires two arguments be passed referencing the source code of _go-algorand_ and _indexer_ respectively:
+
+`./reformat-all-commands.sh $GO_ALGORAND_SRC $INDEXER_SRC`
+
+# reformat.py
+
+Reformats markdown generated by the go spf13/cobra library to work with mkdocs.
+
+Given the `goal` in the path, regenerate the docs from this directory by running:
+```
+rm -rf ../docs/Reference-Docs/goal
+mkdir ../docs/Reference-Docs/goal
+goal generate-docs ../docs/Reference-Docs/goal
+./reformat.py -path ../docs/Reference-Docs/goal -cmd goal
+```
+
+# convert_swagger.py
+
+Given a swagger specfile, generates a markdown file.
+Currently uses `swagger2markup`, with some post processing to make
+the markdown more pleasant with our mkdocs theme.
+
+```
+./convert_swagger.py -specfile ~/algorand/indexer/api/indexer.oas2.json  -target ../docs/reference/rest-apis/indexer.md
+./convert_swagger.py -specfile ~/go/src/github.com/algorand/go-algorand/daemon/kmd/api/swagger.json  -target ../docs/reference/rest-apis/kmd.md
+./convert_swagger.py -specfile ~/go/src/github.com/algorand/go-algorand/daemon/algod/api/algod.oas2.json  -target ../docs/reference/rest-apis/algod.md
+```
+
+# config_json_gen
+
+Used to extract node config options from the go-algorand source. Markdown is written to stdout, warnings are written to stderr. To update the template, edit template.tmpl and rebuild the tool.
+
+Build tool:
+```
+go build .
+```
+
+Run:
+```
+./config_json_gen -path ~/algorand/go-algorand/ > ../../docs/run-a-node/reference/config.md
+```
+
+All in one:
+```
+go run main.go -path ~/algorand/go-algorand/ > ../../docs/run-a-node/reference/config.md
+```
+
+# Code examples
+
+## Example formatting
+
+Examples are all named descriptively and may be referenced in the markdown in multiple places if necessary.
+
+The format for a named example in the docs markdown is:
+```
+<!-- ===LANGSDK_EXAMPLENAME=== -->
+<!-- ===LANGSDK_EXAMPLENAME=== -->
+```
+Running the import script will replace any text between these two tags with the matching example from the SDK repos.
+
+A file containing all examples with descriptions is in `example_tracker/example_list.md`.
+A script that is helpful to track any examples that are missing from languages (or typo'd) is in `example_tracker/list_examples.sh`.
+
+To ensure the language tabs display correctly the markdown must be formatted as follows:
+```
+=== "LanguageName"
+    <!-- ===LANGSDK_EXAMPLE_NAME=== -->
+    <!-- ===LANGSDK_EXAMPLE_NAME=== -->
+```
+
+That is, the comment flags must be tabbed over under the `=== "LanguageName"` line.
+
+
+
+## Running the import script
+
+The import script, `import_examples.py`, will search the configured repository paths for named examples to be pulled into the docs. The script will clone the SDK repositories if they are not already present. The script will also update the SDK repositories if they are already present.
+
+The following will import only the `PYSDK` examples:
+```sh
+python import_examples.py --src PYSDK
+```
+
+## New examples
+
+For any *new* examples, please follow the formatting of the existing examples in that repository.
+
+The `examples` branch of all the SDKs should be used for development of examples.  The examples should be runable with the smoke-test shell script, so that CI can catch any issues.