@goplausible/algorand-mcp 3.0.7

package/dist/resources/knowledge/taxonomy/algokit:cli:features:tasks:mint.md

@@ -0,0 +1,70 @@
+# AlgoKit Task Mint
+
+The AlgoKit Mint feature allows you to mint new fungible or non-fungible assets on the Algorand blockchain. This feature supports the creation of assets, validation of asset parameters, and uploading of asset metadata and image to IPFS using the Piñata provider. Immutable assets are compliant with [ARC3](https://arc.algorand.foundation/ARCs/arc-0003), while mutable are based using [ARC19](https://arc.algorand.foundation/ARCs/arc-0019) standard.
+
+## Usage
+
+Available commands and possible usage as follows:
+
+```bash
+Usage: algokit task mint [OPTIONS]
+
+  Mint new fungible or non-fungible assets on Algorand.
+
+Options:
+  --creator TEXT                  Address or alias of the asset creator.  [required]
+  -n, --name TEXT                 Asset name.  [required]
+  -u, --unit TEXT                 Unit name of the asset.  [required]
+  -t, --total INTEGER             Total supply of the asset. Defaults to 1.
+  -d, --decimals INTEGER          Number of decimals. Defaults to 0.
+  -i, --image FILE                Path to the asset image file to be uploaded to IPFS.  [required]
+  -m, --metadata FILE             Path to the ARC19 compliant asset metadata file to be uploaded to IPFS. If not
+                                  provided, a default metadata object will be generated automatically based on asset-
+                                  name, decimals and image. For more details refer to
+                                  https://arc.algorand.foundation/ARCs/arc-0003#json-metadata-file-schema.
+  --mutable / --immutable         Whether the asset should be mutable or immutable. Refers to `ARC19` by default.
+  --nft / --ft                    Whether the asset should be validated as NFT or FT. Refers to NFT by default and
+                                  validates canonical definitions of pure or fractional NFTs as per ARC3 standard.
+  -n, --network [localnet|testnet|mainnet]
+                                  Network to use. Refers to `localnet` by default.
+  -h, --help                      Show this message and exit.
+```
+
+## Options
+
+- `--creator TEXT`: Specifies the address or alias of the asset creator. This option is required.
+- `-n, --name TEXT`: Specifies the asset name. This option is required.
+- `-u, --unit TEXT`: Specifies the unit name of the asset. This option is required.
+- `-t, --total INTEGER`: Specifies the total supply of the asset. Defaults to 1.
+- `-d, --decimals INTEGER`: Specifies the number of decimals. Defaults to 0.
+- `-i, --image PATH`: Specifies the path to the asset image file to be uploaded to IPFS. This option is required.
+- `-m, --metadata PATH`: Specifies the path to the ARC19 compliant asset metadata file to be uploaded to IPFS. If not provided, a default metadata object will be generated automatically based on asset-name, decimals and image.
+- `--mutable / --immutable`: Specifies whether the asset should be mutable or immutable. Refers to `ARC19` by default.
+- `--nft / --ft`: Specifies whether the asset should be validated as NFT or FT. Refers to NFT by default and validates canonical definitions of pure or fractional NFTs as per ARC3 standard.
+- `-n, --network [localnet|testnet|mainnet]`: Specifies the network to use. Refers to `localnet` by default.
+
+## Example
+
+To mint a new asset in interactive mode, you can use the mint command as follows:
+
+```bash
+$ algokit task mint
+```
+
+This will interactively prompt you for the required information, upload the asset image and metadata to IPFS using the Piñata provider and mint a new asset on the Algorand blockchain. The [asset's metadata](https://arc.algorand.foundation/ARCs/arc-0003#json-metadata-file-schema) will be generated automatically based on the provided asset name, decimals, and image.
+
+If you want to provide a custom metadata file, you can use the --metadata flag:
+
+```bash
+$ algokit task mint --metadata {PATH_TO_METADATA}
+```
+
+If the minting process is successful, the asset ID and transaction ID will be output to the console.
+
+For non interactive mode, refer to usage section above for available options.
+
+> Please note, creator account must have at least 0.2 Algos available to cover minimum balance requirements.
+
+## Further Reading
+
+For in-depth details, visit the [mint section](../../cli/index.md#mint) in the AlgoKit CLI reference documentation.

package/dist/resources/knowledge/taxonomy/algokit:cli:features:tasks:nfd.md

@@ -0,0 +1,45 @@
+# AlgoKit Task NFD Lookup
+
+The AlgoKit NFD Lookup feature allows you to perform a lookup via NFD domain or address, returning the associated address or domain respectively using the AlgoKit CLI. The feature is powered by [NFDomains MainNet API](https://api-docs.nf.domains/).
+
+## Usage
+
+Available commands and possible usage as follows:
+
+```bash
+$ ~ algokit task nfd-lookup
+Usage: algokit task nfd-lookup [OPTIONS] VALUE
+
+Perform a lookup via NFD domain or address, returning the associated address or domain respectively.
+
+Options:
+-o, --output [full|tiny|address] Output format for NFD API response. Defaults to address|domain resolved.
+-h, --help                       Show this message and exit.
+```
+
+## Options
+
+- `VALUE`: Specifies the NFD domain or Algorand address to lookup. This argument is required.
+- `--output, -o [full|tiny|address]`: Specifies the output format for NFD API response. Defaults to address|domain resolved.
+
+> When using the `full` and `tiny` output formats, please be aware that these match the [views in get requests of the NFD API](https://api-docs.nf.domains/quick-start#views-in-get-requests). The `address` output format, which is used by default, refers to the respective domain name or address resolved and outputs it as a string (if found).
+
+## Example
+
+To perform a lookup, you can use the nfd-lookup command as follows:
+
+```bash
+$ algokit task nfd-lookup {NFD_DOMAIN_OR_ALGORAND_ADDRESS}
+```
+
+This will perform a lookup and return the associated address or domain. If you want to specify the output format, you can use the --output flag:
+
+```bash
+$ algokit task nfd-lookup {NFD_DOMAIN_OR_ALGORAND_ADDRESS} --output full
+```
+
+If the lookup is successful, the result will be output to the console in a JSON format.
+
+## Further Reading
+
+For in-depth details, visit the [nfd-lookup section](../../cli/index.md#nfd-lookup) in the AlgoKit CLI reference documentation.

package/dist/resources/knowledge/taxonomy/algokit:cli:features:tasks:opt.md

@@ -0,0 +1,71 @@
+# AlgoKit Task Asset opt-(in|out)
+
+AlgoKit Task Asset opt-(in|out) allows you to opt-in or opt-out of Algorand Asset(s). This task supports single or multiple assets.
+
+## Usage
+
+Available commands and possible usage as follows:
+
+### Opt-in
+
+```bash
+Usage: algokit task opt-in [OPTIONS] ASSET_IDS...
+
+  Opt-in to an asset(s). This is required before you can receive an asset.
+  Use -n to specify localnet, testnet, or mainnet. To supply multiple asset IDs, separate them with a whitespace.
+
+Options:
+  --account, -a TEXT  Address or alias of the signer account.  [required]
+  -n, --network [localnet|testnet|mainnet]
+                      Network to use. Refers to `localnet` by default.
+```
+
+### Opt-out
+
+```bash
+Usage: algokit task opt-out [OPTIONS] [ASSET_IDS]...
+
+  Opt-out of an asset(s). You can only opt out of an asset with a zero balance.
+  Use -n to specify localnet, testnet, or mainnet. To supply multiple asset IDs, separate them with a whitespace.
+
+Options:
+  --account, -a TEXT  Address or alias of the signer account.  [required]
+  --all                Opt-out of all assets with zero balance.
+  -n, --network [localnet|testnet|mainnet]
+                      Network to use. Refers to `localnet` by default.
+```
+
+## Options
+
+- `ASSET_IDS`: Specifies the asset IDs to opt-in or opt-out. To supply multiple asset IDs, separate them with a whitespace.
+- `--account`, `-a` TEXT: Specifies the address or alias of the signer account. This option is required.
+- `--all`: Specifies to opt-out of all assets with zero balance.
+- `-n`, `--network` [localnet|testnet|mainnet]: Specifies the network to use. Refers to localnet by default.
+
+## Example
+
+Example
+
+To opt-in to an asset(s), you can use the opt-in command as follows:
+
+```bash
+$ algokit task opt-in --account {YOUR_ACCOUNT} {ASSET_ID_1} {ASSET_ID_2} {ASSET_ID_3} ...
+```
+
+To opt-out of an asset(s), you can use the opt-out command as follows:
+
+```bash
+$ algokit task opt-out --account {YOUR_ACCOUNT} {ASSET_ID_1} {ASSET_ID_2} ...
+```
+
+To opt-out of all assets with zero balance, you can use the opt-out command with the `--all` flag:
+
+```bash
+$ algokit task opt-out --account {YOUR_ACCOUNT} --all
+```
+
+> Please note, the account must have sufficient balance to cover the transaction fees.
+
+## Further Reading
+
+For in-depth details, visit the [opt-in](../../cli/index.md#opt-in) and [opt-out](../../cli/index#opt-out) sections in the AlgoKit CLI reference documentation.

package/dist/resources/knowledge/taxonomy/algokit:cli:features:tasks:send.md

@@ -0,0 +1,60 @@
+# AlgoKit Task Send
+
+The AlgoKit Send feature allows you to send signed Algorand transaction(s) to a specified network using the AlgoKit CLI. This feature supports sending single or multiple transactions, either provided directly as a base64 encoded string or from a binary file.
+
+## Usage
+
+Available commands and possible usage as follows:
+
+```bash
+$ ~ algokit task send
+Usage: algokit task send [OPTIONS]
+
+  Send a signed transaction to the given network.
+
+Options:
+  -f, --file FILE                 Single or multiple message pack encoded signed transactions from binary file to
+                                  send. Option is mutually exclusive with transaction.
+  -t, --transaction TEXT          Base64 encoded signed transaction to send. Option is mutually exclusive with file.
+  -n, --network [localnet|testnet|mainnet]
+                                  Network to use. Refers to `localnet` by default.
+  -h, --help                      Show this message and exit.
+```
+
+## Options
+
+- `--file, -f PATH`: Specifies the path to a binary file containing single or multiple message pack encoded signed transactions to send. Mutually exclusive with `--transaction` option.
+- `--transaction, -t TEXT`: Specifies a single base64 encoded signed transaction to send. Mutually exclusive with `--file` option.
+- `--network, -n [localnet|testnet|mainnet]`: Specifies the network to which the transactions will be sent. Refers to `localnet` by default.
+
+> Please note, `--transaction` flag only supports sending a single transaction. If you want to send multiple transactions, you can use the `--file` flag to specify a binary file containing multiple transactions.
+
+## Example
+
+To send a transaction, you can use the `send` command as follows:
+
+```bash
+$ algokit task send --file {PATH_TO_BINARY_FILE_CONTAINING_SIGNED_TRANSACTIONS}
+```
+
+This will send the transactions to the default `localnet` network. If you want to send the transactions to a different network, you can use the `--network` flag:
+
+```bash
+$ algokit task send --transaction {YOUR_BASE64_ENCODED_SIGNED_TRANSACTION} --network testnet
+```
+
+You can also pipe in the `stdout` of `algokit sign` command:
+
+```bash
+$ algokit task sign --account {YOUR_ACCOUNT_ALIAS OR YOUR_ADDRESS} --file {PATH_TO_BINARY_FILE_CONTAINING_TRANSACTIONS} --force | algokit task send --network {network_name}
+```
+
+If the transaction is successfully sent, the transaction ID (txid) will be output to the console. You can check the transaction status at the provided transaction explorer URL.
+
+## Goal Compatibility
+
+Please note, at the moment this feature only supports [`goal clerk`](https://developer.algorand.org/docs/clis/goal/clerk/clerk/) compatible transaction objects.
+
+## Further Reading
+
+For in-depth details, visit the [send section](../../cli/index.md#send) in the AlgoKit CLI reference documentation.

package/dist/resources/knowledge/taxonomy/algokit:cli:features:tasks:sign.md

@@ -0,0 +1,94 @@
+# AlgoKit Task Sign
+
+The AlgoKit Sign feature allows you to sign Algorand transaction(s) using the AlgoKit CLI. This feature supports signing single or multiple transactions, either provided directly as a base64 encoded string or from a binary file.
+
+## Usage
+
+Available commands and possible usage as follows:
+
+```bash
+$ ~ algokit task sign
+Usage: algokit task sign [OPTIONS]
+
+Sign goal clerk compatible Algorand transaction(s).
+
+Options:
+-a, --account TEXT Address or alias of the signer account. [required]
+-f, --file PATH Single or multiple message pack encoded transactions from binary file to sign.
+-t, --transaction TEXT Single base64 encoded transaction object to sign.
+-o, --output PATH The output file path to store signed transaction(s).
+--force Force signing without confirmation.
+-h, --help Show this message and exit.
+```
+
+## Options
+
+- `--account, -a TEXT`: Specifies the address or alias of the signer account. This option is required.
+- `--file, -f PATH`: Specifies the path to a binary file containing single or multiple message pack encoded transactions to sign. Mutually exclusive with `--transaction` option.
+- `--transaction, -t TEXT`: Specifies a single base64 encoded transaction object to sign. Mutually exclusive with `--file` option.
+- `--output, -o PATH`: Specifies the output file path to store signed transaction(s).
+- `--force`: If specified, it allows signing without interactive confirmation prompt.
+
+> Please note, `--transaction` flag only supports signing a single transaction. If you want to sign multiple transactions, you can use the `--file` flag to specify a binary file containing multiple transactions.
+
+## Example
+
+To sign a transaction, you can use the `sign` command as follows:
+
+```bash
+$ algokit task sign --account {YOUR_ACCOUNT_ALIAS OR YOUR_ADDRESS} --file {PATH_TO_BINARY_FILE_CONTAINING_TRANSACTIONS}
+```
+
+This will prompt you to confirm the transaction details before signing. If you want to bypass the confirmation, you can use the `--force` flag:
+
+```bash
+$ algokit task sign --account {YOUR_ACCOUNT_ALIAS OR YOUR_ADDRESS} --transaction {YOUR_BASE64_ENCODED_TRANSACTION} --force
+```
+
+If the transaction is successfully signed, the signed transaction will be output to the console in a JSON format. If you want to write the signed transaction to a file, you can use the `--output` option:
+
+```bash
+$ algokit task sign --account {YOUR_ACCOUNT_ALIAS OR YOUR_ADDRESS} --transaction {YOUR_BASE64_ENCODED_TRANSACTION} --output /path/to/output/file
+```
+
+This will write the signed transaction to the specified file.
+
+## Goal Compatibility
+
+Please note, at the moment this feature only supports [`goal clerk`](https://developer.algorand.org/docs/clis/goal/clerk/clerk/) compatible transaction objects.
+
+When `--output` option is not specified, the signed transaction(s) will be output to the console in a following JSON format:
+
+```
+[
+  {transaction_id: "TRANSACTION_ID", content: "BASE64_ENCODED_SIGNED_TRANSACTION"},
+]
+```
+
+On the other hand, when `--output` option is specified, the signed transaction(s) will be stored to a file as a message pack encoded binary file.
+
+### Encoding transactins for signing
+
+Algorand provides a set of options in [py-algorand-sdk](https://github.com/algorand/py-algorand-sdk) and [js-algorand-sdk](https://github.com/algorand/js-algorand-sdk) to encode transactions for signing.
+
+Encoding simple txn object in python:
+
+```py
+# Encoding single transaction as a base64 encoded string
+algosdk.encoding.msgpack_encode({"txn": {YOUR_TXN_OBJECT}.dictify()}) # Resulting string can be passed directy to algokit task sign with --transaction flag
+
+# Encoding multiple transactions as a message pack encoded binary file
+algosdk.transaction.write_to_file([{YOUR_TXN_OBJECT}], "some_file.txn") # Resulting file path can be passed directly to algokit sign with --file flag
+```
+
+Encoding simple txn object in javascript:
+
+```ts
+Buffer.from(algosdk.encodeObj({ txn: txn.get_obj_for_encoding() })).toString(
+  "base64"
+); // Resulting string can be passed directy to algokit task sign with --transaction flag
+```
+
+## Further Reading
+
+For in-depth details, visit the [sign section](../../cli/index.md#sign) in the AlgoKit CLI reference documentation.

package/dist/resources/knowledge/taxonomy/algokit:cli:features:tasks:transfer.md

@@ -0,0 +1,54 @@
+# AlgoKit Task Transfer
+
+The AlgoKit Transfer feature allows you to transfer algos and assets between two accounts.
+
+## Usage
+
+Available commands and possible usage as follows:
+
+```bash
+$ ~ algokit task transfer
+Usage: algokit task transfer [OPTIONS]
+
+Transfer algos or assets from one account to another.
+
+Options:
+  -s, --sender TEXT               Address or alias of the sender account  [required]
+  -r, --receiver TEXT             Address or alias to an account that will receive the asset(s)  [required]
+  --asset, --id INTEGER           ASA asset id to transfer
+  -a, --amount INTEGER            Amount to transfer  [required]
+  --whole-units                   Use whole units (Algos | ASAs) instead of smallest divisible units (for example,
+                                  microAlgos). Disabled by default.
+  -n, --network [localnet|testnet|mainnet]
+                                  Network to use. Refers to `localnet` by default.
+  -h, --help                      Show this message and exit.
+```
+
+> Note: If you use a wallet address for the `sender` argument, you'll be asked for the mnemonic phrase. To use a wallet alias instead, see the [wallet aliasing](wallet.md) task. For wallet aliases, the sender must have a stored `private key`, but the receiver doesn't need one. This is because the sender signs and sends the transfer transaction, while the receiver reference only needs a valid Algorand address.
+
+## Examples
+
+### Transfer algo between accounts on LocalNet
+
+```bash
+$ ~ algokit task transfer -s {SENDER_ALIAS OR SENDER_ADDRESS} -r {RECEIVER_ALIAS OR RECEIVER_ADDRESS} -a {AMOUNT}
+```
+
+By default:
+
+- the `amount` is in microAlgos. To use whole units, use the `--whole-units` flag.
+- the `network` is `localnet`.
+
+### Transfer asset between accounts on TestNet
+
+```bash
+$ ~ algokit task transfer -s {SENDER_ALIAS OR SENDER_ADDRESS} -r {RECEIVER_ALIAS OR RECEIVER_ADDRESS} -a {AMOUNT} --id {ASSET_ID} --network testnet
+```
+
+By default:
+
+- the `amount` is smallest divisible unit of supplied `ASSET_ID`. To use whole units, use the `--whole-units` flag.
+
+## Further Reading
+
+For in-depth details, visit the [transfer section](../../cli/index.md#transfer) in the AlgoKit CLI reference documentation.

package/dist/resources/knowledge/taxonomy/algokit:cli:features:tasks:vanity_address.md

@@ -0,0 +1,56 @@
+# AlgoKit Task Vanity Address
+
+The AlgoKit Vanity Address feature allows you to generate a vanity Algorand address. A vanity address is an address that contains a specific keyword in it. The keyword can only include uppercase letters A-Z and numbers 2-7. The longer the keyword, the longer it may take to generate a matching address.
+
+## Usage
+
+Available commands and possible usage as follows:
+
+```bash
+$ ~ algokit task vanity-address
+Usage: algokit task vanity-address [OPTIONS] KEYWORD
+
+  Generate a vanity Algorand address. Your KEYWORD can only include letters A - Z and numbers 2 - 7. Keeping your
+  KEYWORD under 5 characters will usually result in faster generation. Note: The longer the KEYWORD, the longer it may
+  take to generate a matching address. Please be patient if you choose a long keyword.
+
+Options:
+  -m, --match [start|anywhere|end]
+                                  Location where the keyword will be included. Default is start.
+  -o, --output [stdout|alias|file]
+                                  How the output will be presented.
+  -a, --alias TEXT                Alias for the address. Required if output is "alias".
+  --file-path PATH                File path where to dump the output. Required if output is "file".
+  -f, --force                     Allow overwriting an aliases without confirmation, if output option is 'alias'.
+  -h, --help                      Show this message and exit.
+```
+
+## Examples
+
+Generate a vanity address with the keyword "ALGO" at the start of the address with default output to `stdout`:
+
+```bash
+$ ~ algokit task vanity-address ALGO
+```
+
+Generate a vanity address with the keyword "ALGO" at the start of the address with output to a file:
+
+```bash
+$ ~ algokit task vanity-address ALGO -o file -f vanity-address.txt
+```
+
+Generate a vanity address with the keyword "ALGO" anywhere in the address with output to a file:
+
+```bash
+$ ~ algokit task vanity-address ALGO -m anywhere -o file -f vanity-address.txt
+```
+
+Generate a vanity address with the keyword "ALGO" at the start of the address and store into a [wallet alias](wallet.md):
+
+```bash
+$ ~ algokit task vanity-address ALGO -o alias -a my-vanity-address
+```
+
+## Further Reading
+
+For in-depth details, visit the [vanity-address section](../../cli/index.md#vanity-address) in the AlgoKit CLI reference documentation.

package/dist/resources/knowledge/taxonomy/algokit:cli:features:tasks:wallet.md

@@ -0,0 +1,93 @@
+# AlgoKit Task Wallet
+
+Manage your Algorand addresses and accounts effortlessly with the AlgoKit Wallet feature. This feature allows you to create short aliases for your addresses and accounts on AlgoKit CLI.
+
+## Usage
+
+Available commands and possible usage as follows:
+
+```bash
+$ ~ algokit task wallet
+Usage: algokit task wallet [OPTIONS] COMMAND [ARGS]...
+
+Create short aliases for your addresses and accounts on AlgoKit CLI.
+
+Options:
+-h, --help Show this message and exit.
+
+Commands:
+add Add an address or account to be stored against a named alias.
+get Get an address or account stored against a named alias.
+list List all addresses and accounts stored against a named alias.
+remove Remove an address or account stored against a named alias.
+reset Remove all aliases.
+```
+
+## Commands
+
+### Add
+
+This command adds an address or account to be stored against a named alias. If the `--mnemonic` flag is used, it will prompt the user for a mnemonic phrase interactively using masked input. If the `--force` flag is used, it will allow overwriting an existing alias. Maximum number of aliases that can be stored at a time is 50.
+
+```bash
+$ algokit wallet add [OPTIONS] ALIAS_NAME
+```
+
+> Please note, the command is not designed to be used in CI scope, there is no option to skip interactive masked input of the mnemonic, if you want to alias an `Account` (both private and public key) entity.
+
+#### Options
+
+- `--address, -a TEXT`: Specifies the address of the account. This option is required.
+- `--mnemonic, -m`: If specified, it prompts the user for a mnemonic phrase interactively using masked input.
+- `--force, -f`: If specified, it allows overwriting an existing alias without interactive confirmation prompt.
+
+### Get
+
+This command retrieves an address or account stored against a named alias.
+
+```bash
+$ algokit wallet get ALIAS
+```
+
+### List
+
+This command lists all addresses and accounts stored against a named alias. If a record contains a `private_key` it will show a boolean flag indicating whether it exists, actual private key values are never exposed. As a user you can obtain the content of the stored aliases by navigating to your dedicated password manager (see [keyring details](https://pypi.org/project/keyring/)).
+
+```bash
+$ algokit wallet list
+```
+
+### Remove
+
+This command removes an address or account stored against a named alias.
+You must confirm the prompt interactively or pass `--force` | `-f` flag to ignore the prompt.
+
+```bash
+$ algokit wallet remove ALIAS  [--force | -f]
+```
+
+### Reset
+
+This command removes all aliases. You must confirm the prompt interactively or pass `--force` | `-f` flag to ignore the prompt.
+
+```bash
+$ algokit wallet reset [--force | -f]
+```
+
+## Keyring
+
+AlgoKit relies on the [keyring](https://pypi.org/project/keyring/) library, which provides an easy way to interact with the operating system's password manager. This abstraction allows AlgoKit to securely manage sensitive information such as mnemonics and private keys.
+
+When you use AlgoKit to store a mnemonic, it is never printed or exposed directly in the console. Instead, the mnemonic is converted and stored as a private key in the password manager. This ensures that your sensitive information is kept secure.
+
+To retrieve the stored mnemonic, you will need to manually navigate to your operating system's password manager. The keyring library supports a variety of password managers across different operating systems. Here are some examples:
+
+- On macOS, it uses the Keychain Access app.
+- On Windows, it uses the Credential Manager.
+- On Linux, it can use Secret Service API, KWallet, or an in-memory store depending on your setup.
+
+> Remember, AlgoKit is designed to keep your sensitive information secure however your storage is only as secure as the device on which it is stored. Always ensure to maintain good security practices on your device, especially when dealing with mnemonics that are to be used on MainNet.
+
+## Further Reading
+
+For in-depth details, visit the [wallet section](../../cli/index.md#wallet) in the AlgoKit CLI reference documentation.