feat(docs): add xrpl-go GoLang package to XRPLF documentation site

docs/tutorials/how-tos/send-xrp.md

@@ -28,7 +28,7 @@ To interact with the XRP Ledger, you need to set up a dev environment with the n
 - **Python** with the [`xrpl-py` library](https://xrpl-py.readthedocs.io/). See [Get Started using Python](../python/build-apps/get-started.md) for setup steps.
 - **Java** with the [xrpl4j library](https://github.com/XRPLF/xrpl4j). See [Get Started Using Java](../java/build-apps/get-started.md) for setup steps.
 - **PHP** with the [XRPL_PHP library](https://github.com/AlexanderBuzz/xrpl-php). See [Get Started Using PHP](../php/build-apps/get-started.md) for setup steps.
-
+- **GoLang** with the [xrpl-go library](https://github.com/Peersyst/xrpl-go). See [Get Started Using GoLang](../go/build-apps/get-started.md) for setup steps.
 
 ## Send a Payment on the Test Net
 
@@ -54,6 +54,10 @@ To transact on the XRP Ledger, you need an address and secret key, and some XRP.
 {% code-snippet file="/_code-samples/send-xrp/php/send-xrp.php" from="// Example credentials" before="// Create" language="php" /%}
 {% /tab %}
 
+{% tab label="GoLang" %}
+{% code-snippet file="/_code-samples/send-xrp/go/ws/main.go" from="// Example credentials" before="// Funding" language="go" /%}
+{% /tab %}
+
 {% /tabs %}
 
 The secret key shown here is for example only. For development purposes, you can get your own credentials, pre-funded with XRP, on the Testnet using the following interface:
@@ -87,6 +91,10 @@ The following code connects to a public Testnet servers:
 {% code-snippet file="/_code-samples/send-xrp/php/send-xrp.php" from="// Create a client" before="// Transaction definition" language="php" /%}
 {% /tab %}
 
+{% tab label="GoLang" %}
+{% code-snippet file="/_code-samples/send-xrp/go/ws/main.go" from="func main()" before="if !client.IsConnected() " language="go" /%}
+{% /tab %}
+
 {% /tabs %}
 
 For this tutorial, click the following button to connect:
@@ -142,6 +150,10 @@ Here's an example of preparing the above payment:
 {% code-snippet file="/_code-samples/send-xrp/php/send-xrp.php" from="// Transaction definition" before="// Sign" language="php" /%}
 {% /tab %}
 
+{% tab label="GoLang" %}
+{% code-snippet file="/_code-samples/send-xrp/go/ws/main.go" from="// Prepare " before="// Sign" language="go" /%}
+{% /tab %}
+
 {% /tabs %}
 
 {% interactive-block label="Prepare" steps=$frontmatter.steps %}
@@ -172,6 +184,7 @@ Signing a transaction uses your credentials to authorize the transaction on your
 - **Python:** Use the [`xrpl.transaction.safe_sign_transaction()` method](https://xrpl-py.readthedocs.io/en/latest/source/xrpl.transaction.html#xrpl.transaction.safe_sign_transaction) with a model and `Wallet` object.
 - **Java:** Use a [`SignatureService`](https://javadoc.io/doc/org.xrpl/xrpl4j-crypto-core/latest/org/xrpl/xrpl4j/crypto/signing/SignatureService.html) instance to sign the transaction. For this tutorial, use the [`SingleKeySignatureService`](https://javadoc.io/doc/org.xrpl/xrpl4j-crypto-bouncycastle/latest/org/xrpl/xrpl4j/crypto/signing/SingleKeySignatureService.html).
 - **PHP:** Use a [`sign()` method of a `Wallet` instance](https://alexanderbuzz.github.io/xrpl-php-docs/wallet.html#signing-a-transaction) instance to sign the transaction. The input to this step is a completed array of transaction instructions.
+- **GoLang:** Use the [`Sign()` method of the `Wallet` package](https://pkg.go.dev/github.com/Peersyst/xrpl-go@v0.1.12/xrpl/wallet) to sign the transaction. 
 
 {% tabs %}
 
@@ -191,6 +204,10 @@ Signing a transaction uses your credentials to authorize the transaction on your
 {% code-snippet file="/_code-samples/send-xrp/php/send-xrp.php" from="// Sign" before="// Submit" language="php" /%}
 {% /tab %}
 
+{% tab label="GoLang" %}
+{% code-snippet file="/_code-samples/send-xrp/go/ws/main.go" from="// Sign" before="// Submit" language="go" /%}
+{% /tab %}
+
 {% /tabs %}
 
 The result of the signing operation is a transaction object containing a signature. Typically, XRP Ledger APIs expect a signed transaction to be the hexadecimal representation of the transaction's canonical [binary format](../../references/protocol/binary-format.md), called a "blob".
@@ -199,6 +216,7 @@ The result of the signing operation is a transaction object containing a signatu
 - In `xrpl-py`, you can get the transaction's hash in the response to submitting it in the next step.
 - In xrpl4j, `SignatureService.sign` returns a `SignedTransaction`, which contains the transaction's hash, which you can use to look up the transaction later.
 - In `XRPL_PHP`, the signing API also returns the transaction's ID, or identifying hash, which you can use to look up the transaction later. This is a 64-character hexadecimal string that is unique to this transaction.
+- In `xrpl-go`, the signing API also returns the transaction's ID, or identifying hash, which you can use to look up the transaction later. This is a 64-character hexadecimal string that is unique to this transaction.
 
 {% interactive-block label="Sign" steps=$frontmatter.steps %}
 
@@ -217,6 +235,7 @@ Now that you have a signed transaction, you can submit it to an XRP Ledger serve
 - **Python:** Use the [`xrpl.transaction.submit_and_wait()` method](https://xrpl-py.readthedocs.io/en/stable/source/xrpl.transaction.html#xrpl.transaction.submit_and_wait) to submit a transaction to the network and wait for a response.
 - **Java:** Use the [`XrplClient.submit(SignedTransaction)` method](https://javadoc.io/doc/org.xrpl/xrpl4j-client/latest/org/xrpl/xrpl4j/client/XrplClient.html#submit(org.xrpl.xrpl4j.crypto.signing.SignedTransaction)) to submit a transaction to the network. Use the [`XrplClient.ledger()`](https://javadoc.io/doc/org.xrpl/xrpl4j-client/latest/org/xrpl/xrpl4j/client/XrplClient.html#ledger(org.xrpl.xrpl4j.model.client.ledger.LedgerRequestParams)) method to get the latest validated ledger index.
 - **PHP:** Use the [`submitAndWait()` method of the Client](https://alexanderbuzz.github.io/xrpl-php-docs/client.html) to submit a transaction to the network and wait for the response.
+- **GoLang:** Use [`SubmitTxAndWait()` or `SubmitTxBlobAndWait()` methods os the Client](https://pkg.go.dev/github.com/Peersyst/xrpl-go@v0.1.12/xrpl/websocket#Client.SubmitTxAndWait) to submit a transaction to the network and wait for the response.
 
 {% tabs %}
 
@@ -236,6 +255,10 @@ Now that you have a signed transaction, you can submit it to an XRP Ledger serve
 {% code-snippet file="/_code-samples/send-xrp/php/send-xrp.php" from="// Submit" before="// Wait" language="php" /%}
 {% /tab %}
 
+{% tab label="GoLang" %}
+{% code-snippet file="/_code-samples/send-xrp/go/ws/main.go" from="// Submit" before="// Wait" language="go" /%}
+{% /tab %}
+
 {% /tabs %}
 
 This method returns the **tentative** result of trying to apply the transaction to the open ledger. This result _can_ change when the transaction is included in a validated ledger: transactions that succeed initially might ultimately fail, and transactions that fail initially might ultimately succeed. Still, the tentative result often matches the final result, so it's OK to get excited if you see `tesSUCCESS` here. 😁
@@ -273,6 +296,8 @@ Most transactions are accepted into the next ledger version after they're submit
 
 - **PHP:**  If you used the [`.submitAndWait()` method](https://alexanderbuzz.github.io/xrpl-php-docs/client.html), you can wait until the returned Promise resolves. Other, more asynchronous approaches are also possible.
 
+- **GoLang:** If you used the `SubmitTxAndWait()` or `SubmitTxBlobAndWait()` methods, the client will handle submission and wait until the transaction is confirmed in a ledger. Internally, these methods use a polling mechanism, querying the transaction status with the client's `Request()` method and a `TxRequest`.
+
 {% tabs %}
 
 {% tab label="JavaScript" %}
@@ -291,6 +316,10 @@ Most transactions are accepted into the next ledger version after they're submit
 {% code-snippet file="/_code-samples/send-xrp/php/send-xrp.php" from="// Wait" before="// Check" language="php" /%}
 {% /tab %}
 
+{% tab label="GoLang" %}
+{% code-snippet file="/_code-samples/send-xrp/go/ws/main.go" from="// Wait" before="// Check" language="go" /%}
+{% /tab %}
+
 {% /tabs %}
 
 {% partial file="/docs/_snippets/interactive-tutorials/wait-step.md" /%}
@@ -310,6 +339,8 @@ To know for sure what a transaction did, you must look up the outcome of the tra
 
 - **PHP:** Use the response from `submitAndWait()` or call the `tx method` using [`$client->syncRequest()`](https://alexanderbuzz.github.io/xrpl-php-docs/client.html).
 
+- **GoLang:** Use the response from `SubmitTxAndWait()` or `SubmitTxBlobAndWait()`, or manually query the transaction status using a `TxRequest` with the client's `Request()` method.
+
 {% tabs %}
 
 {% tab label="JavaScript" %}
@@ -328,6 +359,10 @@ To know for sure what a transaction did, you must look up the outcome of the tra
 {% code-snippet file="/_code-samples/send-xrp/php/send-xrp.php" from="// Check" language="php" /%}
 {% /tab %}
 
+{% tab label="GoLang" %}
+{% code-snippet file="/_code-samples/send-xrp/go/ws/main.go" from="// Check" language="go" /%}
+{% /tab %}
+
 {% /tabs %}
 
 {% admonition type="warning" name="Caution" %}XRP Ledger APIs may return tentative results from ledger versions that have not yet been validated. For example, in [tx method][] response, be sure to look for `"validated": true` to confirm that the data comes from a validated ledger version. Transaction results that are not from a validated ledger version are subject to change. For more information, see [Finality of Results](../../concepts/transactions/finality-of-results/index.md).{% /admonition %}
@@ -391,6 +426,16 @@ print_r("Seed: " . $wallet->getSeed()); // Example: sp6JS7f14BuwFY8Mw6bTtLKWauoU
 ```
 {% /tab %}
 
+{% tab label="GoLang" %}
+
+```go
+wallet, err := wallet.New(crypto.ED25519())
+fmt.Println("🌐 Classic Address:", wallet.ClassicAddress) // Example: r9ESeQQswbTxV8neiDTLTHXbXfUwiihyJk
+fmt.Println("🌐 Seed:", wallet.Seed) // Example: sEd7XGFGSWteam777HQHvw7vHypEWy2
+
+```
+{% /tab %}
+
 {% /tabs %}
 
 {% admonition type="danger" name="Warning" %}You should only use an address and secret that you generated securely, on your local machine. If another computer generated the address and secret and sent it to you over a network, it's possible that someone else on the network may see that information. If they do, they'll have as much control over your XRP as you do. It's also recommended not to use the same address for the Testnet and Mainnet, because transactions that you created for use on one network could also be valid to execute on the other network, depending on the parameters you provided.{% /admonition %}
@@ -433,6 +478,20 @@ $client = new JsonRpcClient("https://xrplcluster.com");
 ```
 {% /tab %}
 
+{% tab label="GoLang" %}
+
+```go
+client := websocket.NewClient(
+  websocket.NewClientConfig().
+    WithHost("wss://xrplcluster.com")
+)
+if err := client.Connect(); err != nil {
+  fmt.Println(err)
+  return
+}
+```
+{% /tab %}
+
 {% /tabs %}
 
 If you [install `rippled`](../../infrastructure/installation/index.md) yourself, it connects to the production network by default. (You can also [configure it to connect to the test net](../../infrastructure/configuration/connect-your-rippled-to-the-xrp-test-net.md) instead.) After the server has synced (typically within about 15 minutes of starting it up), you can connect to it locally, which has [various benefits](../../concepts/networks-and-servers/index.md). The following example shows how to connect to a server running the default configuration:
@@ -469,6 +528,20 @@ $client = new JsonRpcClient("http://localhost:5005");
 ```
 {% /tab %}
 
+{% tab label="GoLang" %}
+
+```go
+client := websocket.NewClient(
+  websocket.NewClientConfig().
+    WithHost("http://localhost:5005")
+)
+if err := client.Connect(); err != nil {
+  fmt.Println(err)
+  return
+}
+```
+{% /tab %}
+
 {% /tabs %}
 
 {% admonition type="success" name="Tip" %}The local connection uses an unencrypted protocol (`ws` or `http`) rather than the TLS-encrypted version (`wss` or `https`). This is secure only because the communications never leave the same machine, and is easier to set up because it does not require a TLS certificate. For connections on an outside network, always use `wss` or `https`.{% /admonition %}