@goplausible/algorand-mcp 3.0.7

package/dist/resources/knowledge/taxonomy/developer:docs:run-a-node:setup:node-troubleshooting.md

@@ -0,0 +1,190 @@
+title: Node Troubleshooting
+
+# Do you want to run a node yourself?
+
+If you are a developer, running a private network using [AlgoKit](/docs/get-started/algokit) is simpler and provide more flexibility.
+
+Running a production node for MainNet is very beneficial for decentralization.
+However, as any unmanaged system (and any blockchain node/indexer), to achieve high SLA, running a production node has many requirements: appropriate redundancy (some upgrades create downtime on nodes), 24/7 monitoring, regular maintenance, use of a staging environment for testing updates, ...
+
+!!! tip
+    Subscribe to notifications on [Forum](https://forum.algorand.org/c/announcements/5) to be aware of new releases. Read carefully all release notes as some updates may create downtimes or may require some configuration changes. It is recommended to systematically update to new releases after testing in a non-production environment.
+
+You can consider using [third-party API services](https://developer.algorand.org/ecosystem-projects/?tags=api-services) or a third-party provider to help setting/maintaining a node.
+
+# First steps
+
+Be sure to have your `$PATH` and `$ALGORAND_DATA` environment variables set properly and that your node is running. In particular:
+
+```bash
+goal node status
+```
+
+should return something like:
+
+```
+Last committed block: 23119736
+Time since last block: 0.1s
+Sync Time: 2.7s
+Last consensus protocol: https://github.com/algorandfoundation/specs/tree/d5ac876d7ede07367dbaa26e149aa42589aac1f7
+Next consensus protocol: https://github.com/algorandfoundation/specs/tree/d5ac876d7ede07367dbaa26e149aa42589aac1f7
+Round for next consensus protocol: 23119737
+Next consensus protocol supported: true
+Last Catchpoint:
+Genesis ID: testnet-v1.0
+Genesis hash: SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=
+```
+
+Read [Install a Node](../install) to set these variables properly.
+
+If you see:
+
+* `Data directory not specified.  Please use -d or set $ALGORAND_DATA in your environment. Exiting.`: `$ALGORAND_DATA` is not properly set up.
+* `command not found: goal`: `$PATH` is not properly set up.
+* `Cannot contact Algorand node: open ...: no such file or directory`: the node is not started. Starting a node is done differently depending on the installation method. See sections "Start the node" from [Install a Node](/docs/run-a-node/setup/install).
+    
+# Common Issues for algod
+
+## Most common issues: wrong version, wrong network, not caught up
+
+One of the most common issues are that the node is on the wrong network, has the wrong algod version, or is not fully synced.
+
+* **Check that the node is synced/caught up** following [Catchup and Status](/docs/run-a-node/operations/catchup). See below if the node is not syncing.
+* **Check that the node is on the right network**: when running `goal node status`, `Genesis ID` must be `mainnet-v1.0` for MainNet, `testnet-v1.0` for TestNet, `betanet-v1.0` for BetaNet. See [Switch Networks](/docs/run-a-node/operations/switch_networks) to solve this issue.
+* **Check that the version** reported of `algod -v` and `goal version -v` are the latest stable release (if using MainNet or TestNet) or the latest beta release (if using BetaNet). See the [official repo](https://github.com/algorand/go-algorand/releases) for the list of all releases. Beta releases are clearly marked as such.
+
+## My node is not syncing/catching up at all (Last Committed Block is 0)
+
+As soon as the node is started, the `Last Committed Block` from `goal node status` should be increasing.
+If it stays 0, the node is not syncing/catching up at all.
+This is usually due to a connectivity issue or a DNS restriction imposed by the ISP.
+
+### No connectivity
+
+First, check that the node has proper internet access.
+To check it with the command line, you may use `curl https://example.com`.
+
+### DNS restrictions
+
+By default, a node gets the list of relays it needs to connect to by reading DNS SRV records.
+To ensure those records are not tampered with, the node uses DNSSec.
+
+The node will first try to use the system DNS. If it fails, it will use the fallback DNS from `config.json` (if provided). If this fails again, it will try hardcoded DNS from [tools/network/dnssec/config.go](https://github.com/algorand/go-algorand/blob/master/tools/network/dnssec/config.go).
+
+Some ISP, enterprise networks, or public networks only allows DNS queries to their own DNS server that may not support DNSSec.
+In that case, you will need to set `"DNSSecurityFlags": 0` inside `$ALGORAND_DATA/config.json`.
+
+!!! warning
+    Setting `DNSSecurityFlags` to `0` lowers the security of the node and may allow attackers to make your node connect to untrustworthy relays. While untrustworthy relays cannot make your node accept invalid blocks or create invalid transactions, they may censor all transactions from your nodes or may prevent your node from syncing by not providing the latest blocks. It is strongly recommended to enable DNSSec in production.
+
+!!! tip
+    Do not forget to restart `algod` after any change to the configuration.
+    
+To check if your node's DNS access is correct, run the following commands in the terminal:
+
+```
+dig -t SRV _algobootstrap._tcp.mainnet.algorand.network +dnssec
+dig -t SRV _algobootstrap._tcp.mainnet.algorand.network @8.8.8.8 +dnssec
+```
+
+at least one of them must return a list of relays without any error nor warning.
+(The first command uses the system DNS while the second one uses Google DNS.)
+    
+### Other issues
+
+Here are other less common reasons for a node not being able to catch up at all.
+
+* Check the presence of the right `genesis.json` file in `$ALGORAND_DATA`. See the documentation on how to [switch networks](/docs/run-a-node/operations/switch_networks/).
+* If using BetaNet, check that `$ALGORAND_DATA/config.json` contains the right `DNSBootstrapID`. See the [configuration for BetaNet](/docs/run-a-node/operations/switch_networks/#dns-configuration-for-betanet).
+
+## My node is syncing/catching up very slowly (without fast catchup)
+
+Syncing without fast catchup is expecting to take a 2 to 4 weeks in November 2022, due to the amount of data on the Algorand blockchain.
+In addition, syncing will slow down as rounds increases, as newer blocks usually contain many more transactions than older blocks.
+
+!!! tip
+    Remember that non-archival node can be synced faster using [fast catchup](/docs/run-a-node/setup/install#sync-node-network-using-fast-catchup). Archival nodes cannot use fast catchup but algonode.io, a third-party service, provides [snapshots of archival nodes](https://algonode.io/extras/). This tip is NOT an endorsement of these snapshots and using these snapshots require careful weighting of associated risks: `algod` cannot verify that these snapshots are valid. In particular, `algod` cannot verify that these snapshots do not contain invalid data that would allow for double spending.
+
+If it looks like your node will take much longer than 4 weeks for syncing, then:
+
+1. Check that your node has the right [hardware requirements](/docs/run-a-node/setup/install/#hardware-requirements). In particular, if your node has less than 4GB (or ideally 8GB) of RAM and/or an HDD/slow-SATA-SSD/SD, then you will not be able to catch up on MainNet.
+2. Check that your node is not overused:
+    1. Check RAM and CPU use using `top` or `htop`
+    2. Check free disk using `df -h`
+3. Check that your Internet connection is fast enough using a speed test. You need to have at least a 100Mbps connection and low enough latency (below 100ms is most likely needed).  
+4. While there are relays all over the world, some regions may have a few number of relays which may slow down catching up. Check latency to the best relays using [algonode.io](https://algonode.io/extras/) scripts (in the folder `utils` of https://snap.algonode.cloud/ --- copied below for completeness):
+    ```
+    #!/bin/bash
+
+    # needs dig from dnsutils
+    N=$(dig +short srv _algobootstrap._tcp.mainnet.algorand.network @1.1.1.1 |wc -l)
+    echo "Querying $N nodes, be patient..."
+    echo "" > report.txt
+    for relay in $(dig +short srv _algobootstrap._tcp.mainnet.algorand.network @1.1.1.1|awk '{print $4 ":" $3}');
+    do
+      echo -n .
+      curl -s -o /dev/null --max-time 1 "http://$relay/v1/urtho/ledger/0"
+      echo -ne '\bo'
+      curl -s -o /dev/null --max-time 1 "http://$relay/v1/urtho/ledger/0" -w %{time_total} >> report.txt
+      echo -ne '\b+'
+      echo "s;$relay" >> report.txt
+    done
+
+    echo "Top 20 nodes"
+    sort -n report.txt | head -20
+    ```
+    
+    Latency above 100ms to the top 20 relays may most likely cause issues.
+5. Check that `$ALGORAND_DATA/config.json` is either absent or only contain the non-default parameters you actually need to change. Only change parameters if you understand the consequences, some parameter changes may significantly slow down syncing. 
+
+
+## My node is not syncing/catching up with fast catchup
+
+See [troubleshooting for fast catchup](/docs/run-a-node/setup/install#troubleshooting-for-fast-catchup).
+
+## Other issues
+
+### I get an `overspend` error when sending a transaction
+
+If sending a transaction results in an `overspend` error (i.e., the word `overspend` appears in the error):
+1. Check that the account has enough Algos on a [block explorer](https://developer.algorand.org/ecosystem-projects/?tags=block-explorers).
+2. Check that your node is [synced and on the right network](#Most-common-issues-wrong-version-wrong-network-not-caught-up).
+3. Do not forget to take into account:
+    1. The [minimum balance requirement](/docs/get-details/parameter_tables/#minimum-balance) of 0.1 Algo for a basic account (more if ASA or applications are created or used).
+    2. The [fee](/docs/get-details/transactions/#fees) paid by the sender of the transaction.
+
+
+## None of the above works
+
+If none of the above works, you can look for additional information on the [third-party algonode.io FAQ](https://algonode.io/faq/#algorand-faq).
+
+If this still does not solve your issue, please open a new post on [Forum](https://forum.algorand.org) with the following information:
+
+* what you are trying to do and what fails (with full command lines tried and outputs written in triple backquotes)
+* OS version
+* machine specs: number of CPU, size of RAM, disk type (NVMe SSD, SATA SSD, ...)
+* actual use: memory available, disk available, ...
+* algod version: `algod -v`
+* goal version: `goal version -v`
+* goal status: `goal node status`
+* content of `config.json` (in the data folder `$ALGORAND_DATA`)
+* link to the files `algod-out.log`, `algod-err.log`, `node.log` (in the data folder `$ALGORAND_DATA`) uploaded in a Github gist or equivalent system
+
+
+!!! tip
+    Always write code/long outputs between triple backquotes or use the "code" button to facilitate the user reading
+    
+        ```
+        $ goal node status
+
+        Last committed block: 23119736
+        Time since last block: 0.1s
+        Sync Time: 2.7s
+        Last consensus protocol: https://github.com/algorandfoundation/specs/tree/d5ac876d7ede07367dbaa26e149aa42589aac1f7
+        Next consensus protocol: https://github.com/algorandfoundation/specs/tree/d5ac876d7ede07367dbaa26e149aa42589aac1f7
+        Round for next consensus protocol: 23119737
+        Next consensus protocol supported: true
+        Last Catchpoint:
+        Genesis ID: testnet-v1.0
+        Genesis hash: SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=
+        ```

package/dist/resources/knowledge/taxonomy/developer:docs:run-a-node:setup:types.md

@@ -0,0 +1,77 @@
+title: Algorand node types
+
+The Algorand network is comprised of two distinct types of nodes, **relay nodes**, and **non-relay nodes**. Relay nodes are primarily used for communication routing to a set of connected non-relay nodes. Relay nodes communicate with other relay nodes and route blocks to all connected non-relay nodes. Non-relay nodes only connect to relay nodes and can also participate in consensus. Non-relay nodes may connect to several relay nodes but never connect to another non-relay node.
+
+In addition to the two node types, nodes can be configured to be [**archival**](#archival-mode). Archival nodes store the entire ledger, as opposed to the last 1000 blocks for non-archival blocks. Relay nodes are necessarily archival. Non-relay archival nodes are often used to feed an [**indexer**](../indexer/) that allows more advanced queries on the history of the blockchain.
+
+Finally, a node may either participate in consensus or not. Participation nodes do not need to be archival. In addition, to reduce attack surfaces and outage risks, it is strongly recommended that participation nodes are only used for the purpose in participating in consensus. In particular, participation nodes should not be relays.
+
+All node types use the same install procedure. To setup a node for a specific type, requires a few configuration parameter changes or operations as described below. The default install will set the node up as a non-relay non-archival non-participation mode.
+
+The table below is a summary of possible configurations:
+
+| Relay? | Archival? | Participation? | |
+|-|-|-|-|
+| relay | archival | participation | ❌ insecure / strongly discouraged |
+| relay | archival | non-participation | ✅ normal configuration for a **relay** |
+| relay | non-archival | * | ❌ impossible |
+| non-relay | archival | participation | ❓ discouraged, as participation nodes do not need to be archival and should only be used for participation, and not used for any other purpose |
+| non-relay | archival | non-participation | ✅ normal configuration for an **archival node**, often connected to an [**indexer**](../indexer/) |
+| non-relay | non-archival | participation | ✅ normal configuration for a **participation node** |
+| non-relay | non-archival | non-particiption | ✅ normal configuration for a node used to submit transactions to the blockchain and access current state (current balances, smart contract state, ...) but no historical state |
+
+
+# Which mode do I need?
+
+Here are some common use cases:
+
+* I want to participate in consensus and help secure the Algorand network.
+    * ➥ non-relay non-archival participation node.
+    * Note: I need to have some Algos for that purpose and I need to monitor my node 24/7 to ensure it is working properly.
+* I want to send transactions and read current state of smart contracts/applications:
+    * ➥ non-relay non-archival non-participation node.
+    * Example: a dApp website that does not use any historical information (past transaction/operation), a website displaying balances of a list of important accounts.
+* I want full access to historical data (blocks, transactions) with advanced querying:
+    * ➥ non-relay archival non-participation node, together with an [**indexer**](../indexer/).
+* I want to get state proofs for any block:
+    * ➥ non-relay archival non-participation node.
+
+# Participation Node 
+How to install a node is described [here](../install/).  Classifying a node as a participation node is not a configuration parameter but a dynamic operation where the node is hosting participation keys for one or more online accounts. This process is described in [Participate in Consensus](../participate/index.md). Technically both non-relay and relay nodes can participate in consensus, but Algorand recommends *only* non-relay nodes participate in consensus. 
+
+!!! info
+    Non-relay nodes do not have to participate in consensus. They still have access to the ledger and can be used with applications that need to connect to the network to submit transactions and read block data. 
+
+
+# Archival Mode
+
+By default non-relay nodes only store a limited number of blocks (approximately up to the last 1000 blocks) locally. Older blocks are dropped from the local copy of the ledger. This reduces the disk space requirement of the node. These nodes can still participate in consensus and applications can connect to these nodes for transaction submission and reading block data. The primary drawback for this type of operation is that older block data will not be available.
+
+The archival property must be set to true to run in archival mode, which will then set the node to store the entire ledger.
+
+!!! warning
+     Setting a node to run in archival mode on MainNet/TestNet/BetaNet will significantly increase the disk space requirements for the node. For example, in September 2023, a MainNet non-archival node uses around 20GB of storage, while an archival node requires approximately 2TB of storage.
+
+
+!!! info
+    Relay nodes are always set to Archival mode. Non-relay nodes have the option to run in either configuration.
+
+# Relay Node
+
+A relay node uses the same software install as a non-relay node and only requires setting a few additional configuration parameters.
+
+A node is a valid relay node if two things are true:
+
+1. The node is configured to accept incoming connections on a publicly-accessible port (4160 by convention on MainNet, and 4161 on TestNet, except if behind a proxy in which case port 80 is used.).
+2. The node's public IP address (or a valid DNS name) and assigned port are registered in Algorand's SRV records for a specific network (MainNet/TestNet).
+   
+Relay nodes are where other nodes connect. Therefore, a relay node must be able to support a large number of connections and handle the processing load associated with all the data flowing to and from these connections. Thus, relay nodes require significantly more power than non-relay nodes. Relay nodes are always configured in archival mode.
+
+Relay nodes also require very high egress bandwidth. In October 2022, MainNet relay nodes egress bandwidth is between 10TB to 30TB per month.
+
+See [Configuring Node as a Relay](../../reference/relay) for more information on setting up a relay.
+
+
+
+
+

package/dist/resources/knowledge/taxonomy/developer:docs:sdks:go:index.md

@@ -0,0 +1,189 @@
+title: Go SDK: Your First Transaction
+
+This section is a quick start guide for interacting with the Algorand network using Go. This guide will help to install [Algorand sandbox](https://github.com/algorand/sandbox){target=blank}, which provides a node for testing and development. This guide will also help to install the Go SDK, create an account and submit your first transaction on Algorand.  
+ 
+# Install Sandbox
+
+!!! info
+    This step is only required if you are not using AlgoKit. If you are using AlgoKit, you can spin up a sandbox using the LocalNet, see [AlgoKit getting started guide](/docs/get-started/algokit/#start-a-localnet) for more information. 
+	
+!!! Prerequisites
+    - Docker Compose ([install guide](https://docs.docker.com/compose/install/))
+    - Git ([install guide](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git))
+
+Algorand provides a docker instance for setting up a node, which can be used to get started developing quickly. To install and use this instance, follow these instructions.
+
+```bash
+git clone https://github.com/algorand/sandbox.git
+cd sandbox
+./sandbox up dev 
+```
+
+This will install and start private network. To read more about Algorand networks see [Algorand Networks](../../get-details/algorand-networks/index.md){target=_blank}. 
+
+[More Information about the sandbox](https://developer.algorand.org/articles/introducing-sandbox-20/) and [how to use](https://developer.algorand.org/tutorials/exploring-the-algorand-sandbox/) it.
+
+ 
+
+# Install Go SDK
+Algorand provides an SDK for Go. 
+
+!!! Prerequisites
+    - Go programming language ([install guide](https://golang.org/doc/install))
+
+From a terminal window, install the Go SDK:
+
+```bash
+go get -u github.com/algorand/go-algorand-sdk/v2
+```
+
+The [GitHub repository](https://github.com/algorand/go-algorand-sdk){target=_blank} contains additional documentation and examples.
+
+See the JavaScript SDK [reference documentation](https://pkg.go.dev/github.com/algorand/go-algorand-sdk/v2){target=_blank} for more information on methods.  
+
+The SDK is installed and can now interact with the running Algorand Sandbox environment, as configured above.
+
+# Create an account
+In order to interact with the Algorand blockchain, you must have a funded account on the network. To quickly create a test account use the following code.
+
+<!-- ===GOSDK_ACCOUNT_GENERATE=== -->
+```go
+account := crypto.GenerateAccount()
+mn, err := mnemonic.FromPrivateKey(account.PrivateKey)
+
+if err != nil {
+	log.Fatalf("failed to generate account: %s", err)
+}
+
+log.Printf("Address: %s\n", account.Address)
+log.Printf("Mnemonic: %s\n", mn)
+```
+[Snippet Source](https://github.com/algorand/go-algorand-sdk/blob/examples/examples/account/main.go#L16-L25)
+<!-- ===GOSDK_ACCOUNT_GENERATE=== -->
+
+[`More Information`](../../get-details/accounts/create.md#standalone){target=_blank}  
+
+!!! Warning 
+    Never share your mnemonic passphrase or private keys. Production environments require stringent private key management. For more information on key management in community Wallets, click [here](https://developer.algorand.org/docs/community/#wallets). For the open source [Algorand Wallet](https://developer.algorand.org/articles/algorand-wallet-now-open-source/), click [here](https://github.com/algorand/algorand-wallet).
+
+ 
+# Fund the account
+Before sending transactions to the Algorand network, the account must be funded to cover the minimal transaction fees that exist on Algorand. In this example, we'll be using prefunded accounts available in the Sandbox. To fund an account on Testnet account use the [Algorand faucet](https://dispenser.testnet.aws.algodev.network/){target=_blank}. 
+
+!!! Info
+    All Algorand accounts require a minimum balance to be registered in the ledger. To read more about Algorand minimum balance see [Account Overview](https://developer.algorand.org/docs/features/accounts/#minimum-balance)
+
+
+# Connect Your Client
+An Algod client must be instantiated prior to making calls to the API endpoints. You must provide values for `<algod-address>` and `<algod-token>`. The CLI tools implement the client natively. By default, the `algodToken` for each [sandbox](https://github.com/algorand/sandbox) is set to its `aaa...` value and the `algodAddress` corresponds to `http://localhost:4001`.
+
+
+<!-- ===GOSDK_ALGOD_CREATE_CLIENT=== -->
+```go
+// Create a new algod client, configured to connect to out local sandbox
+var algodAddress = "http://localhost:4001"
+var algodToken = strings.Repeat("a", 64)
+algodClient, _ := algod.MakeClient(
+	algodAddress,
+	algodToken,
+)
+
+// Or, if necessary, pass alternate headers
+
+var algodHeader common.Header
+algodHeader.Key = "X-API-Key"
+algodHeader.Value = algodToken
+algodClientWithHeaders, _ := algod.MakeClientWithHeaders(
+	algodAddress,
+	algodToken,
+	[]*common.Header{&algodHeader},
+)
+```
+[Snippet Source](https://github.com/algorand/go-algorand-sdk/blob/examples/examples/overview/main.go#L18-L36)
+<!-- ===GOSDK_ALGOD_CREATE_CLIENT=== -->
+ 
+!!! Info
+    The example code connects to the sandbox Algod client. If you want to connect to a public API client, change the host, port, and token parameters to match the API service. See some service available [here](https://developer.algorand.org/ecosystem-projects/?tags=api-services)
+
+!!! Info
+    If you are connecting to the Testnet, a dispenser is available [here](https://dispenser.testnet.aws.algodev.network/){target=_blank}
+
+# Check Your Balance
+Before moving on to the next step, make sure your account has been funded.
+ 
+ <!-- ===GOSDK_ALGOD_FETCH_ACCOUNT_INFO=== -->
+```go
+acctInfo, err := algodClient.AccountInformation(acct.Address.String()).Do(context.Background())
+if err != nil {
+	log.Fatalf("failed to fetch account info: %s", err)
+}
+log.Printf("Account balance: %d microAlgos", acctInfo.Amount)
+```
+[Snippet Source](https://github.com/algorand/go-algorand-sdk/blob/examples/examples/overview/main.go#L51-L56)
+ <!-- ===GOSDK_ALGOD_FETCH_ACCOUNT_INFO=== -->
+
+
+# Build First Transaction
+Transactions are used to interact with the Algorand network. To create a payment transaction use the following code.
+
+<!-- ===GOSDK_TRANSACTION_PAYMENT_CREATE=== -->
+```go
+sp, err := algodClient.SuggestedParams().Do(context.Background())
+if err != nil {
+	log.Fatalf("failed to get suggested params: %s", err)
+}
+// payment from account to itself
+ptxn, err := transaction.MakePaymentTxn(acct.Address.String(), acct.Address.String(), 100000, nil, "", sp)
+if err != nil {
+	log.Fatalf("failed creating transaction: %s", err)
+}
+```
+[Snippet Source](https://github.com/algorand/go-algorand-sdk/blob/examples/examples/overview/main.go#L59-L68)
+<!-- ===GOSDK_TRANSACTION_PAYMENT_CREATE=== -->
+
+!!! Info
+    Algorand supports many transaction types. To see what types are supported see [Transactions](https://developer.algorand.org/docs/features/transactions/).
+
+
+# Sign First transaction
+Before the transaction is considered valid, it must be signed by a private key. Use the following code to sign the transaction.
+
+<!-- ===GOSDK_TRANSACTION_PAYMENT_SIGN=== -->
+```go
+_, sptxn, err := crypto.SignTransaction(acct.PrivateKey, ptxn)
+if err != nil {
+	fmt.Printf("Failed to sign transaction: %s\n", err)
+	return
+}
+```
+[Snippet Source](https://github.com/algorand/go-algorand-sdk/blob/examples/examples/overview/main.go#L71-L76)
+<!-- ===GOSDK_TRANSACTION_PAYMENT_SIGN=== -->
+
+!!! Info
+    Algorand provides many ways to sign transactions. To see other ways see [Authorization](https://developer.algorand.org/docs/features/transactions/signatures/#single-signatures).
+
+
+# Submit transaction
+The signed transaction can now be broadcast to the network for validation and inclusion in a future block. The `waitForConfirmation` SDK method polls the `algod` node for the transaction ID to ensure it succeeded.
+
+<!-- ===GOSDK_TRANSACTION_PAYMENT_SUBMIT=== -->
+```go
+pendingTxID, err := algodClient.SendRawTransaction(sptxn).Do(context.Background())
+if err != nil {
+	fmt.Printf("failed to send transaction: %s\n", err)
+	return
+}
+confirmedTxn, err := transaction.WaitForConfirmation(algodClient, pendingTxID, 4, context.Background())
+if err != nil {
+	fmt.Printf("Error waiting for confirmation on txID: %s\n", pendingTxID)
+	return
+}
+fmt.Printf("Confirmed Transaction: %s in Round %d\n", pendingTxID, confirmedTxn.ConfirmedRound)
+```
+[Snippet Source](https://github.com/algorand/go-algorand-sdk/blob/examples/examples/overview/main.go#L79-L90)
+<!-- ===GOSDK_TRANSACTION_PAYMENT_SUBMIT=== -->
+ 
+# Viewing the Transaction
+To view the transaction we submitted to the sandbox Algod, open [Lora](https://lora.algokit.io/localnet){target=_blank} and choose `LocalNet` configuration option, then search for the transaction ID. 
+
+To view a transaction submitted to public network like testnet, open [Lora](https://lora.algokit.io/testnet){target=_blank} or [Pera Explorer](https://testnet.explorer.perawallet.app/){target=blank} and paste the transaction ID into the search bar.

package/dist/resources/knowledge/taxonomy/developer:docs:sdks:index.md

@@ -0,0 +1,38 @@
+title: Section Index 
+
+The **SDKs** section contains documentation and how-tos for all Algorand Developed SDKs. Code examples are embedded throughout in each of the SDKs.
+
+You can use the SDKs to interact with the network by connecting to one of the REST servers and submitting requests for data or submitting transactions.   They also contain methods to help construct and sign transactions or deal with encoding/decoding of things like addresses and mnemonics.
+
+
+## Algorand supported
+
+### Python
+
+* [Python Section](./python/)
+* [Python Repository](https://github.com/algorand/py-algorand-sdk)
+* [Python Docs](https://py-algorand-sdk.readthedocs.io/en/latest/)
+
+### JavaScript
+
+* [JavaScript Section](./javascript/)
+* [JavaScript Repository](https://github.com/algorand/js-algorand-sdk)
+* [JavaScript Docs](https://algorand.github.io/js-algorand-sdk/)
+
+### Go
+
+* [Go Section](./go/)
+* [Go Repository](https://github.com/algorand/go-algorand-sdk)
+* [Go Docs](https://pkg.go.dev/github.com/algorand/go-algorand-sdk)
+
+### Java
+
+* [Java Section](./java/)
+* [Java Repository](https://github.com/algorand/java-algorand-sdk)
+* [Java Docs](https://algorand.github.io/java-algorand-sdk/)
+
+
+## Community Supported
+
+There are also community supported SDKs [available](https://developer.algorand.org/ecosystem-projects/?tags=sdk) for other popular languages like Rust, C# and Dart.
+