@goplausible/algorand-mcp 3.0.7

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

@@ -0,0 +1,64 @@
+# AlgoKit TypeScript Utilities
+
+A set of core Algorand utilities written in TypeScript and released via npm 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 Python there's an equivalent [Python utility library](https://github.com/algorandfoundation/algokit-utils-py).
+
+[Install](#install) | [Documentation](./docs/README.md)
+
+## Install
+
+Before installing, you'll need to decide on the version you want to target. Version 7 and 8 have the same feature set, however v7 leverages algosdk@>=2.9.0<3.0, whereas v8 leverages algosdk@>=3.0.0. Your project and it's dependencies will help you decide which version to target.
+
+Once you've decided on the target version, this library can be installed from NPM using your favourite npm client, e.g.:
+
+To target algosdk@2 and use version 7 of AlgoKit Utils, run the below:
+
+```
+npm install algosdk@^2.9.0 @algorandfoundation/algokit-utils@^7.0.0
+```
+
+To target algosdk@3 and use the latest version of AlgoKit Utils, run the below:
+
+```
+npm install algosdk@^3.0.0 @algorandfoundation/algokit-utils
+```
+
+Now you can import the library:
+
+```typescript
+import { AlgorandClient, Config } from '@algorandfoundation/algokit-utils'
+```
+
+See [usage](./docs/README.md#usage) for more details.
+
+## Migration
+
+Whilst we aim to minimise breaking changes, there are situations where they are required.
+JSDoc deprecations should guide you through most migration paths inside your IDE, however the migration guides will provide more detailed information should you need it.
+
+If you're targetting v7, please refer to the [v7 migration guide](./docs/v7-migration.md).
+If you're targetting v8, please refer to the [v8 migration guide](./docs/v8-migration.md).
+
+## 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) and also have package dependencies and `.env.template` copied to `.env` (both of which `algokit bootstrap all` can do for you):
+
+```
+algokit bootstrap all
+algokit localnet start
+```
+
+To run tests you can use VS Code, or:
+
+```
+npm run test
+```

package/dist/resources/knowledge/taxonomy/algokit:utils:typescript:capabilities:account.md

@@ -0,0 +1,186 @@
+# Account management
+
+Account management is one of the core capabilities provided by AlgoKit Utils. It allows you to create mnemonic, rekeyed, multisig, transaction signer, idempotent KMD and environment variable injected accounts that can be used to sign transactions as well as representing a sender address at the same time. This significantly simplifies management of transaction signing.
+
+## `AccountManager`
+
+The [`AccountManager`](../code/classes/types_account_manager.AccountManager.md) is a class that is used to get, create, and fund accounts and perform account-related actions such as funding. The `AccountManager` also keeps track of signers for each address so when using the [`TransactionComposer`](./transaction-composer.md) to send transactions, a signer function does not need to manually be specified for each transaction - instead it can be inferred from the sender address automatically!
+
+To get an instance of `AccountManager`, you can use either [`AlgorandClient`](./algorand-client.md) via `algorand.account` or instantiate it directly:
+
+```typescript
+import { AccountManager } from '@algorandfoundation/algokit-utils/types/account-manager'
+
+const accountManager = new AccountManager(clientManager)
+```
+
+## `TransactionSignerAccount`
+
+The core internal type that holds information about a signer/sender pair for a transaction is [`TransactionSignerAccount`](../code/interfaces/types_account.TransactionSignerAccount.md), which represents an `algosdk.TransactionSigner` (`signer`) along with a sender address (`addr`) as the encoded string address.
+
+Many methods in `AccountManager` expose a `TransactionSignerAccount`. `TransactionSignerAccount` can be used with `AtomicTransactionComposer`, [`TransactionComposer`](./transaction-composer.md) and [useWallet](https://github.com/TxnLab/use-wallet).
+
+## Registering a signer
+
+The `AccountManager` keeps track of which signer is associated with a given sender address. This is used by [`AlgorandClient`](./algorand-client.md) to automatically sign transactions by that sender. Any of the [methods](#accounts) within `AccountManager` that return an account will automatically register the signer with the sender. If however, you are creating a signer external to the `AccountManager`, for instance when using the use-wallet library in a dApp, then you need to register the signer with the `AccountManager` if you want it to be able to automatically sign transactions from that sender.
+
+There are two methods that can be used for this, `setSignerFromAccount`, which takes any number of [account based objects](#underlying-account-classes) that combine signer and sender (`TransactionSignerAccount` | `algosdk.Account` | `algosdk.LogicSigAccount` | `SigningAccount` | `MultisigAccount`), or `setSigner` which takes the sender address and the `TransactionSigner`:
+
+```typescript
+algorand.account
+  .setSignerFromAccount(algosdk.generateAccount())
+  .setSignerFromAccount(new algosdk.LogicSigAccount(program, args))
+  .setSignerFromAccount(new SigningAccount(mnemonic, sender))
+  .setSignerFromAccount(new MultisigAccount({ version: 1, threshold: 1, addrs: ['ADDRESS1...', 'ADDRESS2...'] }, [account1, account2]))
+  .setSignerFromAccount({ addr: 'SENDERADDRESS', signer: transactionSigner })
+  .setSigner('SENDERADDRESS', transactionSigner)
+```
+
+## Default signer
+
+If you want to have a default signer that is used to sign transactions without a registered signer (rather than throwing an exception) then you can [register a default signer](../code/classes/types_account_manager.AccountManager.md#setdefaultsigner):
+
+```typescript
+algorand.account.setDefaultSigner(myDefaultSigner)
+```
+
+## Get a signer
+
+[`AlgorandClient`](./algorand-client.md) will automatically retrieve a signer when signing a transaction, but if you need to get a `TransactionSigner` externally to do something more custom then you can [retrieve the signer](../code/classes//types_account_manager.AccountManager.md#getsigner) for a given sender address:
+
+```typescript
+const signer = algorand.account.getSigner('SENDER_ADDRESS')
+```
+
+If there is no signer registered for that sender address it will either return the default signer ([if registered](#default-signer)) or throw an exception.
+
+## Accounts
+
+In order to get/register accounts for signing operations you can use the following methods on [`AccountManager`](#accountmanager) (expressed here as `algorand.account` to denote the syntax via an [`AlgorandClient`](./algorand-client.md)):
+
+- [`algorand.account.fromEnvironment(name, fundWith)`](../code/classes/types_account_manager.AccountManager.md#fromenvironment) - Registers and returns an account with private key loaded by convention based on the given name identifier - either by idempotently creating the account in KMD or from environment variable via `process.env['{NAME}_MNEMONIC']` and (optionally) `process.env['{NAME}_SENDER']` (if account is rekeyed)
+  - This allows you to have powerful code that will automatically create and fund an account by name locally and when deployed against TestNet/MainNet will automatically resolve from environment variables, without having to have different code
+  - Note: `fundWith` allows you to control how many Algo are seeded into an account created in KMD
+- [`algorand.account.fromMnemonic(mnemonicSecret, sender?)`](../code/classes/types_account_manager.AccountManager.md#frommnemonic) - Registers and returns an account with secret key loaded by taking the mnemonic secret
+- [`algorand.account.multisig(multisigParams, signingAccounts)`](../code/classes/types_account_manager.AccountManager.md#multisig) - Registers and returns a multisig account with one or more signing keys loaded
+- [`algorand.account.rekeyed(sender, signer)`](../code/classes/types_account_manager.AccountManager.md#rekeyed) - Registers and returns an account representing the given rekeyed sender/signer combination
+- [`algorand.account.random()`](../code/classes/types_account_manager.AccountManager.md#random) - Returns a new, cryptographically randomly generated account with private key loaded
+- [`algorand.account.fromKmd()`](../code/classes/types_account_manager.AccountManager.md#fromkmd) - Returns an account with private key loaded from the given KMD wallet (identified by name)
+- [`algorand.account.logicsig(program, args?)`](../code/classes/types_account_manager.AccountManager.md#logicsig) - Returns an account that represents a logic signature
+
+### Underlying account classes
+
+While `TransactionSignerAccount` is the main class used to represent an account that can sign, there are underlying account classes that can underpin the signer within the transaction signer account.
+
+- `Account` - An in-built `algosdk.Account` object that has an address and private signing key, this can be created
+- [`SigningAccount`](../code/classes/types_account.SigningAccount.md) - An abstraction around `algosdk.Account` that supports rekeyed accounts
+- `LogicSigAccount` - An in-built algosdk `algosdk.LogicSigAccount` object
+- [`MultisigAccount`](../code/classes/types_account.MultisigAccount.md) - An abstraction around `algosdk.MultisigMetadata`, `algosdk.makeMultiSigAccountTransactionSigner`, `algosdk.multisigAddress`, `algosdk.signMultisigTransaction` and `algosdk.appendSignMultisigTransaction` that supports multisig accounts with one or more signers present
+
+### Dispenser
+
+- [`algorand.account.dispenserFromEnvironment()`](../code/classes/types_account_manager.AccountManager.md#dispenserfromenvironment) - Returns an account (with private key loaded) that can act as a dispenser from environment variables, or against default LocalNet if no environment variables present
+- [`algorand.account.localNetDispenser()`](../code/classes/types_account_manager.AccountManager.md#localnetdispenser) - Returns an account with private key loaded that can act as a dispenser for the default LocalNet dispenser account
+
+## Rekey account
+
+One of the unique features of Algorand is the ability to change the private key that can authorise transactions for an account. This is called [rekeying](https://developer.algorand.org/docs/get-details/accounts/rekey/).
+
+> [!WARNING]
+> Rekeying should be done with caution as a rekey transaction can result in permanent loss of control of an account.
+
+You can issue a transaction to rekey an account by using the [`algorand.account.rekeyAccount(account, rekeyTo, options)`](../code/classes/types_account_manager.AccountManager.md#rekeyaccount) function:
+
+- `account: string | TransactionSignerAccount` - The account address or signing account of the account that will be rekeyed
+- `rekeyTo: string | TransactionSignerAccount` - The account address or signing account of the account that will be used to authorise transactions for the rekeyed account going forward. If a signing account is provided that will now be tracked as the signer for `account` in the `AccountManager` instance.
+- An `options` object, which has:
+  - [Common transaction parameters](./algorand-client.md#transaction-parameters)
+  - [Execution parameters](./algorand-client.md#sending-a-single-transaction)
+
+You can also pass in `rekeyTo` as a [common transaction parameter](./algorand-client.md#transaction-parameters) to any transaction.
+
+### Examples
+
+```typescript
+// Basic example (with string addresses)
+
+await algorand.account.rekeyAccount({ account: 'ACCOUNTADDRESS', rekeyTo: 'NEWADDRESS' })
+
+// Basic example (with signer accounts)
+
+await algorand.account.rekeyAccount({ account: account1, rekeyTo: newSignerAccount })
+
+// Advanced example
+
+await algorand.account.rekeyAccount({
+  account: 'ACCOUNTADDRESS',
+  rekeyTo: 'NEWADDRESS',
+  lease: 'lease',
+  note: 'note',
+  firstValidRound: 1000n,
+  validityWindow: 10,
+  extraFee: (1000).microAlgo(),
+  staticFee: (1000).microAlgo(),
+  // Max fee doesn't make sense with extraFee AND staticFee
+  //  already specified, but here for completeness
+  maxFee: (3000).microAlgo(),
+  maxRoundsToWaitForConfirmation: 5,
+  suppressLog: true,
+})
+
+// Using a rekeyed account
+
+// Note: if a signing account is passed into `algorand.account.rekeyAccount` then you don't need to call `rekeyedAccount` to register the new signer
+const rekeyedAccount = algorand.account.rekeyed(account, newAccount)
+// rekeyedAccount can be used to sign transactions on behalf of account...
+```
+
+# KMD account management
+
+When running LocalNet, you have an instance of the [Key Management Daemon](https://github.com/algorand/go-algorand/blob/master/daemon/kmd/README.md), which is useful for:
+
+- Accessing the private key of the default accounts that are pre-seeded with Algo so that other accounts can be funded and it's possible to use LocalNet
+- Idempotently creating new accounts against a name that will stay intact while the LocalNet instance is running without you needing to store private keys anywhere (i.e. completely automated)
+
+The KMD SDK is fairly low level so to make use of it there is a fair bit of boilerplate code that's needed. This code has been abstracted away into the `KmdAccountManager` class.
+
+To get an instance of the `KmdAccountManager` class you can access it from [`AlgorandClient`](./algorand-client.md) via `algorand.account.kmd` or instantiate it directly (passing in a [`ClientManager`](./client.md)):
+
+```typescript
+import { KmdAccountManager } from '@algorandfoundation/algokit-utils/types/kmd-account-manager'
+
+// Algod client only
+const kmdAccountManager = new KmdAccountManager(clientManager)
+```
+
+The methods that are available are:
+
+- [`getWalletAccount(walletName, predicate?, sender?)](../code/classes/types_kmd_account_manager.KmdAccountManager.md#getwalletaccount)` - Returns an Algorand signing account with private key loaded from the given KMD wallet (identified by name).
+- [`getOrCreateWalletAccount(name, fundWith?)](../code/classes/types_kmd_account_manager.KmdAccountManager.md#getorcreatewalletaccount)` - Gets an account with private key loaded from a KMD wallet of the given name, or alternatively creates one with funds in it via a KMD wallet of the given name.
+- [`getLocalNetDispenserAccount()](../code/classes/types_kmd_account_manager.KmdAccountManager.md#getlocalnetdispenseraccount)` - Returns an Algorand account with private key loaded for the default LocalNet dispenser account (that can be used to fund other accounts)
+
+```typescript
+// Get a wallet account that seeded the LocalNet network
+const defaultDispenserAccount = await kmdAccountManager.getWalletAccount(
+  'unencrypted-default-wallet',
+  (a) => a.status !== 'Offline' && a.amount > 1_000_000_000,
+)
+// Same as above, but dedicated method call for convenience
+const localNetDispenserAccount = await kmdAccountManager.getLocalNetDispenserAccount()
+// Idempotently get (if exists) or create (if it doesn't exist yet) an account by name using KMD
+// if creating it then fund it with 2 ALGO from the default dispenser account
+const newAccount = await kmdAccountManager.getOrCreateWalletAccount('account1', (2).algo())
+// This will return the same account as above since the name matches
+const existingAccount = await kmdAccountManager.getOrCreateWalletAccount('account1')
+```
+
+Some of this functionality is directly exposed from [`AccountManager`](#accountmanager), which has the added benefit of registering the account as a signer so they can be automatically used to sign transactions when using via [`AlgorandClient`](./algorand-client.md):
+
+```typescript
+// Get and register LocalNet dispenser
+const localNetDispenser = await algorand.account.localNetDispenser()
+// Get and register a dispenser by environment variable, or if not set then LocalNet dispenser via KMD
+const dispenser = await algorand.account.dispenserFromEnvironment()
+// Get / create and register account from KMD idempotently by name
+const account1 = await algorand.account.fromKmd('account1', (2).algo())
+```

package/dist/resources/knowledge/taxonomy/algokit:utils:typescript:capabilities:algorand-client.md

@@ -0,0 +1,160 @@
+# Algorand client
+
+`AlgorandClient` is a client class that brokers easy access to Algorand functionality. It's the [default entrypoint](../README.md#usage) into AlgoKit Utils functionality.
+
+The main entrypoint to the bulk of the functionality in AlgoKit Utils is the `AlgorandClient` class, most of the time you can get started by typing `AlgorandClient.` and choosing one of the static initialisation methods to create an [Algorand client](./capabilities/algorand-client.md), e.g.:
+
+```typescript
+// Point to the network configured through environment variables or
+//  if no environment variables it will point to the default LocalNet
+//  configuration
+const algorand = AlgorandClient.fromEnvironment()
+// Point to default LocalNet configuration
+const algorand = AlgorandClient.defaultLocalNet()
+// Point to TestNet using AlgoNode free tier
+const algorand = AlgorandClient.testNet()
+// Point to MainNet using AlgoNode free tier
+const algorand = AlgorandClient.mainNet()
+// Point to a pre-created algod client
+const algorand = AlgorandClient.fromClients({ algod })
+// Point to pre-created algod, indexer and kmd clients
+const algorand = AlgorandClient.fromClients({ algod, indexer, kmd })
+// Point to custom configuration for algod
+const algorand = AlgorandClient.fromConfig({ algodConfig })
+// Point to custom configuration for algod, indexer and kmd
+const algorand = AlgorandClient.fromConfig({ algodConfig, indexerConfig, kmdConfig })
+```
+
+## Accessing SDK clients
+
+Once you have an `AlgorandClient` instance, you can access the SDK clients for the various Algorand APIs via the `algorand.client` property.
+
+```ts
+const algorand = AlgorandClient.defaultLocalNet()
+
+const algodClient = algorand.client.algod
+const indexerClient = algorand.client.indexer
+const kmdClient = algorand.client.kmd
+```
+
+## Accessing manager class instances
+
+The `AlgorandClient` has a number of manager class instances that help you quickly use intellisense to get access to advanced functionality.
+
+- [`AccountManager`](./account.md) via `algorand.account`, there are also some chainable convenience methods which wrap specific methods in `AccountManager`:
+  - `algorand.setDefaultSigner(signer)` -
+  - `algorand.setSignerFromAccount(account)` -
+  - `algorand.setSigner(sender, signer)`
+- [`AssetManager`](./asset.md) via `algorand.asset`
+- [`ClientManager`](./client.md) via `algorand.client`
+
+## Creating and issuing transactions
+
+`AlgorandClient` exposes a series of methods that allow you to create, execute, and compose groups of transactions (all via the [`TransactionComposer`](./transaction-composer.md)).
+
+### Creating transactions
+
+You can compose a transaction via `algorand.createTransaction...`, which gives you an instance of the [`AlgorandClientTransactionCreator`](../code/classes/types_algorand_client_transaction_creator.AlgorandClientTransactionCreator.md) class. Intellisense will guide you on the different options.
+
+The signature for the calls to send a single transaction usually look like:
+
+```
+algorand.createTransaction.{method}(params: {ComposerTransactionTypeParams} & CommonTransactionParams): Promise<Transaction>
+```
+
+- To get intellisense on the params, open an object parenthesis (`{`) and use your IDE's intellisense keyboard shortcut (e.g. ctrl+space).
+- `{ComposerTransactionTypeParams}` will be the parameters that are specific to that transaction type e.g. `PaymentParams`, [see the full list](../code/modules/types_composer.md#type-aliases)
+- [`CommonTransactionParams`](../code/modules/types_composer.md#commontransactionparams) are the [common transaction parameters](#transaction-parameters) that can be specified for every single transaction
+- `Transaction` is an unsigned `algosdk.Transaction` object, ready to be signed and sent
+
+The return type for the ABI method call methods are slightly different:
+
+```
+algorand.createTransaction.app{callType}MethodCall(params: {ComposerTransactionTypeParams} & CommonTransactionParams): Promise<BuiltTransactions>
+```
+
+Where `BuiltTransactions` looks like this:
+
+```typescript
+export interface BuiltTransactions {
+  /** The built transactions */
+  transactions: algosdk.Transaction[]
+  /** Any `ABIMethod` objects associated with any of the transactions in a map keyed by transaction index. */
+  methodCalls: Map<number, algosdk.ABIMethod>
+  /** Any `TransactionSigner` objects associated with any of the transactions in a map keyed by transaction index. */
+  signers: Map<number, algosdk.TransactionSigner>
+}
+```
+
+This signifies the fact that an ABI method call can actually result in multiple transactions (which in turn may have different signers), that you need ABI metadata to be able to extract the return value from the transaction result.
+
+### Sending a single transaction
+
+You can compose a single transaction via `algorand.send...`, which gives you an instance of the [`AlgorandClientTransactionSender`](../code/classes/types_algorand_client_transaction_sender.AlgorandClientTransactionSender.md) class. Intellisense will guide you on the different options.
+
+Further documentation is present in the related capabilities:
+
+- [App management](./app.md)
+- [Asset management](./asset.md)
+- [Algo transfers](./transfer.md)
+
+The signature for the calls to send a single transaction usually look like:
+
+`algorand.send.{method}(params: {ComposerTransactionTypeParams} & CommonAppCallParams & SendParams): SingleSendTransactionResult`
+
+- To get intellisense on the params, open an object parenthesis (`{`) and use your IDE's intellisense keyboard shortcut (e.g. ctrl+space).
+- `{ComposerTransactionTypeParams}` will be the parameters that are specific to that transaction type e.g. `PaymentParams`, [see the full list](../code/modules/types_composer.md#type-aliases)
+- [`CommonAppCallParams`](../code/modules/types_composer.md#commonappcallparams) are the [common app call transaction parameters](./app.md#common-app-parameters) that can be specified for every single app transaction
+- [`SendParams`](../code/interfaces/types_transaction.SendParams.md) are the [parameters](#transaction-parameters) that control execution semantics when sending transactions to the network
+- [`SendSingleTransactionResult`](../code/modules/types_algorand_client.md#sendsingletransactionresult) is all of the information that is relevant when [sending a single transaction to the network](./transaction.md#sending-a-transaction)
+
+Generally, the functions to immediately send a single transaction will emit log messages before and/or after sending the transaction. You can opt-out of this by sending `suppressLog: true`.
+
+### Composing a group of transactions
+
+You can compose a group of transactions for execution by using the `newGroup()` method on `AlgorandClient` and then use the various `.add{Type}()` methods on [`TransactionComposer`](./transaction-composer.md) to add a series of transactions.
+
+```typescript
+const result = algorand
+  .newGroup()
+  .addPayment({ sender: 'SENDERADDRESS', receiver: 'RECEIVERADDRESS', amount: (1).microAlgo() })
+  .addAssetOptIn({ sender: 'SENDERADDRESS', assetId: 12345n })
+  .send()
+```
+
+`newGroup()` returns a new [`TransactionComposer`](./transaction-composer.md) instance, which can also return the group of transactions, simulate them and other things.
+
+### Transaction parameters
+
+To create a transaction you define a set of parameters as a plain TypeScript object.
+
+There are two common base interfaces that get reused:
+
+- [`CommonTransactionParams`](../code/modules/types_composer.md#commontransactionparams)
+  - `sender: string` - The address of the account sending the transaction.
+  - `signer?: algosdk.TransactionSigner | TransactionSignerAccount` - The function used to sign transaction(s); if not specified then an attempt will be made to find a registered signer for the given `sender` or use a default signer (if configured).
+  - `rekeyTo?: string` - Change the signing key of the sender to the given address. **Warning:** Please be careful with this parameter and be sure to read the [official rekey guidance](https://developer.algorand.org/docs/get-details/accounts/rekey/).
+  - `note?: Uint8Array | string` - Note to attach to the transaction. Max of 1000 bytes.
+  - `lease?: Uint8Array | string` - Prevent multiple transactions with the same lease being included within the validity window. A [lease](https://developer.algorand.org/articles/leased-transactions-securing-advanced-smart-contract-design/) enforces a mutually exclusive transaction (useful to prevent double-posting and other scenarios).
+  - Fee management
+    - `staticFee?: AlgoAmount` - The static transaction fee. In most cases you want to use `extraFee` unless setting the fee to 0 to be covered by another transaction.
+    - `extraFee?: AlgoAmount` - The fee to pay IN ADDITION to the suggested fee. Useful for covering inner transaction fees.
+    - `maxFee?: AlgoAmount` - Throw an error if the fee for the transaction is more than this amount; prevents overspending on fees during high congestion periods.
+  - Round validity management
+    - `validityWindow?: number` - How many rounds the transaction should be valid for, if not specified then the registered default validity window will be used.
+    - `firstValidRound?: bigint` - Set the first round this transaction is valid. If left undefined, the value from algod will be used. We recommend you only set this when you intentionally want this to be some time in the future.
+    - `lastValidRound?: bigint` - The last round this transaction is valid. It is recommended to use `validityWindow` instead.
+- [`SendParams`](../code/interfaces/types_transaction.SendParams.md)
+  - `maxRoundsToWaitForConfirmation?: number` - The number of rounds to wait for confirmation. By default until the latest lastValid has past.
+  - `suppressLog?: boolean` - Whether to suppress log messages from transaction send, default: do not suppress.
+
+Then on top of that the base type gets extended for the specific type of transaction you are issuing. These are all defined as part of [`TransactionComposer`](./transaction-composer.md).
+
+### Transaction configuration
+
+AlgorandClient caches network provided transaction values for you automatically to reduce network traffic. It has a set of default configurations that control this behaviour, but you have the ability to override and change the configuration of this behaviour:
+
+- `algorand.setDefaultValidityWindow(validityWindow)` - Set the default validity window (number of rounds from the current known round that the transaction will be valid to be accepted for), having a smallish value for this is usually ideal to avoid transactions that are valid for a long future period and may be submitted even after you think it failed to submit if waiting for a particular number of rounds for the transaction to be successfully submitted. The validity window defaults to 10, except in [automated testing](./testing.md) where it's set to 1000 when targeting LocalNet.
+- `algorand.setSuggestedParams(suggestedParams, until?)` - Set the suggested network parameters to use (optionally until the given time)
+- `algorand.setSuggestedParamsTimeout(timeout)` - Set the timeout that is used to cache the suggested network parameters (by default 3 seconds)
+- `algorand.getSuggestedParams()` - Get the current suggested network parameters object, either the cached value, or if the cache has expired a fresh value

package/dist/resources/knowledge/taxonomy/algokit:utils:typescript:capabilities:amount.md

@@ -0,0 +1,51 @@
+# Algo amount handling
+
+Algo amount handling is one of the core capabilities provided by AlgoKit Utils. It allows you to reliably and tersely specify amounts of microAlgo and Algo and safely convert between them.
+
+Any AlgoKit Utils function that needs an Algo amount will take an `AlgoAmount` object, which ensures that there is never any confusion about what value is being passed around. Whenever an AlgoKit Utils function calls into an underlying algosdk function, or if you need to take an `AlgoAmount` and pass it into an underlying algosdk function (per the [modularity principle](../README.md#core-principles)) you can safely and explicitly convert to microAlgo or Algo.
+
+To see some usage examples check out the [automated tests](../../src/types/amount.spec.ts). Alternatively, you see the [reference documentation](../code/classes/types_amount.AlgoAmount.md) for `AlgoAmount`.
+
+## `AlgoAmount`
+
+The `AlgoAmount` class provides a safe wrapper around an underlying `number` amount of microAlgo where any value entering or existing the `AlgoAmount` class must be explicitly stated to be in microAlgo or Algo. This makes it much safer to handle Algo amounts rather than passing them around as raw `number`'s where it's easy to make a (potentially costly!) mistake and not perform a conversion when one is needed (or perform one when it shouldn't be!).
+
+To import the AlgoAmount class you can access it via:
+
+```typescript
+import { AlgoAmount } from '@algorandfoundation/algokit-utils/types/amount'
+```
+
+You may not need to import this type to use it though since there are also special methods that are exposed from the root AlgoKit Utils export and also others that extend the `number` protoype per below.
+
+### Creating an `AlgoAmount`
+
+There are a few ways to create an `AlgoAmount`:
+
+- Algo
+  - Constructor: `new AlgoAmount({algo: 10})`
+  - Static helper: `AlgoAmount.algo(10)`
+  - AlgoKit Helper: `algo(10)`
+  - Number coersion: `(10).algo()` (note: you have to wrap the number in brackets or have it in a variable or function return, a raw number value can't have a method called on it)
+- microAlgo
+  - Constructor: `new AlgoAmount({microAlgos: 10_000})`
+  - Static helper: `AlgoAmount.algo(10)`
+  - AlgoKit Helper: `microAlgo(10_000)`
+  - Number coersion: `(10_000).microAlgo()` (note: you have to wrap the number in brackets or have it in a variable or function return, a raw number value can't have a method called on it)
+
+Note: per above, to use any of the versions that reference `AlgoAmount` type itself you need to import it:
+
+```typescript
+import { AlgoAmount } from '@algorandfoundation/algokit-utils/types/amount'
+```
+
+### Extracting a value from `AlgoAmount`
+
+The `AlgoAmount` class has properties to return Algo and microAlgo:
+
+- `amount.algo` - Returns the value in Algo
+- `amount.microAlgo` - Returns the value in microAlgo
+
+`AlgoAmount` will coerce to a `number` automatically (in microAlgo), which is not recommended to be used outside of allowing you to use `AlgoAmount` objects in comparison operations such as `<` and `>=` etc.
+
+You can also call `.toString()` or use an `AlgoAmount` directly in string interpolation to convert it to a nice user-facing formatted amount expressed in microAlgo.