ARCHIVE/xrpl-dev-portal
1
0
Fork 0
mirror of https://github.com/XRPLF/xrpl-dev-portal.git synced 2025-11-20 03:35:51 +00:00
Code Issues Packages Projects Releases Wiki Activity

chore(code-samples): remove all emojis

Browse Source
This commit is contained in:
banasa44
2025-08-25 11:27:50 +02:00
parent 22d67e640d
commit 162a97887e
40 changed files with 1125 additions and 1123 deletions
Download Patch File Download Diff File Expand all files Collapse all files

56
_code-samples/batch/go/rpc/main.go
View File

@@ -1,15 +1,15 @@
package main
import (
"fmt"
"fmt"
"github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/rpc"
"github.com/Peersyst/xrpl-go/xrpl/rpc/types"
"github.com/Peersyst/xrpl-go/xrpl/transaction"
txnTypes "github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/rpc"
"github.com/Peersyst/xrpl-go/xrpl/rpc/types"
"github.com/Peersyst/xrpl-go/xrpl/transaction"
txnTypes "github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
)
var (
@@ -56,7 +56,7 @@ func main() {
return
}
fmt.Println("⏳ Funding wallets...")
fmt.Println("Funding wallets...")
if err := client.FundWallet(&userWallet); err != nil {
fmt.Println(err)
return
@@ -65,7 +65,7 @@ func main() {
fmt.Println(err)
return
}
fmt.Println("💸 Wallets funded")
fmt.Println("Wallets funded")
// Check initial balances
userBalance, err := client.GetXrpBalance(userWallet.ClassicAddress)
@@ -82,9 +82,9 @@ func main() {
receiverBalance = "0"
}
fmt.Printf("💳 User initial balance: %s XRP\n", userBalance)
fmt.Printf("💳 User2 initial balance: %s XRP\n", user2Balance)
fmt.Printf("💳 Receiver initial balance: %s XRP\n", receiverBalance)
fmt.Printf("User initial balance: %s XRP\n", userBalance)
fmt.Printf("User2 initial balance: %s XRP\n", user2Balance)
fmt.Printf("Receiver initial balance: %s XRP\n", receiverBalance)
fmt.Println()
fmt.Printf("Batch transaction test\n")
@@ -103,13 +103,13 @@ func main() {
batchTx.SetAllOrNothingFlag()
flattenedBatchTx := batchTx.Flatten()
fmt.Println("⏳ Autofilling flattened batch transaction...")
fmt.Println("Autofilling flattened batch transaction...")
if err := client.Autofill(&flattenedBatchTx); err != nil {
fmt.Println("Autofill error:", err)
return
}
fmt.Println("⏳ Signing batch transaction...")
fmt.Println("Signing batch transaction...")
response, err := client.SubmitTxAndWait(flattenedBatchTx, &types.SubmitOptions{
Autofill: false,
Wallet: &userWallet,
@@ -119,9 +119,9 @@ func main() {
return
}
fmt.Println("✅ Batch transaction submitted")
fmt.Printf("🌐 Hash: %s\n", response.Hash.String())
fmt.Printf("🌐 Validated: %t\n", response.Validated)
fmt.Println("Batch transaction submitted")
fmt.Printf("Hash: %s\n", response.Hash.String())
fmt.Printf("Validated: %t\n", response.Validated)
fmt.Println()
// Check final balances
@@ -134,9 +134,9 @@ func main() {
finalReceiverBalance = "0"
}
fmt.Printf("💳 User final balance: %s XRP\n", finalUserBalance)
fmt.Printf("User final balance: %s XRP\n", finalUserBalance)
fmt.Printf("💳 Receiver final balance: %s XRP\n", finalReceiverBalance)
fmt.Printf("Receiver final balance: %s XRP\n", finalReceiverBalance)
fmt.Println()
fmt.Printf("Multisig Batch transaction test\n")
@@ -163,13 +163,13 @@ func main() {
multiBatchTx.SetAllOrNothingFlag()
flattenedMultiBatchTx := multiBatchTx.Flatten()
fmt.Println("⏳ Autofilling flattened multi batch transaction...")
fmt.Println("Autofilling flattened multi batch transaction...")
if err := client.AutofillMultisigned(&flattenedMultiBatchTx, 1); err != nil {
fmt.Println("Autofill error:", err)
return
}
fmt.Println("⏳ Signing multi batch transaction...")
fmt.Println("Signing multi batch transaction...")
if err := wallet.SignMultiBatch(user2Wallet, &flattenedMultiBatchTx, nil); err != nil {
fmt.Println("Signing error:", err)
return
@@ -184,9 +184,9 @@ func main() {
return
}
fmt.Println("✅ Multisig Batch transaction submitted")
fmt.Printf("🌐 Hash: %s\n", response.Hash.String())
fmt.Printf("🌐 Validated: %t\n", response.Validated)
fmt.Println("Multisig Batch transaction submitted")
fmt.Printf("Hash: %s\n", response.Hash.String())
fmt.Printf("Validated: %t\n", response.Validated)
fmt.Println()
// Check final balances
@@ -202,7 +202,7 @@ func main() {
if err != nil {
finalReceiverBalance = "0"
}
fmt.Printf("💳 User final balance: %s XRP\n", finalUserBalance)
fmt.Printf("💳 User2 final balance: %s XRP\n", finalUser2Balance)
fmt.Printf("💳 Receiver final balance: %s XRP\n", finalReceiverBalance)
fmt.Printf("User final balance: %s XRP\n", finalUserBalance)
fmt.Printf("User2 final balance: %s XRP\n", finalUser2Balance)
fmt.Printf("Receiver final balance: %s XRP\n", finalReceiverBalance)
}

56
_code-samples/batch/go/ws/main.go
View File

@@ -1,15 +1,15 @@
package main
import (
"fmt"
"fmt"
"github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/transaction"
txnTypes "github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/xrpl/websocket"
"github.com/Peersyst/xrpl-go/xrpl/websocket/types"
"github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/transaction"
txnTypes "github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/xrpl/websocket"
"github.com/Peersyst/xrpl-go/xrpl/websocket/types"
)
var (
@@ -58,7 +58,7 @@ func main() {
return
}
fmt.Println("⏳ Funding wallets...")
fmt.Println("Funding wallets...")
if err := client.FundWallet(&userWallet); err != nil {
fmt.Println(err)
return
@@ -67,7 +67,7 @@ func main() {
fmt.Println(err)
return
}
fmt.Println("💸 Wallets funded")
fmt.Println("Wallets funded")
// Check initial balances
userBalance, err := client.GetXrpBalance(userWallet.ClassicAddress)
@@ -84,9 +84,9 @@ func main() {
receiverBalance = "0"
}
fmt.Printf("💳 User initial balance: %s XRP\n", userBalance)
fmt.Printf("💳 User2 initial balance: %s XRP\n", user2Balance)
fmt.Printf("💳 Receiver initial balance: %s XRP\n", receiverBalance)
fmt.Printf("User initial balance: %s XRP\n", userBalance)
fmt.Printf("User2 initial balance: %s XRP\n", user2Balance)
fmt.Printf("Receiver initial balance: %s XRP\n", receiverBalance)
fmt.Println()
fmt.Printf("Batch transaction test\n")
@@ -105,13 +105,13 @@ func main() {
batchTx.SetAllOrNothingFlag()
flattenedBatchTx := batchTx.Flatten()
fmt.Println("⏳ Autofilling flattened batch transaction...")
fmt.Println("Autofilling flattened batch transaction...")
if err := client.Autofill(&flattenedBatchTx); err != nil {
fmt.Println("Autofill error:", err)
return
}
fmt.Println("⏳ Signing batch transaction...")
fmt.Println("Signing batch transaction...")
response, err := client.SubmitTxAndWait(flattenedBatchTx, &types.SubmitOptions{
Autofill: false,
Wallet: &userWallet,
@@ -121,9 +121,9 @@ func main() {
return
}
fmt.Println("✅ Batch transaction submitted")
fmt.Printf("🌐 Hash: %s\n", response.Hash.String())
fmt.Printf("🌐 Validated: %t\n", response.Validated)
fmt.Println("Batch transaction submitted")
fmt.Printf("Hash: %s\n", response.Hash.String())
fmt.Printf("Validated: %t\n", response.Validated)
fmt.Println()
// Check final balances
@@ -136,9 +136,9 @@ func main() {
finalReceiverBalance = "0"
}
fmt.Printf("💳 User final balance: %s XRP\n", finalUserBalance)
fmt.Printf("User final balance: %s XRP\n", finalUserBalance)
fmt.Printf("💳 Receiver final balance: %s XRP\n", finalReceiverBalance)
fmt.Printf("Receiver final balance: %s XRP\n", finalReceiverBalance)
fmt.Println()
fmt.Printf("Multisig Batch transaction test\n")
@@ -165,13 +165,13 @@ func main() {
multiBatchTx.SetAllOrNothingFlag()
flattenedMultiBatchTx := multiBatchTx.Flatten()
fmt.Println("⏳ Autofilling flattened multi batch transaction...")
fmt.Println("Autofilling flattened multi batch transaction...")
if err := client.AutofillMultisigned(&flattenedMultiBatchTx, 1); err != nil {
fmt.Println("Autofill error:", err)
return
}
fmt.Println("⏳ Signing multi batch transaction...")
fmt.Println("Signing multi batch transaction...")
if err := wallet.SignMultiBatch(user2Wallet, &flattenedMultiBatchTx, nil); err != nil {
fmt.Println("Signing error:", err)
return
@@ -186,9 +186,9 @@ func main() {
return
}
fmt.Println("✅ Multisig Batch transaction submitted")
fmt.Printf("🌐 Hash: %s\n", response.Hash.String())
fmt.Printf("🌐 Validated: %t\n", response.Validated)
fmt.Println("Multisig Batch transaction submitted")
fmt.Printf("Hash: %s\n", response.Hash.String())
fmt.Printf("Validated: %t\n", response.Validated)
fmt.Println()
// Check final balances
@@ -204,7 +204,7 @@ func main() {
if err != nil {
finalReceiverBalance = "0"
}
fmt.Printf("💳 User final balance: %s XRP\n", finalUserBalance)
fmt.Printf("💳 User2 final balance: %s XRP\n", finalUser2Balance)
fmt.Printf("💳 Receiver final balance: %s XRP\n", finalReceiverBalance)
fmt.Printf("User final balance: %s XRP\n", finalUserBalance)
fmt.Printf("User2 final balance: %s XRP\n", finalUser2Balance)
fmt.Printf("Receiver final balance: %s XRP\n", finalReceiverBalance)
}

46
_code-samples/checks/go/rpc/main.go
View File

@@ -1,15 +1,15 @@
package main
import (
"fmt"
"fmt"
"github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/ledger-entry-types"
"github.com/Peersyst/xrpl-go/xrpl/rpc"
"github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/ledger-entry-types"
"github.com/Peersyst/xrpl-go/xrpl/rpc"
"github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
)
func main() {
@@ -35,27 +35,27 @@ func main() {
return
}
fmt.Println("⏳ Setting up wallets...")
fmt.Println("Setting up wallets...")
if err := client.FundWallet(&w); err != nil {
fmt.Println(err)
return
}
fmt.Println("💸 Sender wallet funded!")
fmt.Println("Sender wallet funded!")
if err := client.FundWallet(&receiverWallet); err != nil {
fmt.Println(err)
return
}
fmt.Println("💸 Receiver wallet funded!")
fmt.Println("Receiver wallet funded!")
fmt.Println()
fmt.Println("✅ Wallets setup complete!")
fmt.Println("💳 Sender wallet:", w.ClassicAddress)
fmt.Println("💳 Receiver wallet:", receiverWallet.ClassicAddress)
fmt.Println("Wallets setup complete!")
fmt.Println("Sender wallet:", w.ClassicAddress)
fmt.Println("Receiver wallet:", receiverWallet.ClassicAddress)
fmt.Println()
fmt.Println("⏳ Creating check...")
fmt.Println("Creating check...")
cc := &transaction.CheckCreate{
BaseTx: transaction.BaseTx{
Account: w.GetAddress(),
@@ -85,19 +85,19 @@ func main() {
}
if !res.Validated {
fmt.Println("❌ Check creation failed!")
fmt.Println("Check creation failed!")
fmt.Println("Try again!")
fmt.Println()
return
}
fmt.Println("✅ Check created!")
fmt.Printf("🌐 Hash: %s\n", res.Hash.String())
fmt.Println("Check created!")
fmt.Printf("Hash: %s\n", res.Hash.String())
fmt.Println()
meta, ok := res.Meta.(map[string]interface{})
if !ok {
fmt.Println("❌ Meta is not of type TxObjMeta")
fmt.Println("Meta is not of type TxObjMeta")
return
}
@@ -108,7 +108,7 @@ func main() {
for _, node := range affectedNodes {
affectedNode, ok := node.(map[string]interface{})
if !ok {
fmt.Println("❌ Node is not of type map[string]interface{}")
fmt.Println("Node is not of type map[string]interface{}")
return
}
@@ -128,7 +128,7 @@ func main() {
return
}
fmt.Println("⏳ Cashing out check...")
fmt.Println("Cashing out check...")
checkCash := &transaction.CheckCash{
BaseTx: transaction.BaseTx{
Account: receiverWallet.GetAddress(),
@@ -156,7 +156,7 @@ func main() {
return
}
fmt.Println("✅ Check cashed out!")
fmt.Printf("🌐 Hash: %s\n", res.Hash.String())
fmt.Println("Check cashed out!")
fmt.Printf("Hash: %s\n", res.Hash.String())
fmt.Println()
}

52
_code-samples/checks/go/ws/main.go
View File

@@ -1,19 +1,19 @@
package main
import (
"fmt"
"fmt"
"github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/ledger-entry-types"
"github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/xrpl/websocket"
"github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/ledger-entry-types"
"github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/xrpl/websocket"
)
func main() {
fmt.Println("⏳ Connecting to testnet...")
fmt.Println("Connecting to testnet...")
client := websocket.NewClient(
websocket.NewClientConfig().
WithHost("wss://s.altnet.rippletest.net:51233").
@@ -27,11 +27,11 @@ func main() {
}
if !client.IsConnected() {
fmt.Println("❌ Failed to connect to testnet")
fmt.Println("Failed to connect to testnet")
return
}
fmt.Println("✅ Connected to testnet")
fmt.Println("Connected to testnet")
fmt.Println()
w, err := wallet.New(crypto.ED25519())
@@ -46,27 +46,27 @@ func main() {
return
}
fmt.Println("⏳ Setting up wallets...")
fmt.Println("Setting up wallets...")
if err := client.FundWallet(&w); err != nil {
fmt.Println(err)
return
}
fmt.Println("💸 Sender wallet funded!")
fmt.Println("Sender wallet funded!")
if err := client.FundWallet(&receiverWallet); err != nil {
fmt.Println(err)
return
}
fmt.Println("💸 Receiver wallet funded!")
fmt.Println("Receiver wallet funded!")
fmt.Println()
fmt.Println("✅ Wallets setup complete!")
fmt.Println("💳 Sender wallet:", w.ClassicAddress)
fmt.Println("💳 Receiver wallet:", receiverWallet.ClassicAddress)
fmt.Println("Wallets setup complete!")
fmt.Println("Sender wallet:", w.ClassicAddress)
fmt.Println("Receiver wallet:", receiverWallet.ClassicAddress)
fmt.Println()
fmt.Println("⏳ Creating check...")
fmt.Println("Creating check...")
cc := &transaction.CheckCreate{
BaseTx: transaction.BaseTx{
Account: w.GetAddress(),
@@ -96,19 +96,19 @@ func main() {
}
if !res.Validated {
fmt.Println("❌ Check creation failed!")
fmt.Println("Check creation failed!")
fmt.Println("Try again!")
fmt.Println()
return
}
fmt.Println("✅ Check created!")
fmt.Printf("🌐 Hash: %s\n", res.Hash.String())
fmt.Println("Check created!")
fmt.Printf("Hash: %s\n", res.Hash.String())
fmt.Println()
meta, ok := res.Meta.(map[string]interface{})
if !ok {
fmt.Println("❌ Meta is not of type TxObjMeta")
fmt.Println("Meta is not of type TxObjMeta")
return
}
@@ -119,7 +119,7 @@ func main() {
for _, node := range affectedNodes {
affectedNode, ok := node.(map[string]interface{})
if !ok {
fmt.Println("❌ Node is not of type map[string]interface{}")
fmt.Println("Node is not of type map[string]interface{}")
return
}
@@ -139,7 +139,7 @@ func main() {
return
}
fmt.Println("⏳ Cashing out check...")
fmt.Println("Cashing out check...")
checkCash := &transaction.CheckCash{
BaseTx: transaction.BaseTx{
Account: receiverWallet.GetAddress(),
@@ -167,7 +167,7 @@ func main() {
return
}
fmt.Println("✅ Check cashed out!")
fmt.Printf("🌐 Hash: %s\n", res.Hash.String())
fmt.Println("Check cashed out!")
fmt.Printf("Hash: %s\n", res.Hash.String())
fmt.Println()
}

90
_code-samples/clawback/go/rpc/main.go
View File

@@ -1,14 +1,14 @@
package main
import (
"fmt"
"fmt"
"github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/rpc"
transactions "github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/rpc"
transactions "github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
)
const (
@@ -32,41 +32,41 @@ func main() {
//
// Configure wallets
//
fmt.Println("⏳ Setting up wallets...")
fmt.Println("Setting up wallets...")
coldWallet, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Printf("❌ Error creating cold wallet: %s\n", err)
fmt.Printf("Error creating cold wallet: %s\n", err)
return
}
err = client.FundWallet(&coldWallet)
if err != nil {
fmt.Printf("❌ Error funding cold wallet: %s\n", err)
fmt.Printf("Error funding cold wallet: %s\n", err)
return
}
fmt.Println("💸 Cold wallet funded!")
fmt.Println("Cold wallet funded!")
hotWallet, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Printf("❌ Error creating hot wallet: %s\n", err)
fmt.Printf("Error creating hot wallet: %s\n", err)
return
}
err = client.FundWallet(&hotWallet)
if err != nil {
fmt.Printf("❌ Error funding hot wallet: %s\n", err)
fmt.Printf("Error funding hot wallet: %s\n", err)
return
}
fmt.Println("💸 Hot wallet funded!")
fmt.Println("Hot wallet funded!")
fmt.Println()
fmt.Println("✅ Wallets setup complete!")
fmt.Println("💳 Cold wallet:", coldWallet.ClassicAddress)
fmt.Println("💳 Hot wallet:", hotWallet.ClassicAddress)
fmt.Println("Wallets setup complete!")
fmt.Println("Cold wallet:", coldWallet.ClassicAddress)
fmt.Println("Hot wallet:", hotWallet.ClassicAddress)
fmt.Println()
//
// Configure cold address settings
//
fmt.Println("⏳ Configuring cold address settings...")
fmt.Println("Configuring cold address settings...")
coldWalletAccountSet := &transactions.AccountSet{
BaseTx: transactions.BaseTx{
Account: types.Address(coldWallet.ClassicAddress),
@@ -85,37 +85,37 @@ func main() {
err = client.Autofill(&flattenedTx)
if err != nil {
fmt.Printf("❌ Error autofilling transaction: %s\n", err)
fmt.Printf("Error autofilling transaction: %s\n", err)
return
}
txBlob, _, err := coldWallet.Sign(flattenedTx)
if err != nil {
fmt.Printf("❌ Error signing transaction: %s\n", err)
fmt.Printf("Error signing transaction: %s\n", err)
return
}
response, err := client.SubmitTxBlobAndWait(txBlob, false)
if err != nil {
fmt.Printf("❌ Error submitting transaction: %s\n", err)
fmt.Printf("Error submitting transaction: %s\n", err)
return
}
if !response.Validated {
fmt.Println("❌ Cold wallet unfreezing failed!")
fmt.Println("Cold wallet unfreezing failed!")
fmt.Println("Try again!")
fmt.Println()
return
}
fmt.Println("✅ Cold address settings configured!")
fmt.Printf("🌐 Hash: %s\n", response.Hash.String())
fmt.Println("Cold address settings configured!")
fmt.Printf("Hash: %s\n", response.Hash.String())
fmt.Println()
//
// Create trust line from hot to cold address
//
fmt.Println("⏳ Creating trust line from hot to cold address...")
fmt.Println("Creating trust line from hot to cold address...")
hotColdTrustSet := &transactions.TrustSet{
BaseTx: transactions.BaseTx{
Account: types.Address(hotWallet.ClassicAddress),
@@ -130,37 +130,37 @@ func main() {
flattenedTx = hotColdTrustSet.Flatten()
err = client.Autofill(&flattenedTx)
if err != nil {
fmt.Printf("❌ Error autofilling transaction: %s\n", err)
fmt.Printf("Error autofilling transaction: %s\n", err)
return
}
txBlob, _, err = hotWallet.Sign(flattenedTx)
if err != nil {
fmt.Printf("❌ Error signing transaction: %s\n", err)
fmt.Printf("Error signing transaction: %s\n", err)
return
}
response, err = client.SubmitTxBlobAndWait(txBlob, false)
if err != nil {
fmt.Printf("❌ Error submitting transaction: %s\n", err)
fmt.Printf("Error submitting transaction: %s\n", err)
return
}
if !response.Validated {
fmt.Println("❌ Trust line from hot to cold address creation failed!")
fmt.Println("Trust line from hot to cold address creation failed!")
fmt.Println("Try again!")
fmt.Println()
return
}
fmt.Println("✅ Trust line from hot to cold address created!")
fmt.Printf("🌐 Hash: %s\n", response.Hash.String())
fmt.Println("Trust line from hot to cold address created!")
fmt.Printf("Hash: %s\n", response.Hash.String())
fmt.Println()
//
// Send tokens from cold wallet to hot wallet
//
fmt.Println("⏳ Sending tokens from cold wallet to hot wallet...")
fmt.Println("Sending tokens from cold wallet to hot wallet...")
coldToHotPayment := &transactions.Payment{
BaseTx: transactions.BaseTx{
Account: types.Address(coldWallet.ClassicAddress),
@@ -177,37 +177,37 @@ func main() {
flattenedTx = coldToHotPayment.Flatten()
err = client.Autofill(&flattenedTx)
if err != nil {
fmt.Printf("❌ Error autofilling transaction: %s\n", err)
fmt.Printf("Error autofilling transaction: %s\n", err)
return
}
txBlob, _, err = coldWallet.Sign(flattenedTx)
if err != nil {
fmt.Printf("❌ Error signing transaction: %s\n", err)
fmt.Printf("Error signing transaction: %s\n", err)
return
}
response, err = client.SubmitTxBlobAndWait(txBlob, false)
if err != nil {
fmt.Printf("❌ Error submitting transaction: %s\n", err)
fmt.Printf("Error submitting transaction: %s\n", err)
return
}
if !response.Validated {
fmt.Println("❌ Tokens not sent from cold wallet to hot wallet!")
fmt.Println("Tokens not sent from cold wallet to hot wallet!")
fmt.Println("Try again!")
fmt.Println()
return
}
fmt.Println("✅ Tokens sent from cold wallet to hot wallet!")
fmt.Printf("🌐 Hash: %s\n", response.Hash.String())
fmt.Println("Tokens sent from cold wallet to hot wallet!")
fmt.Printf("Hash: %s\n", response.Hash.String())
fmt.Println()
//
// Claw back tokens from customer one
//
fmt.Println("⏳ Clawing back tokens from hot wallet...")
fmt.Println("Clawing back tokens from hot wallet...")
coldWalletClawback := &transactions.Clawback{
BaseTx: transactions.BaseTx{
@@ -223,29 +223,29 @@ func main() {
flattenedTx = coldWalletClawback.Flatten()
err = client.Autofill(&flattenedTx)
if err != nil {
fmt.Printf("❌ Error autofilling transaction: %s\n", err)
fmt.Printf("Error autofilling transaction: %s\n", err)
return
}
txBlob, _, err = coldWallet.Sign(flattenedTx)
if err != nil {
fmt.Printf("❌ Error signing transaction: %s\n", err)
fmt.Printf("Error signing transaction: %s\n", err)
return
}
response, err = client.SubmitTxBlobAndWait(txBlob, false)
if err != nil {
fmt.Printf("❌ Error submitting transaction: %s\n", err)
fmt.Printf("Error submitting transaction: %s\n", err)
return
}
if !response.Validated {
fmt.Println("❌ Tokens not clawed back from customer one!")
fmt.Println("Tokens not clawed back from customer one!")
fmt.Println("Try again!")
return
}
fmt.Println("✅ Tokens clawed back from customer one!")
fmt.Printf("🌐 Hash: %s\n", response.Hash.String())
fmt.Println("Tokens clawed back from customer one!")
fmt.Printf("Hash: %s\n", response.Hash.String())
fmt.Println()
}

94
_code-samples/clawback/go/ws/main.go
View File

@@ -1,14 +1,14 @@
package main
import (
"fmt"
"fmt"
"github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
transactions "github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/xrpl/websocket"
"github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
transactions "github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/xrpl/websocket"
)
const (
@@ -19,13 +19,13 @@ func main() {
//
// Configure client
//
fmt.Println("⏳ Setting up client...")
fmt.Println("Setting up client...")
client := websocket.NewClient(
websocket.NewClientConfig().
WithHost("wss://s.altnet.rippletest.net").
WithFaucetProvider(faucet.NewTestnetFaucetProvider()),
)
fmt.Println("✅ Client configured!")
fmt.Println("Client configured!")
fmt.Println()
fmt.Println("Connecting to server...")
@@ -39,41 +39,41 @@ func main() {
//
// Configure wallets
//
fmt.Println("⏳ Setting up wallets...")
fmt.Println("Setting up wallets...")
coldWallet, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Printf("❌ Error creating cold wallet: %s\n", err)
fmt.Printf("Error creating cold wallet: %s\n", err)
return
}
err = client.FundWallet(&coldWallet)
if err != nil {
fmt.Printf("❌ Error funding cold wallet: %s\n", err)
fmt.Printf("Error funding cold wallet: %s\n", err)
return
}
fmt.Println("💸 Cold wallet funded!")
fmt.Println("Cold wallet funded!")
hotWallet, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Printf("❌ Error creating hot wallet: %s\n", err)
fmt.Printf("Error creating hot wallet: %s\n", err)
return
}
err = client.FundWallet(&hotWallet)
if err != nil {
fmt.Printf("❌ Error funding hot wallet: %s\n", err)
fmt.Printf("Error funding hot wallet: %s\n", err)
return
}
fmt.Println("💸 Hot wallet funded!")
fmt.Println("Hot wallet funded!")
fmt.Println()
fmt.Println("✅ Wallets setup complete!")
fmt.Println("💳 Cold wallet:", coldWallet.ClassicAddress)
fmt.Println("💳 Hot wallet:", hotWallet.ClassicAddress)
fmt.Println("Wallets setup complete!")
fmt.Println("Cold wallet:", coldWallet.ClassicAddress)
fmt.Println("Hot wallet:", hotWallet.ClassicAddress)
fmt.Println()
//
// Configure cold address settings
//
fmt.Println("⏳ Configuring cold address settings...")
fmt.Println("Configuring cold address settings...")
coldWalletAccountSet := &transactions.AccountSet{
BaseTx: transactions.BaseTx{
Account: types.Address(coldWallet.ClassicAddress),
@@ -92,37 +92,37 @@ func main() {
err = client.Autofill(&flattenedTx)
if err != nil {
fmt.Printf("❌ Error autofilling transaction: %s\n", err)
fmt.Printf("Error autofilling transaction: %s\n", err)
return
}
txBlob, _, err := coldWallet.Sign(flattenedTx)
if err != nil {
fmt.Printf("❌ Error signing transaction: %s\n", err)
fmt.Printf("Error signing transaction: %s\n", err)
return
}
response, err := client.SubmitTxBlobAndWait(txBlob, false)
if err != nil {
fmt.Printf("❌ Error submitting transaction: %s\n", err)
fmt.Printf("Error submitting transaction: %s\n", err)
return
}
if !response.Validated {
fmt.Println("❌ Cold wallet unfreezing failed!")
fmt.Println("Cold wallet unfreezing failed!")
fmt.Println("Try again!")
fmt.Println()
return
}
fmt.Println("✅ Cold address settings configured!")
fmt.Printf("🌐 Hash: %s\n", response.Hash.String())
fmt.Println("Cold address settings configured!")
fmt.Printf("Hash: %s\n", response.Hash.String())
fmt.Println()
//
// Create trust line from hot to cold address
//
fmt.Println("⏳ Creating trust line from hot to cold address...")
fmt.Println("Creating trust line from hot to cold address...")
hotColdTrustSet := &transactions.TrustSet{
BaseTx: transactions.BaseTx{
Account: types.Address(hotWallet.ClassicAddress),
@@ -137,37 +137,37 @@ func main() {
flattenedTx = hotColdTrustSet.Flatten()
err = client.Autofill(&flattenedTx)
if err != nil {
fmt.Printf("❌ Error autofilling transaction: %s\n", err)
fmt.Printf("Error autofilling transaction: %s\n", err)
return
}
txBlob, _, err = hotWallet.Sign(flattenedTx)
if err != nil {
fmt.Printf("❌ Error signing transaction: %s\n", err)
fmt.Printf("Error signing transaction: %s\n", err)
return
}
response, err = client.SubmitTxBlobAndWait(txBlob, false)
if err != nil {
fmt.Printf("❌ Error submitting transaction: %s\n", err)
fmt.Printf("Error submitting transaction: %s\n", err)
return
}
if !response.Validated {
fmt.Println("❌ Trust line from hot to cold address creation failed!")
fmt.Println("Trust line from hot to cold address creation failed!")
fmt.Println("Try again!")
fmt.Println()
return
}
fmt.Println("✅ Trust line from hot to cold address created!")
fmt.Printf("🌐 Hash: %s\n", response.Hash.String())
fmt.Println("Trust line from hot to cold address created!")
fmt.Printf("Hash: %s\n", response.Hash.String())
fmt.Println()
//
// Send tokens from cold wallet to hot wallet
//
fmt.Println("⏳ Sending tokens from cold wallet to hot wallet...")
fmt.Println("Sending tokens from cold wallet to hot wallet...")
coldToHotPayment := &transactions.Payment{
BaseTx: transactions.BaseTx{
Account: types.Address(coldWallet.ClassicAddress),
@@ -184,37 +184,37 @@ func main() {
flattenedTx = coldToHotPayment.Flatten()
err = client.Autofill(&flattenedTx)
if err != nil {
fmt.Printf("❌ Error autofilling transaction: %s\n", err)
fmt.Printf("Error autofilling transaction: %s\n", err)
return
}
txBlob, _, err = coldWallet.Sign(flattenedTx)
if err != nil {
fmt.Printf("❌ Error signing transaction: %s\n", err)
fmt.Printf("Error signing transaction: %s\n", err)
return
}
response, err = client.SubmitTxBlobAndWait(txBlob, false)
if err != nil {
fmt.Printf("❌ Error submitting transaction: %s\n", err)
fmt.Printf("Error submitting transaction: %s\n", err)
return
}
if !response.Validated {
fmt.Println("❌ Tokens not sent from cold wallet to hot wallet!")
fmt.Println("Tokens not sent from cold wallet to hot wallet!")
fmt.Println("Try again!")
fmt.Println()
return
}
fmt.Println("✅ Tokens sent from cold wallet to hot wallet!")
fmt.Printf("🌐 Hash: %s\n", response.Hash.String())
fmt.Println("Tokens sent from cold wallet to hot wallet!")
fmt.Printf("Hash: %s\n", response.Hash.String())
fmt.Println()
//
// Claw back tokens from customer one
//
fmt.Println("⏳ Clawing back tokens from hot wallet...")
fmt.Println("Clawing back tokens from hot wallet...")
coldWalletClawback := &transactions.Clawback{
BaseTx: transactions.BaseTx{
@@ -230,29 +230,29 @@ func main() {
flattenedTx = coldWalletClawback.Flatten()
err = client.Autofill(&flattenedTx)
if err != nil {
fmt.Printf("❌ Error autofilling transaction: %s\n", err)
fmt.Printf("Error autofilling transaction: %s\n", err)
return
}
txBlob, _, err = coldWallet.Sign(flattenedTx)
if err != nil {
fmt.Printf("❌ Error signing transaction: %s\n", err)
fmt.Printf("Error signing transaction: %s\n", err)
return
}
response, err = client.SubmitTxBlobAndWait(txBlob, false)
if err != nil {
fmt.Printf("❌ Error submitting transaction: %s\n", err)
fmt.Printf("Error submitting transaction: %s\n", err)
return
}
if !response.Validated {
fmt.Println("❌ Tokens not clawed back from customer one!")
fmt.Println("Tokens not clawed back from customer one!")
fmt.Println("Try again!")
return
}
fmt.Println("✅ Tokens clawed back from customer one!")
fmt.Printf("🌐 Hash: %s\n", response.Hash.String())
fmt.Println("Tokens clawed back from customer one!")
fmt.Printf("Hash: %s\n", response.Hash.String())
fmt.Println()
}

42
_code-samples/credential/go/rpc/main.go
View File

@@ -1,16 +1,16 @@
package main
import (
"encoding/hex"
"fmt"
"time"
"encoding/hex"
"fmt"
"time"
"github.com/Peersyst/xrpl-go/examples/clients"
"github.com/Peersyst/xrpl-go/pkg/crypto"
rippleTime "github.com/Peersyst/xrpl-go/xrpl/time"
"github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/examples/clients"
"github.com/Peersyst/xrpl-go/pkg/crypto"
rippleTime "github.com/Peersyst/xrpl-go/xrpl/time"
"github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
)
func main() {
@@ -20,47 +20,47 @@ func main() {
// Configure wallets
// Issuer
fmt.Println("⏳ Setting up credential issuer wallet...")
fmt.Println("Setting up credential issuer wallet...")
issuer, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Printf("❌ Error creating issuer wallet: %s\n", err)
fmt.Printf("Error creating issuer wallet: %s\n", err)
return
}
err = client.FundWallet(&issuer)
if err != nil {
fmt.Printf("❌ Error funding issuer wallet: %s\n", err)
fmt.Printf("Error funding issuer wallet: %s\n", err)
return
}
fmt.Printf("✅ Issuer wallet funded: %s\n", issuer.ClassicAddress)
fmt.Printf("Issuer wallet funded: %s\n", issuer.ClassicAddress)
// -----------------------------------------------------
// Subject (destination)
fmt.Println("⏳ Setting up Subject wallet...")
fmt.Println("Setting up Subject wallet...")
subjectWallet, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Printf("❌ Error creating subject wallet: %s\n", err)
fmt.Printf("Error creating subject wallet: %s\n", err)
return
}
err = client.FundWallet(&subjectWallet)
if err != nil {
fmt.Printf("❌ Error funding subject wallet: %s\n", err)
fmt.Printf("Error funding subject wallet: %s\n", err)
return
}
fmt.Printf("✅ Subject wallet funded: %s\n", subjectWallet.ClassicAddress)
fmt.Printf("Subject wallet funded: %s\n", subjectWallet.ClassicAddress)
// -----------------------------------------------------
// Creating the CredentialCreate transaction
fmt.Println("⏳ Creating CredentialCreate transaction...")
fmt.Println("Creating CredentialCreate transaction...")
expiration, err := rippleTime.IsoTimeToRippleTime(time.Now().Add(time.Hour * 24).Format(time.RFC3339))
credentialType := types.CredentialType("6D795F63726564656E7469616C")
if err != nil {
fmt.Printf("❌ Error converting expiration to ripple time: %s\n", err)
fmt.Printf("Error converting expiration to ripple time: %s\n", err)
return
}
@@ -79,7 +79,7 @@ func main() {
// -----------------------------------------------------
// Creating the CredentialAccept transaction
fmt.Println("⏳ Creating CredentialAccept transaction...")
fmt.Println("Creating CredentialAccept transaction...")
acceptTxn := &transaction.CredentialAccept{
BaseTx: transaction.BaseTx{
@@ -94,7 +94,7 @@ func main() {
// -----------------------------------------------------
// Creating the CredentialDelete transaction
fmt.Println("⏳ Creating CredentialDelete transaction...")
fmt.Println("Creating CredentialDelete transaction...")
deleteTxn := &transaction.CredentialDelete{
BaseTx: transaction.BaseTx{

46
_code-samples/credential/go/ws/main.go
View File

@@ -1,21 +1,21 @@
package main
import (
"encoding/hex"
"fmt"
"time"
"encoding/hex"
"fmt"
"time"
"github.com/Peersyst/xrpl-go/examples/clients"
"github.com/Peersyst/xrpl-go/pkg/crypto"
rippleTime "github.com/Peersyst/xrpl-go/xrpl/time"
"github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/examples/clients"
"github.com/Peersyst/xrpl-go/pkg/crypto"
rippleTime "github.com/Peersyst/xrpl-go/xrpl/time"
"github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
)
func main() {
fmt.Println("⏳ Setting up client...")
fmt.Println("Setting up client...")
client := clients.GetDevnetWebsocketClient()
fmt.Println("Connecting to server...")
@@ -24,7 +24,7 @@ func main() {
return
}
fmt.Println("✅ Client configured!")
fmt.Println("Client configured!")
fmt.Println()
fmt.Printf("Connection: %t", client.IsConnected())
@@ -33,47 +33,47 @@ func main() {
// Configure wallets
// Issuer
fmt.Println("⏳ Setting up credential issuer wallet...")
fmt.Println("Setting up credential issuer wallet...")
issuer, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Printf("❌ Error creating issuer wallet: %s\n", err)
fmt.Printf("Error creating issuer wallet: %s\n", err)
return
}
err = client.FundWallet(&issuer)
if err != nil {
fmt.Printf("❌ Error funding issuer wallet: %s\n", err)
fmt.Printf("Error funding issuer wallet: %s\n", err)
return
}
fmt.Printf("✅ Issuer wallet funded: %s\n", issuer.ClassicAddress)
fmt.Printf("Issuer wallet funded: %s\n", issuer.ClassicAddress)
// -----------------------------------------------------
// Subject (destination)
fmt.Println("⏳ Setting up Subject wallet...")
fmt.Println("Setting up Subject wallet...")
subjectWallet, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Printf("❌ Error creating subject wallet: %s\n", err)
fmt.Printf("Error creating subject wallet: %s\n", err)
return
}
err = client.FundWallet(&subjectWallet)
if err != nil {
fmt.Printf("❌ Error funding subject wallet: %s\n", err)
fmt.Printf("Error funding subject wallet: %s\n", err)
return
}
fmt.Printf("✅ Subject wallet funded: %s\n", subjectWallet.ClassicAddress)
fmt.Printf("Subject wallet funded: %s\n", subjectWallet.ClassicAddress)
// -----------------------------------------------------
// Creating the CredentialCreate transaction
fmt.Println("⏳ Creating CredentialCreate transaction...")
fmt.Println("Creating CredentialCreate transaction...")
expiration, err := rippleTime.IsoTimeToRippleTime(time.Now().Add(time.Hour * 24).Format(time.RFC3339))
credentialType := types.CredentialType("6D795F63726564656E7469616C")
if err != nil {
fmt.Printf("❌ Error converting expiration to ripple time: %s\n", err)
fmt.Printf("Error converting expiration to ripple time: %s\n", err)
return
}
@@ -92,7 +92,7 @@ func main() {
// -----------------------------------------------------
// Creating the CredentialAccept transaction
fmt.Println("⏳ Creating CredentialAccept transaction...")
fmt.Println("Creating CredentialAccept transaction...")
acceptTxn := &transaction.CredentialAccept{
BaseTx: transaction.BaseTx{
@@ -107,7 +107,7 @@ func main() {
// -----------------------------------------------------
// Creating the CredentialDelete transaction
fmt.Println("⏳ Creating CredentialDelete transaction...")
fmt.Println("Creating CredentialDelete transaction...")
deleteTxn := &transaction.CredentialDelete{
BaseTx: transaction.BaseTx{

40
_code-samples/delegate-set/go/rpc/main.go
View File

@@ -1,15 +1,15 @@
package main
import (
"fmt"
"fmt"
"github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/rpc"
"github.com/Peersyst/xrpl-go/xrpl/rpc/types"
transactions "github.com/Peersyst/xrpl-go/xrpl/transaction"
txnTypes "github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/rpc"
"github.com/Peersyst/xrpl-go/xrpl/rpc/types"
transactions "github.com/Peersyst/xrpl-go/xrpl/transaction"
txnTypes "github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
)
func main() {
@@ -36,7 +36,7 @@ func main() {
return
}
fmt.Println("⏳ Funding wallets...")
fmt.Println("Funding wallets...")
if err := client.FundWallet(&delegatorWallet); err != nil {
fmt.Println(err)
return
@@ -45,7 +45,7 @@ func main() {
fmt.Println(err)
return
}
fmt.Println("💸 Wallets funded")
fmt.Println("Wallets funded")
// Check initial balances
delegatorBalance, err := client.GetXrpBalance(delegatorWallet.ClassicAddress)
@@ -57,8 +57,8 @@ func main() {
delegateeBalance = "0"
}
fmt.Printf("💳 Delegator initial balance: %s XRP\n", delegatorBalance)
fmt.Printf("💳 Delegatee initial balance: %s XRP\n", delegateeBalance)
fmt.Printf("Delegator initial balance: %s XRP\n", delegatorBalance)
fmt.Printf("Delegatee initial balance: %s XRP\n", delegateeBalance)
fmt.Println()
// Create DelegateSet transaction
@@ -86,9 +86,9 @@ func main() {
return
}
fmt.Println("✅ DelegateSet transaction submitted")
fmt.Printf("🌐 Hash: %s\n", response.Hash)
fmt.Printf("🌐 Validated: %t\n", response.Validated)
fmt.Println("DelegateSet transaction submitted")
fmt.Printf("Hash: %s\n", response.Hash)
fmt.Printf("Validated: %t\n", response.Validated)
fmt.Println()
// Create delegated payment transaction
@@ -111,9 +111,9 @@ func main() {
return
}
fmt.Println("✅ Delegated payment submitted")
fmt.Printf("🌐 Hash: %s\n", response2.Hash)
fmt.Printf("🌐 Validated: %t\n", response2.Validated)
fmt.Println("Delegated payment submitted")
fmt.Printf("Hash: %s\n", response2.Hash)
fmt.Printf("Validated: %t\n", response2.Validated)
fmt.Println()
// Check final balances
@@ -126,6 +126,6 @@ func main() {
finalDelegateeBalance = "0"
}
fmt.Printf("💳 Delegator final balance: %s XRP\n", finalDelegatorBalance)
fmt.Printf("💳 Delegatee final balance: %s XRP\n", finalDelegateeBalance)
fmt.Printf("Delegator final balance: %s XRP\n", finalDelegatorBalance)
fmt.Printf("Delegatee final balance: %s XRP\n", finalDelegateeBalance)
}

38
_code-samples/delegate-set/go/ws/main.go
View File

@@ -1,14 +1,14 @@
package main
import (
"fmt"
"fmt"
"github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
transactions "github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/xrpl/websocket"
"github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
transactions "github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/xrpl/websocket"
)
func main() {
@@ -38,7 +38,7 @@ func main() {
return
}
fmt.Println("⏳ Funding wallets...")
fmt.Println("Funding wallets...")
if err := client.FundWallet(&delegatorWallet); err != nil {
fmt.Println(err)
return
@@ -47,7 +47,7 @@ func main() {
fmt.Println(err)
return
}
fmt.Println("💸 Wallets funded")
fmt.Println("Wallets funded")
// Check initial balances
delegatorBalance, err := client.GetXrpBalance(delegatorWallet.ClassicAddress)
@@ -59,8 +59,8 @@ func main() {
delegateeBalance = "0"
}
fmt.Printf("💳 Delegator initial balance: %s XRP\n", delegatorBalance)
fmt.Printf("💳 Delegatee initial balance: %s XRP\n", delegateeBalance)
fmt.Printf("Delegator initial balance: %s XRP\n", delegatorBalance)
fmt.Printf("Delegatee initial balance: %s XRP\n", delegateeBalance)
fmt.Println()
// Create DelegateSet transaction
@@ -97,9 +97,9 @@ func main() {
return
}
fmt.Println("✅ DelegateSet transaction submitted")
fmt.Printf("🌐 Hash: %s\n", response.Hash)
fmt.Printf("🌐 Validated: %t\n", response.Validated)
fmt.Println("DelegateSet transaction submitted")
fmt.Printf("Hash: %s\n", response.Hash)
fmt.Printf("Validated: %t\n", response.Validated)
fmt.Println()
// Create delegated payment transaction
@@ -131,9 +131,9 @@ func main() {
return
}
fmt.Println("✅ Delegated payment submitted")
fmt.Printf("🌐 Hash: %s\n", response2.Hash)
fmt.Printf("🌐 Validated: %t\n", response2.Validated)
fmt.Println("Delegated payment submitted")
fmt.Printf("Hash: %s\n", response2.Hash)
fmt.Printf("Validated: %t\n", response2.Validated)
fmt.Println()
// Check final balances
@@ -146,6 +146,6 @@ func main() {
finalDelegateeBalance = "0"
}
fmt.Printf("💳 Delegator final balance: %s XRP\n", finalDelegatorBalance)
fmt.Printf("💳 Delegatee final balance: %s XRP\n", finalDelegateeBalance)
fmt.Printf("Delegator final balance: %s XRP\n", finalDelegatorBalance)
fmt.Printf("Delegatee final balance: %s XRP\n", finalDelegateeBalance)
}

64
_code-samples/deposit-preauth/go/rpc/main.go
View File

@@ -1,18 +1,18 @@
package main
import (
"encoding/hex"
"fmt"
"time"
"encoding/hex"
"fmt"
"time"
"github.com/Peersyst/xrpl-go/examples/clients"
"github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/queries/account"
"github.com/Peersyst/xrpl-go/xrpl/queries/common"
rippletime "github.com/Peersyst/xrpl-go/xrpl/time"
"github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/examples/clients"
"github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/queries/account"
"github.com/Peersyst/xrpl-go/xrpl/queries/common"
rippletime "github.com/Peersyst/xrpl-go/xrpl/time"
"github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
)
func main() {
@@ -21,41 +21,41 @@ func main() {
// Configure wallets
// Issuer
fmt.Println("⏳ Setting up credential issuer wallet...")
fmt.Println("Setting up credential issuer wallet...")
issuer, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Printf("❌ Error creating credential issuer wallet: %s\n", err)
fmt.Printf("Error creating credential issuer wallet: %s\n", err)
return
}
err = client.FundWallet(&issuer)
if err != nil {
fmt.Printf("❌ Error funding credential issuer wallet: %s\n", err)
fmt.Printf("Error funding credential issuer wallet: %s\n", err)
return
}
fmt.Printf("✅ Credential issuer wallet funded: %s\n", issuer.ClassicAddress)
fmt.Printf("Credential issuer wallet funded: %s\n", issuer.ClassicAddress)
// -----------------------------------------------------
// Holder 1
fmt.Println("⏳ Setting up holder 1 wallet...")
fmt.Println("Setting up holder 1 wallet...")
holderWallet1, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Printf("❌ Error creating holder 1 wallet: %s\n", err)
fmt.Printf("Error creating holder 1 wallet: %s\n", err)
return
}
err = client.FundWallet(&holderWallet1)
if err != nil {
fmt.Printf("❌ Error funding holder 1 wallet: %s\n", err)
fmt.Printf("Error funding holder 1 wallet: %s\n", err)
return
}
fmt.Printf("✅ Holder 1 wallet funded: %s\n", holderWallet1.ClassicAddress)
fmt.Printf("Holder 1 wallet funded: %s\n", holderWallet1.ClassicAddress)
// -----------------------------------------------------
// Enabling DepositAuth on the issuer account with an AccountSet transaction
fmt.Println("⏳ Enabling DepositAuth on the issuer account...")
fmt.Println("Enabling DepositAuth on the issuer account...")
accountSetTx := &transaction.AccountSet{
BaseTx: transaction.BaseTx{
Account: issuer.ClassicAddress,
@@ -69,11 +69,11 @@ func main() {
// -----------------------------------------------------
// Creating the CredentialCreate transaction
fmt.Println("⏳ Creating the CredentialCreate transaction...")
fmt.Println("Creating the CredentialCreate transaction...")
expiration, err := rippletime.IsoTimeToRippleTime(time.Now().Add(time.Hour * 24).Format(time.RFC3339))
if err != nil {
fmt.Printf("❌ Error converting expiration to ripple time: %s\n", err)
fmt.Printf("Error converting expiration to ripple time: %s\n", err)
return
}
credentialType := types.CredentialType("6D795F63726564656E7469616C") // my_credential
@@ -94,7 +94,7 @@ func main() {
// -----------------------------------------------------
// Creating the CredentialAccept transaction
fmt.Println("⏳ Creating the CredentialAccept transaction...")
fmt.Println("Creating the CredentialAccept transaction...")
credentialAcceptTx := &transaction.CredentialAccept{
BaseTx: transaction.BaseTx{
@@ -110,7 +110,7 @@ func main() {
// -----------------------------------------------------
// Creating the DepositPreauth transaction
fmt.Println("⏳ Creating the DepositPreauth transaction using AuthorizeCredentials...")
fmt.Println("Creating the DepositPreauth transaction using AuthorizeCredentials...")
depositPreauthTx := &transaction.DepositPreauth{
BaseTx: transaction.BaseTx{
@@ -132,7 +132,7 @@ func main() {
// -----------------------------------------------------
// Get the credential ID
fmt.Println("⏳ Getting the credential ID from the holder 1 account...")
fmt.Println("Getting the credential ID from the holder 1 account...")
objectsRequest := &account.ObjectsRequest{
Account: holderWallet1.ClassicAddress,
@@ -142,30 +142,30 @@ func main() {
objectsResponse, err := client.GetAccountObjects(objectsRequest)
if err != nil {
fmt.Printf("❌ Error getting the credential ID: %s\n", err)
fmt.Printf("Error getting the credential ID: %s\n", err)
return
}
// Check if we have any credential objects
if len(objectsResponse.AccountObjects) == 0 {
fmt.Println("❌ No credential objects found")
fmt.Println("No credential objects found")
return
}
// Extract the credential ID
credentialID, ok := objectsResponse.AccountObjects[0]["index"].(string)
if !ok {
fmt.Println("❌ Could not extract credential ID from response")
fmt.Println("Could not extract credential ID from response")
return
}
fmt.Printf("✅ Credential ID: %s\n", credentialID)
fmt.Printf("Credential ID: %s\n", credentialID)
fmt.Println()
// -----------------------------------------------------
// Sending XRP to the holder 1 account
fmt.Println("⏳ Sending XRP to the issuer account, should succeed...")
fmt.Println("Sending XRP to the issuer account, should succeed...")
sendTx := &transaction.Payment{
BaseTx: transaction.BaseTx{
@@ -182,7 +182,7 @@ func main() {
// -----------------------------------------------------
// Unauthorizing the holder 1 account
fmt.Println("⏳ Unauthorizing the holder 1 account with the DepositPreauth transaction and the UnauthorizeCredentials field...")
fmt.Println("Unauthorizing the holder 1 account with the DepositPreauth transaction and the UnauthorizeCredentials field...")
unauthorizeTx := &transaction.DepositPreauth{
BaseTx: transaction.BaseTx{
@@ -204,7 +204,7 @@ func main() {
// -----------------------------------------------------
// Sending XRP to the holder 1 account again (which should fail)
fmt.Println("⏳ Sending XRP to the issuer account again (which should fail)...")
fmt.Println("Sending XRP to the issuer account again (which should fail)...")
sendTx2 := &transaction.Payment{
BaseTx: transaction.BaseTx{

68
_code-samples/deposit-preauth/go/ws/main.go
View File

@@ -1,23 +1,23 @@
package main
import (
"encoding/hex"
"fmt"
"time"
"encoding/hex"
"fmt"
"time"
"github.com/Peersyst/xrpl-go/examples/clients"
"github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/queries/account"
"github.com/Peersyst/xrpl-go/xrpl/queries/common"
rippletime "github.com/Peersyst/xrpl-go/xrpl/time"
"github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/examples/clients"
"github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/queries/account"
"github.com/Peersyst/xrpl-go/xrpl/queries/common"
rippletime "github.com/Peersyst/xrpl-go/xrpl/time"
"github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
)
func main() {
fmt.Println("⏳ Setting up client...")
fmt.Println("Setting up client...")
client := clients.GetDevnetWebsocketClient()
fmt.Println("Connecting to server...")
@@ -26,7 +26,7 @@ func main() {
return
}
fmt.Println("✅ Client configured!")
fmt.Println("Client configured!")
fmt.Println()
fmt.Printf("Connection: %t", client.IsConnected())
@@ -35,41 +35,41 @@ func main() {
// Configure wallets
// Issuer
fmt.Println("⏳ Setting up credential issuer wallet...")
fmt.Println("Setting up credential issuer wallet...")
issuer, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Printf("❌ Error creating credential issuer wallet: %s\n", err)
fmt.Printf("Error creating credential issuer wallet: %s\n", err)
return
}
err = client.FundWallet(&issuer)
if err != nil {
fmt.Printf("❌ Error funding credential issuer wallet: %s\n", err)
fmt.Printf("Error funding credential issuer wallet: %s\n", err)
return
}
fmt.Printf("✅ Credential issuer wallet funded: %s\n", issuer.ClassicAddress)
fmt.Printf("Credential issuer wallet funded: %s\n", issuer.ClassicAddress)
// -----------------------------------------------------
// Holder 1
fmt.Println("⏳ Setting up holder 1 wallet...")
fmt.Println("Setting up holder 1 wallet...")
holderWallet1, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Printf("❌ Error creating holder 1 wallet: %s\n", err)
fmt.Printf("Error creating holder 1 wallet: %s\n", err)
return
}
err = client.FundWallet(&holderWallet1)
if err != nil {
fmt.Printf("❌ Error funding holder 1 wallet: %s\n", err)
fmt.Printf("Error funding holder 1 wallet: %s\n", err)
return
}
fmt.Printf("✅ Holder 1 wallet funded: %s\n", holderWallet1.ClassicAddress)
fmt.Printf("Holder 1 wallet funded: %s\n", holderWallet1.ClassicAddress)
// -----------------------------------------------------
// Enabling DepositAuth on the issuer account with an AccountSet transaction
fmt.Println("⏳ Enabling DepositAuth on the issuer account...")
fmt.Println("Enabling DepositAuth on the issuer account...")
accountSetTx := &transaction.AccountSet{
BaseTx: transaction.BaseTx{
Account: issuer.ClassicAddress,
@@ -83,11 +83,11 @@ func main() {
// -----------------------------------------------------
// Creating the CredentialCreate transaction
fmt.Println("⏳ Creating the CredentialCreate transaction...")
fmt.Println("Creating the CredentialCreate transaction...")
expiration, err := rippletime.IsoTimeToRippleTime(time.Now().Add(time.Hour * 24).Format(time.RFC3339))
if err != nil {
fmt.Printf("❌ Error converting expiration to ripple time: %s\n", err)
fmt.Printf("Error converting expiration to ripple time: %s\n", err)
return
}
credentialType := types.CredentialType("6D795F63726564656E7469616C") // my_credential
@@ -108,7 +108,7 @@ func main() {
// -----------------------------------------------------
// Creating the CredentialAccept transaction
fmt.Println("⏳ Creating the CredentialAccept transaction...")
fmt.Println("Creating the CredentialAccept transaction...")
credentialAcceptTx := &transaction.CredentialAccept{
BaseTx: transaction.BaseTx{
@@ -124,7 +124,7 @@ func main() {
// -----------------------------------------------------
// Creating the DepositPreauth transaction
fmt.Println("⏳ Creating the DepositPreauth transaction using AuthorizeCredentials...")
fmt.Println("Creating the DepositPreauth transaction using AuthorizeCredentials...")
depositPreauthTx := &transaction.DepositPreauth{
BaseTx: transaction.BaseTx{
@@ -146,7 +146,7 @@ func main() {
// -----------------------------------------------------
// Get the credential ID
fmt.Println("⏳ Getting the credential ID from the holder 1 account...")
fmt.Println("Getting the credential ID from the holder 1 account...")
objectsRequest := &account.ObjectsRequest{
Account: holderWallet1.ClassicAddress,
@@ -156,30 +156,30 @@ func main() {
objectsResponse, err := client.GetAccountObjects(objectsRequest)
if err != nil {
fmt.Printf("❌ Error getting the credential ID: %s\n", err)
fmt.Printf("Error getting the credential ID: %s\n", err)
return
}
// Check if we have any credential objects
if len(objectsResponse.AccountObjects) == 0 {
fmt.Println("❌ No credential objects found")
fmt.Println("No credential objects found")
return
}
// Extract the credential ID
credentialID, ok := objectsResponse.AccountObjects[0]["index"].(string)
if !ok {
fmt.Println("❌ Could not extract credential ID from response")
fmt.Println("Could not extract credential ID from response")
return
}
fmt.Printf("✅ Credential ID: %s\n", credentialID)
fmt.Printf("Credential ID: %s\n", credentialID)
fmt.Println()
// -----------------------------------------------------
// Sending XRP to the holder 1 account
fmt.Println("⏳ Sending XRP to the issuer account, should succeed...")
fmt.Println("Sending XRP to the issuer account, should succeed...")
sendTx := &transaction.Payment{
BaseTx: transaction.BaseTx{
@@ -196,7 +196,7 @@ func main() {
// -----------------------------------------------------
// Unauthorize the holder 1 account
fmt.Println("⏳ Unauthorize the holder 1 account with the DepositPreauth transaction and the UnauthorizeCredentials field...")
fmt.Println("Unauthorize the holder 1 account with the DepositPreauth transaction and the UnauthorizeCredentials field...")
unauthorizeTx := &transaction.DepositPreauth{
BaseTx: transaction.BaseTx{
@@ -218,7 +218,7 @@ func main() {
// -----------------------------------------------------
// Sending XRP to the holder 1 account again (which should fail)
fmt.Println("⏳ Sending XRP to the issuer account again (which should fail)...")
fmt.Println("Sending XRP to the issuer account again (which should fail)...")
sendTx2 := &transaction.Payment{
BaseTx: transaction.BaseTx{

86
_code-samples/freeze/go/rpc/main.go
View File

@@ -1,15 +1,15 @@
package main
import (
"fmt"
"fmt"
"github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/currency"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/rpc"
transactions "github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/currency"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/rpc"
transactions "github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
)
const (
@@ -27,62 +27,62 @@ func main() {
// Configure wallets
// Issuer
fmt.Println("⏳ Setting up issuer wallet...")
fmt.Println("Setting up issuer wallet...")
issuer, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Printf("❌ Error creating issuer wallet: %s\n", err)
fmt.Printf("Error creating issuer wallet: %s\n", err)
return
}
err = client.FundWallet(&issuer)
if err != nil {
fmt.Printf("❌ Error funding issuer wallet: %s\n", err)
fmt.Printf("Error funding issuer wallet: %s\n", err)
return
}
fmt.Printf("✅ Issuer wallet funded: %s\n", issuer.ClassicAddress)
fmt.Printf("Issuer wallet funded: %s\n", issuer.ClassicAddress)
// -----------------------------------------------------
// Holder 1
fmt.Println("⏳ Setting up holder 1 wallet...")
fmt.Println("Setting up holder 1 wallet...")
holderWallet1, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Printf("❌ Error creating holder wallet 1: %s\n", err)
fmt.Printf("Error creating holder wallet 1: %s\n", err)
return
}
err = client.FundWallet(&holderWallet1)
if err != nil {
fmt.Printf("❌ Error funding holder wallet 1: %s\n", err)
fmt.Printf("Error funding holder wallet 1: %s\n", err)
return
}
fmt.Printf("✅ Holder wallet 1 funded: %s\n", holderWallet1.ClassicAddress)
fmt.Printf("Holder wallet 1 funded: %s\n", holderWallet1.ClassicAddress)
// -----------------------------------------------------
// Holder 2
fmt.Println("⏳ Setting up holder 2 wallet...")
fmt.Println("Setting up holder 2 wallet...")
holderWallet2, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Printf("❌ Error creating holder wallet 2: %s\n", err)
fmt.Printf("Error creating holder wallet 2: %s\n", err)
return
}
err = client.FundWallet(&holderWallet2)
if err != nil {
fmt.Printf("❌ Error funding holder wallet 2: %s\n", err)
fmt.Printf("Error funding holder wallet 2: %s\n", err)
return
}
fmt.Printf("✅ Holder wallet 2 funded: %s\n", holderWallet2.ClassicAddress)
fmt.Printf("Holder wallet 2 funded: %s\n", holderWallet2.ClassicAddress)
fmt.Println()
fmt.Println("✅ Wallets setup complete!")
fmt.Println("Wallets setup complete!")
fmt.Println()
// -----------------------------------------------------
// Configuring Issuing account
fmt.Println("⏳ Configuring issuer address settings...")
fmt.Println("Configuring issuer address settings...")
accountSet := &transactions.AccountSet{
BaseTx: transactions.BaseTx{
Account: types.Address(issuer.ClassicAddress),
@@ -96,7 +96,7 @@ func main() {
// -----------------------------------------------------
// Trustline from the holder 1 to the issuer
fmt.Println("⏳ Setting up trustline from holder 1 to the issuer...")
fmt.Println("Setting up trustline from holder 1 to the issuer...")
trustSet := &transactions.TrustSet{
BaseTx: transactions.BaseTx{
Account: types.Address(holderWallet1.ClassicAddress),
@@ -112,7 +112,7 @@ func main() {
// -----------------------------------------------------
// Trustline from the holder 2 to the issuer
fmt.Println("⏳ Setting up trustline from holder 2 to the issuer...")
fmt.Println("Setting up trustline from holder 2 to the issuer...")
trustSet = &transactions.TrustSet{
BaseTx: transactions.BaseTx{
Account: types.Address(holderWallet2.ClassicAddress),
@@ -129,7 +129,7 @@ func main() {
// -----------------------------------------------------
// Minting to Holder 1
fmt.Println("⏳ Minting to Holder 1...")
fmt.Println("Minting to Holder 1...")
payment := &transactions.Payment{
BaseTx: transactions.BaseTx{
Account: types.Address(issuer.ClassicAddress),
@@ -146,7 +146,7 @@ func main() {
// -----------------------------------------------------
// Minting to Holder 2
fmt.Println("⏳ Minting to Holder 2...")
fmt.Println("Minting to Holder 2...")
payment = &transactions.Payment{
BaseTx: transactions.BaseTx{
Account: types.Address(issuer.ClassicAddress),
@@ -163,7 +163,7 @@ func main() {
// -----------------------------------------------------
// Sending payment from Holder 1 to Holder 2
fmt.Println("⏳ Sending payment from Holder 1 to Holder 2...")
fmt.Println("Sending payment from Holder 1 to Holder 2...")
payment = &transactions.Payment{
BaseTx: transactions.BaseTx{
Account: types.Address(holderWallet1.ClassicAddress),
@@ -180,7 +180,7 @@ func main() {
// -----------------------------------------------------
// Freezing and Deep Freezing holder1
fmt.Println("⏳ Freezing and Deep Freezing holder 1 trustline...")
fmt.Println("Freezing and Deep Freezing holder 1 trustline...")
trustSet = &transactions.TrustSet{
BaseTx: transactions.BaseTx{
Account: types.Address(issuer.ClassicAddress),
@@ -196,10 +196,10 @@ func main() {
submitAndWait(client, trustSet, issuer)
// ------------------- SHOULD FAIL ⬇️ ------------------
// ------------------- SHOULD FAIL ------------------
// Sending payment from Holder 1 to Holder 2 (which should fail), Holder 1 can't decrease its balance
fmt.Println("⏳ Sending payment from Holder 1 to Holder 2 (which should fail). Holder 1 can't decrease its balance...")
fmt.Println("Sending payment from Holder 1 to Holder 2 (which should fail). Holder 1 can't decrease its balance...")
payment = &transactions.Payment{
BaseTx: transactions.BaseTx{
Account: types.Address(holderWallet1.ClassicAddress),
@@ -213,10 +213,10 @@ func main() {
}
submitAndWait(client, payment, holderWallet1)
// ------------------- SHOULD FAIL ⬇️ ------------------
// ------------------- SHOULD FAIL ------------------
// Sending payment from Holder 2 to Holder 1 (which should fail), Holder 1 can't increase its balance
fmt.Println("⏳ Sending payment from Holder 2 to Holder 1 (which should fail). Holder 1 can't increase its balance...")
fmt.Println("Sending payment from Holder 2 to Holder 1 (which should fail). Holder 1 can't increase its balance...")
payment = &transactions.Payment{
BaseTx: transactions.BaseTx{
Account: types.Address(holderWallet2.ClassicAddress),
@@ -230,10 +230,10 @@ func main() {
}
submitAndWait(client, payment, holderWallet2)
// ------------------- SHOULD FAIL ⬇️ ------------------
// ------------------- SHOULD FAIL ------------------
// Creating OfferCreate transaction (which should fail), Holder 1 can't create an offer
fmt.Println("⏳ Creating OfferCreate transaction (which should fail). Holder 1 can't create an offer...")
fmt.Println("Creating OfferCreate transaction (which should fail). Holder 1 can't create an offer...")
offerCreate := &transactions.OfferCreate{
BaseTx: transactions.BaseTx{
Account: types.Address(holderWallet1.ClassicAddress),
@@ -250,7 +250,7 @@ func main() {
// -----------------------------------------------------
// Unfreezing and Deep Unfreezing holder 1
fmt.Println("⏳ Unfreezing and Deep Unfreezing holder 1 trustline...")
fmt.Println("Unfreezing and Deep Unfreezing holder 1 trustline...")
trustSet = &transactions.TrustSet{
BaseTx: transactions.BaseTx{
Account: types.Address(issuer.ClassicAddress),
@@ -268,7 +268,7 @@ func main() {
// -----------------------------------------------------
// Sending payment from Holder 1 to Holder 2 (which should succeed), Holder 1 can decrease its balance
fmt.Println("⏳ Sending payment from Holder 1 to Holder 2 (which should succeed). Holder 1 can decrease its balance...")
fmt.Println("Sending payment from Holder 1 to Holder 2 (which should succeed). Holder 1 can decrease its balance...")
payment = &transactions.Payment{
BaseTx: transactions.BaseTx{
Account: types.Address(holderWallet1.ClassicAddress),
@@ -285,7 +285,7 @@ func main() {
// -----------------------------------------------------
// Sending payment from Holder 2 to Holder 1 (which should succeed), Holder 1 can increase its balance
fmt.Println("⏳ Sending payment from Holder 2 to Holder 1 (which should succeed). Holder 1 can increase its balance...")
fmt.Println("Sending payment from Holder 2 to Holder 1 (which should succeed). Holder 1 can increase its balance...")
payment = &transactions.Payment{
BaseTx: transactions.BaseTx{
Account: types.Address(holderWallet2.ClassicAddress),
@@ -316,32 +316,32 @@ func getRpcClient() *rpc.Client {
// submitAndWait submits a transaction and waits for it to be included in a validated ledger
func submitAndWait(client *rpc.Client, txn SubmittableTransaction, wallet wallet.Wallet) {
fmt.Printf("⏳ Submitting %s transaction...\n", txn.TxType())
fmt.Printf("Submitting %s transaction...\n", txn.TxType())
flattenedTx := txn.Flatten()
err := client.Autofill(&flattenedTx)
if err != nil {
fmt.Printf("❌ Error autofilling %s transaction: %s\n", txn.TxType(), err)
fmt.Printf("Error autofilling %s transaction: %s\n", txn.TxType(), err)
fmt.Println()
return
}
txBlob, _, err := wallet.Sign(flattenedTx)
if err != nil {
fmt.Printf("❌ Error signing %s transaction: %s\n", txn.TxType(), err)
fmt.Printf("Error signing %s transaction: %s\n", txn.TxType(), err)
fmt.Println()
return
}
response, err := client.SubmitTxBlobAndWait(txBlob, false)
if err != nil {
fmt.Printf("❌ Error submitting %s transaction: %s\n", txn.TxType(), err)
fmt.Printf("Error submitting %s transaction: %s\n", txn.TxType(), err)
fmt.Println()
return
}
fmt.Printf("✅ %s transaction submitted\n", txn.TxType())
fmt.Printf("🌐 Hash: %s\n", response.Hash.String())
fmt.Printf("%s transaction submitted\n", txn.TxType())
fmt.Printf("Hash: %s\n", response.Hash.String())
fmt.Println()
}

90
_code-samples/freeze/go/ws/main.go
View File

@@ -1,15 +1,15 @@
package main
import (
"fmt"
"fmt"
"github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/currency"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
transactions "github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/xrpl/websocket"
"github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/currency"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
transactions "github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/xrpl/websocket"
)
const (
@@ -22,7 +22,7 @@ type SubmittableTransaction interface {
}
func main() {
fmt.Println("⏳ Setting up client...")
fmt.Println("Setting up client...")
client := getClient()
fmt.Println("Connecting to server...")
@@ -31,7 +31,7 @@ func main() {
return
}
fmt.Println("✅ Client configured!")
fmt.Println("Client configured!")
fmt.Println()
fmt.Printf("Connection: %t", client.IsConnected())
@@ -40,62 +40,62 @@ func main() {
// Configure wallets
// Issuer
fmt.Println("⏳ Setting up issuer wallet...")
fmt.Println("Setting up issuer wallet...")
issuer, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Printf("❌ Error creating issuer wallet: %s\n", err)
fmt.Printf("Error creating issuer wallet: %s\n", err)
return
}
err = client.FundWallet(&issuer)
if err != nil {
fmt.Printf("❌ Error funding issuer wallet: %s\n", err)
fmt.Printf("Error funding issuer wallet: %s\n", err)
return
}
fmt.Printf("✅ Issuer wallet funded: %s\n", issuer.ClassicAddress)
fmt.Printf("Issuer wallet funded: %s\n", issuer.ClassicAddress)
// -----------------------------------------------------
// Holder 1
fmt.Println("⏳ Setting up holder 1 wallet...")
fmt.Println("Setting up holder 1 wallet...")
holderWallet1, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Printf("❌ Error creating holder wallet 1: %s\n", err)
fmt.Printf("Error creating holder wallet 1: %s\n", err)
return
}
err = client.FundWallet(&holderWallet1)
if err != nil {
fmt.Printf("❌ Error funding holder wallet 1: %s\n", err)
fmt.Printf("Error funding holder wallet 1: %s\n", err)
return
}
fmt.Printf("✅ Holder wallet 1 funded: %s\n", holderWallet1.ClassicAddress)
fmt.Printf("Holder wallet 1 funded: %s\n", holderWallet1.ClassicAddress)
// -----------------------------------------------------
// Holder 2
fmt.Println("⏳ Setting up holder 2 wallet...")
fmt.Println("Setting up holder 2 wallet...")
holderWallet2, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Printf("❌ Error creating holder wallet 2: %s\n", err)
fmt.Printf("Error creating holder wallet 2: %s\n", err)
return
}
err = client.FundWallet(&holderWallet2)
if err != nil {
fmt.Printf("❌ Error funding holder wallet 2: %s\n", err)
fmt.Printf("Error funding holder wallet 2: %s\n", err)
return
}
fmt.Printf("✅ Holder wallet 2 funded: %s\n", holderWallet2.ClassicAddress)
fmt.Printf("Holder wallet 2 funded: %s\n", holderWallet2.ClassicAddress)
fmt.Println()
fmt.Println("✅ Wallets setup complete!")
fmt.Println("Wallets setup complete!")
fmt.Println()
// -----------------------------------------------------
// Configuring Issuing account
fmt.Println("⏳ Configuring issuer address settings...")
fmt.Println("Configuring issuer address settings...")
accountSet := &transactions.AccountSet{
BaseTx: transactions.BaseTx{
Account: types.Address(issuer.ClassicAddress),
@@ -109,7 +109,7 @@ func main() {
// -----------------------------------------------------
// Trustline from the holder 1 to the issuer
fmt.Println("⏳ Setting up trustline from holder 1 to the issuer...")
fmt.Println("Setting up trustline from holder 1 to the issuer...")
trustSet := &transactions.TrustSet{
BaseTx: transactions.BaseTx{
Account: types.Address(holderWallet1.ClassicAddress),
@@ -125,7 +125,7 @@ func main() {
// -----------------------------------------------------
// Trustline from the holder 2 to the issuer
fmt.Println("⏳ Setting up trustline from holder 2 to the issuer...")
fmt.Println("Setting up trustline from holder 2 to the issuer...")
trustSet = &transactions.TrustSet{
BaseTx: transactions.BaseTx{
Account: types.Address(holderWallet2.ClassicAddress),
@@ -142,7 +142,7 @@ func main() {
// -----------------------------------------------------
// Minting to Holder 1
fmt.Println("⏳ Minting to Holder 1...")
fmt.Println("Minting to Holder 1...")
payment := &transactions.Payment{
BaseTx: transactions.BaseTx{
Account: types.Address(issuer.ClassicAddress),
@@ -159,7 +159,7 @@ func main() {
// -----------------------------------------------------
// Minting to Holder 2
fmt.Println("⏳ Minting to Holder 2...")
fmt.Println("Minting to Holder 2...")
payment = &transactions.Payment{
BaseTx: transactions.BaseTx{
Account: types.Address(issuer.ClassicAddress),
@@ -176,7 +176,7 @@ func main() {
// -----------------------------------------------------
// Sending payment from Holder 1 to Holder 2
fmt.Println("⏳ Sending payment from Holder 1 to Holder 2...")
fmt.Println("Sending payment from Holder 1 to Holder 2...")
payment = &transactions.Payment{
BaseTx: transactions.BaseTx{
Account: types.Address(holderWallet1.ClassicAddress),
@@ -193,7 +193,7 @@ func main() {
// -----------------------------------------------------
// Freezing and Deep Freezing holder1
fmt.Println("⏳ Freezing and Deep Freezing holder 1 trustline...")
fmt.Println("Freezing and Deep Freezing holder 1 trustline...")
trustSet = &transactions.TrustSet{
BaseTx: transactions.BaseTx{
Account: types.Address(issuer.ClassicAddress),
@@ -209,10 +209,10 @@ func main() {
submitAndWait(client, trustSet, issuer)
// ------------------- SHOULD FAIL ⬇️ ------------------
// ------------------- SHOULD FAIL ------------------
// Sending payment from Holder 1 to Holder 2 (which should fail), Holder 1 can't decrease its balance
fmt.Println("⏳ Sending payment from Holder 1 to Holder 2 (which should fail). Holder 1 can't decrease its balance...")
fmt.Println("Sending payment from Holder 1 to Holder 2 (which should fail). Holder 1 can't decrease its balance...")
payment = &transactions.Payment{
BaseTx: transactions.BaseTx{
Account: types.Address(holderWallet1.ClassicAddress),
@@ -226,10 +226,10 @@ func main() {
}
submitAndWait(client, payment, holderWallet1)
// ------------------- SHOULD FAIL ⬇️ ------------------
// ------------------- SHOULD FAIL ------------------
// Sending payment from Holder 2 to Holder 1 (which should fail), Holder 1 can't increase its balance
fmt.Println("⏳ Sending payment from Holder 2 to Holder 1 (which should fail). Holder 1 can't increase its balance...")
fmt.Println("Sending payment from Holder 2 to Holder 1 (which should fail). Holder 1 can't increase its balance...")
payment = &transactions.Payment{
BaseTx: transactions.BaseTx{
Account: types.Address(holderWallet2.ClassicAddress),
@@ -243,10 +243,10 @@ func main() {
}
submitAndWait(client, payment, holderWallet2)
// ------------------- SHOULD FAIL ⬇️ ------------------
// ------------------- SHOULD FAIL ------------------
// Creating OfferCreate transaction (which should fail), Holder 1 can't create an offer
fmt.Println("⏳ Creating OfferCreate transaction (which should fail). Holder 1 can't create an offer...")
fmt.Println("Creating OfferCreate transaction (which should fail). Holder 1 can't create an offer...")
offerCreate := &transactions.OfferCreate{
BaseTx: transactions.BaseTx{
Account: types.Address(holderWallet1.ClassicAddress),
@@ -263,7 +263,7 @@ func main() {
// -----------------------------------------------------
// Unfreezing and Deep Unfreezing holder 1
fmt.Println("⏳ Unfreezing and Deep Unfreezing holder 1 trustline...")
fmt.Println("Unfreezing and Deep Unfreezing holder 1 trustline...")
trustSet = &transactions.TrustSet{
BaseTx: transactions.BaseTx{
Account: types.Address(issuer.ClassicAddress),
@@ -281,7 +281,7 @@ func main() {
// -----------------------------------------------------
// Sending payment from Holder 1 to Holder 2 (which should succeed), Holder 1 can decrease its balance
fmt.Println("⏳ Sending payment from Holder 1 to Holder 2 (which should succeed). Holder 1 can decrease its balance...")
fmt.Println("Sending payment from Holder 1 to Holder 2 (which should succeed). Holder 1 can decrease its balance...")
payment = &transactions.Payment{
BaseTx: transactions.BaseTx{
Account: types.Address(holderWallet1.ClassicAddress),
@@ -298,7 +298,7 @@ func main() {
// -----------------------------------------------------
// Sending payment from Holder 2 to Holder 1 (which should succeed), Holder 1 can increase its balance
fmt.Println("⏳ Sending payment from Holder 2 to Holder 1 (which should succeed). Holder 1 can increase its balance...")
fmt.Println("Sending payment from Holder 2 to Holder 1 (which should succeed). Holder 1 can increase its balance...")
payment = &transactions.Payment{
BaseTx: transactions.BaseTx{
Account: types.Address(holderWallet2.ClassicAddress),
@@ -326,32 +326,32 @@ func getClient() *websocket.Client {
// submitAndWait submits a transaction and waits for it to be included in a validated ledger
func submitAndWait(client *websocket.Client, txn SubmittableTransaction, wallet wallet.Wallet) {
fmt.Printf("⏳ Submitting %s transaction...\n", txn.TxType())
fmt.Printf("Submitting %s transaction...\n", txn.TxType())
flattenedTx := txn.Flatten()
err := client.Autofill(&flattenedTx)
if err != nil {
fmt.Printf("❌ Error autofilling %s transaction: %s\n", txn.TxType(), err)
fmt.Printf("Error autofilling %s transaction: %s\n", txn.TxType(), err)
fmt.Println()
return
}
txBlob, _, err := wallet.Sign(flattenedTx)
if err != nil {
fmt.Printf("❌ Error signing %s transaction: %s\n", txn.TxType(), err)
fmt.Printf("Error signing %s transaction: %s\n", txn.TxType(), err)
fmt.Println()
return
}
response, err := client.SubmitTxBlobAndWait(txBlob, false)
if err != nil {
fmt.Printf("❌ Error submitting %s transaction: %s\n", txn.TxType(), err)
fmt.Printf("Error submitting %s transaction: %s\n", txn.TxType(), err)
fmt.Println()
return
}
fmt.Printf("✅ %s transaction submitted\n", txn.TxType())
fmt.Printf("🌐 Hash: %s\n", response.Hash.String())
fmt.Printf("%s transaction submitted\n", txn.TxType())
fmt.Printf("Hash: %s\n", response.Hash.String())
fmt.Println()
}

5
_code-samples/get-started/go/base/rpc/main.go
View File

@@ -1,8 +1,9 @@
package main
import (
"github.com/Peersyst/xrpl-go/xrpl/queries/utility"
"github.com/Peersyst/xrpl-go/xrpl/rpc"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/queries/utility"
"github.com/Peersyst/xrpl-go/xrpl/rpc"
)
func main() {

5
_code-samples/get-started/go/base/ws/main.go
View File

@@ -1,9 +1,10 @@
package main
import (
"fmt"
"fmt"
"github.com/Peersyst/xrpl-go/xrpl/websocket"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/websocket"
)
func main() {

20
_code-samples/get-started/go/get-acc-info/ws/main.go
View File

@@ -1,15 +1,15 @@
package main
import (
"fmt"
"fmt"
"github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/queries/account"
"github.com/Peersyst/xrpl-go/xrpl/queries/common"
"github.com/Peersyst/xrpl-go/xrpl/queries/ledger"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/xrpl/websocket"
"github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/queries/account"
"github.com/Peersyst/xrpl-go/xrpl/queries/common"
"github.com/Peersyst/xrpl-go/xrpl/queries/ledger"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/xrpl/websocket"
)
func main() {
@@ -31,11 +31,11 @@ func main() {
}
if !client.IsConnected() {
fmt.Println("❌ Failed to connect to testnet")
fmt.Println("Failed to connect to testnet")
return
}
fmt.Println("✅ Connected to testnet")
fmt.Println("Connected to testnet")
fmt.Println()
// Create a new wallet

184
_code-samples/issue-a-token/go/rpc/main.go
View File

@@ -1,14 +1,14 @@
package main
import (
"fmt"
"fmt"
"github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/rpc"
transactions "github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/rpc"
transactions "github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
)
const (
@@ -19,7 +19,7 @@ func main() {
//
// Configure client
//
fmt.Println("⏳ Setting up client...")
fmt.Println("Setting up client...")
cfg, err := rpc.NewClientConfig(
"https://s.altnet.rippletest.net:51234/",
rpc.WithFaucetProvider(faucet.NewTestnetFaucetProvider()),
@@ -29,60 +29,60 @@ func main() {
}
client := rpc.NewClient(cfg)
fmt.Println("✅ Client configured!")
fmt.Println("Client configured!")
fmt.Println()
//
// Configure wallets
//
fmt.Println("⏳ Setting up wallets...")
fmt.Println("Setting up wallets...")
coldWallet, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Printf("❌ Error creating cold wallet: %s\n", err)
fmt.Printf("Error creating cold wallet: %s\n", err)
return
}
err = client.FundWallet(&coldWallet)
if err != nil {
fmt.Printf("❌ Error funding cold wallet: %s\n", err)
fmt.Printf("Error funding cold wallet: %s\n", err)
return
}
fmt.Println("💸 Cold wallet funded!")
fmt.Println("Cold wallet funded!")
hotWallet, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Printf("❌ Error creating hot wallet: %s\n", err)
fmt.Printf("Error creating hot wallet: %s\n", err)
return
}
err = client.FundWallet(&hotWallet)
if err != nil {
fmt.Printf("❌ Error funding hot wallet: %s\n", err)
fmt.Printf("Error funding hot wallet: %s\n", err)
return
}
fmt.Println("💸 Hot wallet funded!")
fmt.Println("Hot wallet funded!")
customerOneWallet, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Printf("❌ Error creating token wallet: %s\n", err)
fmt.Printf("Error creating token wallet: %s\n", err)
return
}
err = client.FundWallet(&customerOneWallet)
if err != nil {
fmt.Printf("❌ Error funding customer one wallet: %s\n", err)
fmt.Printf("Error funding customer one wallet: %s\n", err)
return
}
fmt.Println("💸 Customer one wallet funded!")
fmt.Println("Customer one wallet funded!")
fmt.Println()
fmt.Println("✅ Wallets setup complete!")
fmt.Println("💳 Cold wallet:", coldWallet.ClassicAddress)
fmt.Println("💳 Hot wallet:", hotWallet.ClassicAddress)
fmt.Println("💳 Customer one wallet:", customerOneWallet.ClassicAddress)
fmt.Println("Wallets setup complete!")
fmt.Println("Cold wallet:", coldWallet.ClassicAddress)
fmt.Println("Hot wallet:", hotWallet.ClassicAddress)
fmt.Println("Customer one wallet:", customerOneWallet.ClassicAddress)
fmt.Println()
//
// Configure cold address settings
//
fmt.Println("⏳ Configuring cold address settings...")
fmt.Println("Configuring cold address settings...")
coldWalletAccountSet := &transactions.AccountSet{
BaseTx: transactions.BaseTx{
Account: types.Address(coldWallet.ClassicAddress),
@@ -101,37 +101,37 @@ func main() {
err = client.Autofill(&flattenedTx)
if err != nil {
fmt.Printf("❌ Error autofilling transaction: %s\n", err)
fmt.Printf("Error autofilling transaction: %s\n", err)
return
}
txBlob, _, err := coldWallet.Sign(flattenedTx)
if err != nil {
fmt.Printf("❌ Error signing transaction: %s\n", err)
fmt.Printf("Error signing transaction: %s\n", err)
return
}
response, err := client.SubmitTxBlobAndWait(txBlob, false)
if err != nil {
fmt.Printf("❌ Error submitting transaction: %s\n", err)
fmt.Printf("Error submitting transaction: %s\n", err)
return
}
if !response.Validated {
fmt.Println("❌ Cold address settings configuration failed!")
fmt.Println("Cold address settings configuration failed!")
fmt.Println("Try again!")
fmt.Println()
return
}
fmt.Println("✅ Cold address settings configured!")
fmt.Printf("🌐 Hash: %s\n", response.Hash.String())
fmt.Println("Cold address settings configured!")
fmt.Printf("Hash: %s\n", response.Hash.String())
fmt.Println()
//
// Configure hot address settings
//
fmt.Println("⏳ Configuring hot address settings...")
fmt.Println("Configuring hot address settings...")
hotWalletAccountSet := &transactions.AccountSet{
BaseTx: transactions.BaseTx{
Account: types.Address(hotWallet.ClassicAddress),
@@ -146,37 +146,37 @@ func main() {
flattenedTx = hotWalletAccountSet.Flatten()
err = client.Autofill(&flattenedTx)
if err != nil {
fmt.Printf("❌ Error autofilling transaction: %s\n", err)
fmt.Printf("Error autofilling transaction: %s\n", err)
return
}
txBlob, _, err = hotWallet.Sign(flattenedTx)
if err != nil {
fmt.Printf("❌ Error signing transaction: %s\n", err)
fmt.Printf("Error signing transaction: %s\n", err)
return
}
response, err = client.SubmitTxBlobAndWait(txBlob, false)
if err != nil {
fmt.Printf("❌ Error submitting transaction: %s\n", err)
fmt.Printf("Error submitting transaction: %s\n", err)
return
}
if !response.Validated {
fmt.Println("❌ Hot address settings configuration failed!")
fmt.Println("Hot address settings configuration failed!")
fmt.Println("Try again!")
fmt.Println()
return
}
fmt.Println("✅ Hot address settings configured!")
fmt.Printf("🌐 Hash: %s\n", response.Hash.String())
fmt.Println("Hot address settings configured!")
fmt.Printf("Hash: %s\n", response.Hash.String())
fmt.Println()
//
// Create trust line from hot to cold address
//
fmt.Println("⏳ Creating trust line from hot to cold address...")
fmt.Println("Creating trust line from hot to cold address...")
hotColdTrustSet := &transactions.TrustSet{
BaseTx: transactions.BaseTx{
Account: types.Address(hotWallet.ClassicAddress),
@@ -191,37 +191,37 @@ func main() {
flattenedTx = hotColdTrustSet.Flatten()
err = client.Autofill(&flattenedTx)
if err != nil {
fmt.Printf("❌ Error autofilling transaction: %s\n", err)
fmt.Printf("Error autofilling transaction: %s\n", err)
return
}
txBlob, _, err = hotWallet.Sign(flattenedTx)
if err != nil {
fmt.Printf("❌ Error signing transaction: %s\n", err)
fmt.Printf("Error signing transaction: %s\n", err)
return
}
response, err = client.SubmitTxBlobAndWait(txBlob, false)
if err != nil {
fmt.Printf("❌ Error submitting transaction: %s\n", err)
fmt.Printf("Error submitting transaction: %s\n", err)
return
}
if !response.Validated {
fmt.Println("❌ Trust line from hot to cold address creation failed!")
fmt.Println("Trust line from hot to cold address creation failed!")
fmt.Println("Try again!")
fmt.Println()
return
}
fmt.Println("✅ Trust line from hot to cold address created!")
fmt.Printf("🌐 Hash: %s\n", response.Hash.String())
fmt.Println("Trust line from hot to cold address created!")
fmt.Printf("Hash: %s\n", response.Hash.String())
fmt.Println()
//
// Create trust line from costumer one to cold address
//
fmt.Println("⏳ Creating trust line from customer one to cold address...")
fmt.Println("Creating trust line from customer one to cold address...")
customerOneColdTrustSet := &transactions.TrustSet{
BaseTx: transactions.BaseTx{
Account: types.Address(customerOneWallet.ClassicAddress),
@@ -236,37 +236,37 @@ func main() {
flattenedTx = customerOneColdTrustSet.Flatten()
err = client.Autofill(&flattenedTx)
if err != nil {
fmt.Printf("❌ Error autofilling transaction: %s\n", err)
fmt.Printf("Error autofilling transaction: %s\n", err)
return
}
txBlob, _, err = customerOneWallet.Sign(flattenedTx)
if err != nil {
fmt.Printf("❌ Error signing transaction: %s\n", err)
fmt.Printf("Error signing transaction: %s\n", err)
return
}
response, err = client.SubmitTxBlobAndWait(txBlob, false)
if err != nil {
fmt.Printf("❌ Error submitting transaction: %s\n", err)
fmt.Printf("Error submitting transaction: %s\n", err)
return
}
if !response.Validated {
fmt.Println("❌ Trust line from customer one to cold address creation failed!")
fmt.Println("Trust line from customer one to cold address creation failed!")
fmt.Println("Try again!")
fmt.Println()
return
}
fmt.Println("✅ Trust line from customer one to cold address created!")
fmt.Printf("🌐 Hash: %s\n", response.Hash.String())
fmt.Println("Trust line from customer one to cold address created!")
fmt.Printf("Hash: %s\n", response.Hash.String())
fmt.Println()
//
// Send tokens from cold wallet to hot wallet
//
fmt.Println("⏳ Sending tokens from cold wallet to hot wallet...")
fmt.Println("Sending tokens from cold wallet to hot wallet...")
coldToHotPayment := &transactions.Payment{
BaseTx: transactions.BaseTx{
Account: types.Address(coldWallet.ClassicAddress),
@@ -283,37 +283,37 @@ func main() {
flattenedTx = coldToHotPayment.Flatten()
err = client.Autofill(&flattenedTx)
if err != nil {
fmt.Printf("❌ Error autofilling transaction: %s\n", err)
fmt.Printf("Error autofilling transaction: %s\n", err)
return
}
txBlob, _, err = coldWallet.Sign(flattenedTx)
if err != nil {
fmt.Printf("❌ Error signing transaction: %s\n", err)
fmt.Printf("Error signing transaction: %s\n", err)
return
}
response, err = client.SubmitTxBlobAndWait(txBlob, false)
if err != nil {
fmt.Printf("❌ Error submitting transaction: %s\n", err)
fmt.Printf("Error submitting transaction: %s\n", err)
return
}
if !response.Validated {
fmt.Println("❌ Tokens not sent from cold wallet to hot wallet!")
fmt.Println("Tokens not sent from cold wallet to hot wallet!")
fmt.Println("Try again!")
fmt.Println()
return
}
fmt.Println("✅ Tokens sent from cold wallet to hot wallet!")
fmt.Printf("🌐 Hash: %s\n", response.Hash.String())
fmt.Println("Tokens sent from cold wallet to hot wallet!")
fmt.Printf("Hash: %s\n", response.Hash.String())
fmt.Println()
//
// Send tokens from hot wallet to customer one
//
fmt.Println("⏳ Sending tokens from cold wallet to customer one...")
fmt.Println("Sending tokens from cold wallet to customer one...")
coldToCustomerOnePayment := &transactions.Payment{
BaseTx: transactions.BaseTx{
Account: types.Address(coldWallet.ClassicAddress),
@@ -329,36 +329,36 @@ func main() {
flattenedTx = coldToCustomerOnePayment.Flatten()
err = client.Autofill(&flattenedTx)
if err != nil {
fmt.Printf("❌ Error autofilling transaction: %s\n", err)
fmt.Printf("Error autofilling transaction: %s\n", err)
return
}
txBlob, _, err = coldWallet.Sign(flattenedTx)
if err != nil {
fmt.Printf("❌ Error signing transaction: %s\n", err)
fmt.Printf("Error signing transaction: %s\n", err)
return
}
response, err = client.SubmitTxBlobAndWait(txBlob, false)
if err != nil {
fmt.Printf("❌ Error submitting transaction: %s\n", err)
fmt.Printf("Error submitting transaction: %s\n", err)
return
}
if !response.Validated {
fmt.Println("❌ Tokens not sent from cold wallet to customer one!")
fmt.Println("Tokens not sent from cold wallet to customer one!")
fmt.Println()
return
}
fmt.Println("✅ Tokens sent from cold wallet to customer one!")
fmt.Printf("🌐 Hash: %s\n", response.Hash.String())
fmt.Println("Tokens sent from cold wallet to customer one!")
fmt.Printf("Hash: %s\n", response.Hash.String())
fmt.Println()
//
// Freeze cold wallet
//
fmt.Println("⏳ Freezing cold wallet...")
fmt.Println("Freezing cold wallet...")
freezeColdWallet := &transactions.AccountSet{
BaseTx: transactions.BaseTx{
Account: types.Address(coldWallet.ClassicAddress),
@@ -370,37 +370,37 @@ func main() {
flattenedTx = freezeColdWallet.Flatten()
err = client.Autofill(&flattenedTx)
if err != nil {
fmt.Printf("❌ Error autofilling transaction: %s\n", err)
fmt.Printf("Error autofilling transaction: %s\n", err)
return
}
txBlob, _, err = coldWallet.Sign(flattenedTx)
if err != nil {
fmt.Printf("❌ Error signing transaction: %s\n", err)
fmt.Printf("Error signing transaction: %s\n", err)
return
}
response, err = client.SubmitTxBlobAndWait(txBlob, false)
if err != nil {
fmt.Printf("❌ Error submitting transaction: %s\n", err)
fmt.Printf("Error submitting transaction: %s\n", err)
return
}
if !response.Validated {
fmt.Println("❌ Cold wallet freezing failed!")
fmt.Printf("🌐 Hash: %s\n", response.Hash.String())
fmt.Println("Cold wallet freezing failed!")
fmt.Printf("Hash: %s\n", response.Hash.String())
fmt.Println()
return
}
fmt.Println("✅ Cold wallet frozen!")
fmt.Printf("🌐 Hash: %s\n", response.Hash.String())
fmt.Println("Cold wallet frozen!")
fmt.Printf("Hash: %s\n", response.Hash.String())
fmt.Println()
//
// Try to send tokens from hot wallet to customer one
//
fmt.Println("⏳ Trying to send tokens from hot wallet to customer one...")
fmt.Println("Trying to send tokens from hot wallet to customer one...")
hotToCustomerOnePayment := &transactions.Payment{
BaseTx: transactions.BaseTx{
Account: types.Address(hotWallet.ClassicAddress),
@@ -416,13 +416,13 @@ func main() {
flattenedTx = hotToCustomerOnePayment.Flatten()
err = client.Autofill(&flattenedTx)
if err != nil {
fmt.Printf("❌ Error autofilling transaction: %s\n", err)
fmt.Printf("Error autofilling transaction: %s\n", err)
return
}
txBlob, _, err = hotWallet.Sign(flattenedTx)
if err != nil {
fmt.Printf("❌ Error signing transaction: %s\n", err)
fmt.Printf("Error signing transaction: %s\n", err)
return
}
@@ -431,13 +431,13 @@ func main() {
return
}
fmt.Println("❌ Tokens not sent from hot wallet to customer one!")
fmt.Println("Tokens not sent from hot wallet to customer one!")
fmt.Println()
// //
// // Unfreeze cold wallet
// //
fmt.Println("⏳ Unfreezing cold wallet...")
fmt.Println("Unfreezing cold wallet...")
unfreezeColdWallet := &transactions.AccountSet{
BaseTx: transactions.BaseTx{
Account: types.Address(coldWallet.ClassicAddress),
@@ -449,37 +449,37 @@ func main() {
flattenedTx = unfreezeColdWallet.Flatten()
err = client.Autofill(&flattenedTx)
if err != nil {
fmt.Printf("❌ Error autofilling transaction: %s\n", err)
fmt.Printf("Error autofilling transaction: %s\n", err)
return
}
txBlob, _, err = coldWallet.Sign(flattenedTx)
if err != nil {
fmt.Printf("❌ Error signing transaction: %s\n", err)
fmt.Printf("Error signing transaction: %s\n", err)
return
}
response, err = client.SubmitTxBlobAndWait(txBlob, false)
if err != nil {
fmt.Printf("❌ Error submitting transaction: %s\n", err)
fmt.Printf("Error submitting transaction: %s\n", err)
return
}
if !response.Validated {
fmt.Println("❌ Cold wallet unfreezing failed!")
fmt.Printf("🌐 Hash: %s\n", response.Hash.String())
fmt.Println("Cold wallet unfreezing failed!")
fmt.Printf("Hash: %s\n", response.Hash.String())
fmt.Println()
return
}
fmt.Println("✅ Cold wallet unfrozen!")
fmt.Printf("🌐 Hash: %s\n", response.Hash.String())
fmt.Println("Cold wallet unfrozen!")
fmt.Printf("Hash: %s\n", response.Hash.String())
fmt.Println()
//
// Try to send tokens from hot wallet to customer one
//
fmt.Println("⏳ Trying to send tokens from hot wallet to customer one...")
fmt.Println("Trying to send tokens from hot wallet to customer one...")
hotToCustomerOnePayment = &transactions.Payment{
BaseTx: transactions.BaseTx{
Account: types.Address(hotWallet.ClassicAddress),
@@ -495,29 +495,29 @@ func main() {
flattenedTx = hotToCustomerOnePayment.Flatten()
err = client.Autofill(&flattenedTx)
if err != nil {
fmt.Printf("❌ Error autofilling transaction: %s\n", err)
fmt.Printf("Error autofilling transaction: %s\n", err)
return
}
txBlob, _, err = hotWallet.Sign(flattenedTx)
if err != nil {
fmt.Printf("❌ Error signing transaction: %s\n", err)
fmt.Printf("Error signing transaction: %s\n", err)
return
}
response, err = client.SubmitTxBlobAndWait(txBlob, false)
if err != nil {
fmt.Printf("❌ Error submitting transaction: %s\n", err)
fmt.Printf("Error submitting transaction: %s\n", err)
return
}
if !response.Validated {
fmt.Println("❌ Tokens not sent from hot wallet to customer one!")
fmt.Println("Tokens not sent from hot wallet to customer one!")
fmt.Println("Try again!")
return
}
fmt.Println("✅ Tokens sent from hot wallet to customer one!")
fmt.Printf("🌐 Hash: %s\n", response.Hash.String())
fmt.Println("Tokens sent from hot wallet to customer one!")
fmt.Printf("Hash: %s\n", response.Hash.String())
fmt.Println()
}

184
_code-samples/issue-a-token/go/ws/main.go
View File

@@ -1,14 +1,14 @@
package main
import (
"fmt"
"fmt"
"github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
transactions "github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/xrpl/websocket"
"github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
transactions "github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/xrpl/websocket"
)
const (
@@ -19,14 +19,14 @@ func main() {
//
// Configure client
//
fmt.Println("⏳ Setting up client...")
fmt.Println("Setting up client...")
client := websocket.NewClient(
websocket.NewClientConfig().
WithHost("wss://s.altnet.rippletest.net").
WithFaucetProvider(faucet.NewTestnetFaucetProvider()),
)
defer client.Disconnect()
fmt.Println("✅ Client configured!")
fmt.Println("Client configured!")
fmt.Println()
fmt.Println("Connecting to server...")
@@ -41,54 +41,54 @@ func main() {
//
// Configure wallets
//
fmt.Println("⏳ Setting up wallets...")
fmt.Println("Setting up wallets...")
coldWallet, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Printf("❌ Error creating cold wallet: %s\n", err)
fmt.Printf("Error creating cold wallet: %s\n", err)
return
}
err = client.FundWallet(&coldWallet)
if err != nil {
fmt.Printf("❌ Error funding cold wallet: %s\n", err)
fmt.Printf("Error funding cold wallet: %s\n", err)
return
}
fmt.Println("💸 Cold wallet funded!")
fmt.Println("Cold wallet funded!")
hotWallet, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Printf("❌ Error creating hot wallet: %s\n", err)
fmt.Printf("Error creating hot wallet: %s\n", err)
return
}
err = client.FundWallet(&hotWallet)
if err != nil {
fmt.Printf("❌ Error funding hot wallet: %s\n", err)
fmt.Printf("Error funding hot wallet: %s\n", err)
return
}
fmt.Println("💸 Hot wallet funded!")
fmt.Println("Hot wallet funded!")
customerOneWallet, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Printf("❌ Error creating token wallet: %s\n", err)
fmt.Printf("Error creating token wallet: %s\n", err)
return
}
err = client.FundWallet(&customerOneWallet)
if err != nil {
fmt.Printf("❌ Error funding customer one wallet: %s\n", err)
fmt.Printf("Error funding customer one wallet: %s\n", err)
return
}
fmt.Println("💸 Customer one wallet funded!")
fmt.Println("Customer one wallet funded!")
fmt.Println()
fmt.Println("✅ Wallets setup complete!")
fmt.Println("💳 Cold wallet:", coldWallet.ClassicAddress)
fmt.Println("💳 Hot wallet:", hotWallet.ClassicAddress)
fmt.Println("💳 Customer one wallet:", customerOneWallet.ClassicAddress)
fmt.Println("Wallets setup complete!")
fmt.Println("Cold wallet:", coldWallet.ClassicAddress)
fmt.Println("Hot wallet:", hotWallet.ClassicAddress)
fmt.Println("Customer one wallet:", customerOneWallet.ClassicAddress)
fmt.Println()
//
// Configure cold address settings
//
fmt.Println("⏳ Configuring cold address settings...")
fmt.Println("Configuring cold address settings...")
coldWalletAccountSet := &transactions.AccountSet{
BaseTx: transactions.BaseTx{
Account: types.Address(coldWallet.ClassicAddress),
@@ -107,37 +107,37 @@ func main() {
err = client.Autofill(&flattenedTx)
if err != nil {
fmt.Printf("❌ Error autofilling transaction: %s\n", err)
fmt.Printf("Error autofilling transaction: %s\n", err)
return
}
txBlob, _, err := coldWallet.Sign(flattenedTx)
if err != nil {
fmt.Printf("❌ Error signing transaction: %s\n", err)
fmt.Printf("Error signing transaction: %s\n", err)
return
}
response, err := client.SubmitTxBlobAndWait(txBlob, false)
if err != nil {
fmt.Printf("❌ Error submitting transaction: %s\n", err)
fmt.Printf("Error submitting transaction: %s\n", err)
return
}
if !response.Validated {
fmt.Println("❌ Cold address settings configuration failed!")
fmt.Println("Cold address settings configuration failed!")
fmt.Println("Try again!")
fmt.Println()
return
}
fmt.Println("✅ Cold address settings configured!")
fmt.Printf("🌐 Hash: %s\n", response.Hash.String())
fmt.Println("Cold address settings configured!")
fmt.Printf("Hash: %s\n", response.Hash.String())
fmt.Println()
//
// Configure hot address settings
//
fmt.Println("⏳ Configuring hot address settings...")
fmt.Println("Configuring hot address settings...")
hotWalletAccountSet := &transactions.AccountSet{
BaseTx: transactions.BaseTx{
Account: types.Address(hotWallet.ClassicAddress),
@@ -152,37 +152,37 @@ func main() {
flattenedTx = hotWalletAccountSet.Flatten()
err = client.Autofill(&flattenedTx)
if err != nil {
fmt.Printf("❌ Error autofilling transaction: %s\n", err)
fmt.Printf("Error autofilling transaction: %s\n", err)
return
}
txBlob, _, err = hotWallet.Sign(flattenedTx)
if err != nil {
fmt.Printf("❌ Error signing transaction: %s\n", err)
fmt.Printf("Error signing transaction: %s\n", err)
return
}
response, err = client.SubmitTxBlobAndWait(txBlob, false)
if err != nil {
fmt.Printf("❌ Error submitting transaction: %s\n", err)
fmt.Printf("Error submitting transaction: %s\n", err)
return
}
if !response.Validated {
fmt.Println("❌ Hot address settings configuration failed!")
fmt.Println("Hot address settings configuration failed!")
fmt.Println("Try again!")
fmt.Println()
return
}
fmt.Println("✅ Hot address settings configured!")
fmt.Printf("🌐 Hash: %s\n", response.Hash.String())
fmt.Println("Hot address settings configured!")
fmt.Printf("Hash: %s\n", response.Hash.String())
fmt.Println()
//
// Create trust line from hot to cold address
//
fmt.Println("⏳ Creating trust line from hot to cold address...")
fmt.Println("Creating trust line from hot to cold address...")
hotColdTrustSet := &transactions.TrustSet{
BaseTx: transactions.BaseTx{
Account: types.Address(hotWallet.ClassicAddress),
@@ -197,37 +197,37 @@ func main() {
flattenedTx = hotColdTrustSet.Flatten()
err = client.Autofill(&flattenedTx)
if err != nil {
fmt.Printf("❌ Error autofilling transaction: %s\n", err)
fmt.Printf("Error autofilling transaction: %s\n", err)
return
}
txBlob, _, err = hotWallet.Sign(flattenedTx)
if err != nil {
fmt.Printf("❌ Error signing transaction: %s\n", err)
fmt.Printf("Error signing transaction: %s\n", err)
return
}
response, err = client.SubmitTxBlobAndWait(txBlob, false)
if err != nil {
fmt.Printf("❌ Error submitting transaction: %s\n", err)
fmt.Printf("Error submitting transaction: %s\n", err)
return
}
if !response.Validated {
fmt.Println("❌ Trust line from hot to cold address creation failed!")
fmt.Println("Trust line from hot to cold address creation failed!")
fmt.Println("Try again!")
fmt.Println()
return
}
fmt.Println("✅ Trust line from hot to cold address created!")
fmt.Printf("🌐 Hash: %s\n", response.Hash.String())
fmt.Println("Trust line from hot to cold address created!")
fmt.Printf("Hash: %s\n", response.Hash.String())
fmt.Println()
//
// Create trust line from costumer one to cold address
//
fmt.Println("⏳ Creating trust line from customer one to cold address...")
fmt.Println("Creating trust line from customer one to cold address...")
customerOneColdTrustSet := &transactions.TrustSet{
BaseTx: transactions.BaseTx{
Account: types.Address(customerOneWallet.ClassicAddress),
@@ -242,37 +242,37 @@ func main() {
flattenedTx = customerOneColdTrustSet.Flatten()
err = client.Autofill(&flattenedTx)
if err != nil {
fmt.Printf("❌ Error autofilling transaction: %s\n", err)
fmt.Printf("Error autofilling transaction: %s\n", err)
return
}
txBlob, _, err = customerOneWallet.Sign(flattenedTx)
if err != nil {
fmt.Printf("❌ Error signing transaction: %s\n", err)
fmt.Printf("Error signing transaction: %s\n", err)
return
}
response, err = client.SubmitTxBlobAndWait(txBlob, false)
if err != nil {
fmt.Printf("❌ Error submitting transaction: %s\n", err)
fmt.Printf("Error submitting transaction: %s\n", err)
return
}
if !response.Validated {
fmt.Println("❌ Trust line from customer one to cold address creation failed!")
fmt.Println("Trust line from customer one to cold address creation failed!")
fmt.Println("Try again!")
fmt.Println()
return
}
fmt.Println("✅ Trust line from customer one to cold address created!")
fmt.Printf("🌐 Hash: %s\n", response.Hash.String())
fmt.Println("Trust line from customer one to cold address created!")
fmt.Printf("Hash: %s\n", response.Hash.String())
fmt.Println()
//
// Send tokens from cold wallet to hot wallet
//
fmt.Println("⏳ Sending tokens from cold wallet to hot wallet...")
fmt.Println("Sending tokens from cold wallet to hot wallet...")
coldToHotPayment := &transactions.Payment{
BaseTx: transactions.BaseTx{
Account: types.Address(coldWallet.ClassicAddress),
@@ -289,37 +289,37 @@ func main() {
flattenedTx = coldToHotPayment.Flatten()
err = client.Autofill(&flattenedTx)
if err != nil {
fmt.Printf("❌ Error autofilling transaction: %s\n", err)
fmt.Printf("Error autofilling transaction: %s\n", err)
return
}
txBlob, _, err = coldWallet.Sign(flattenedTx)
if err != nil {
fmt.Printf("❌ Error signing transaction: %s\n", err)
fmt.Printf("Error signing transaction: %s\n", err)
return
}
response, err = client.SubmitTxBlobAndWait(txBlob, false)
if err != nil {
fmt.Printf("❌ Error submitting transaction: %s\n", err)
fmt.Printf("Error submitting transaction: %s\n", err)
return
}
if !response.Validated {
fmt.Println("❌ Tokens not sent from cold wallet to hot wallet!")
fmt.Println("Tokens not sent from cold wallet to hot wallet!")
fmt.Println("Try again!")
fmt.Println()
return
}
fmt.Println("✅ Tokens sent from cold wallet to hot wallet!")
fmt.Printf("🌐 Hash: %s\n", response.Hash.String())
fmt.Println("Tokens sent from cold wallet to hot wallet!")
fmt.Printf("Hash: %s\n", response.Hash.String())
fmt.Println()
//
// Send tokens from hot wallet to customer one
//
fmt.Println("⏳ Sending tokens from cold wallet to customer one...")
fmt.Println("Sending tokens from cold wallet to customer one...")
coldToCustomerOnePayment := &transactions.Payment{
BaseTx: transactions.BaseTx{
Account: types.Address(coldWallet.ClassicAddress),
@@ -335,36 +335,36 @@ func main() {
flattenedTx = coldToCustomerOnePayment.Flatten()
err = client.Autofill(&flattenedTx)
if err != nil {
fmt.Printf("❌ Error autofilling transaction: %s\n", err)
fmt.Printf("Error autofilling transaction: %s\n", err)
return
}
txBlob, _, err = coldWallet.Sign(flattenedTx)
if err != nil {
fmt.Printf("❌ Error signing transaction: %s\n", err)
fmt.Printf("Error signing transaction: %s\n", err)
return
}
response, err = client.SubmitTxBlobAndWait(txBlob, false)
if err != nil {
fmt.Printf("❌ Error submitting transaction: %s\n", err)
fmt.Printf("Error submitting transaction: %s\n", err)
return
}
if !response.Validated {
fmt.Println("❌ Tokens not sent from cold wallet to customer one!")
fmt.Println("Tokens not sent from cold wallet to customer one!")
fmt.Println()
return
}
fmt.Println("✅ Tokens sent from cold wallet to customer one!")
fmt.Printf("🌐 Hash: %s\n", response.Hash.String())
fmt.Println("Tokens sent from cold wallet to customer one!")
fmt.Printf("Hash: %s\n", response.Hash.String())
fmt.Println()
//
// Freeze cold wallet
//
fmt.Println("⏳ Freezing cold wallet...")
fmt.Println("Freezing cold wallet...")
freezeColdWallet := &transactions.AccountSet{
BaseTx: transactions.BaseTx{
Account: types.Address(coldWallet.ClassicAddress),
@@ -376,37 +376,37 @@ func main() {
flattenedTx = freezeColdWallet.Flatten()
err = client.Autofill(&flattenedTx)
if err != nil {
fmt.Printf("❌ Error autofilling transaction: %s\n", err)
fmt.Printf("Error autofilling transaction: %s\n", err)
return
}
txBlob, _, err = coldWallet.Sign(flattenedTx)
if err != nil {
fmt.Printf("❌ Error signing transaction: %s\n", err)
fmt.Printf("Error signing transaction: %s\n", err)
return
}
response, err = client.SubmitTxBlobAndWait(txBlob, false)
if err != nil {
fmt.Printf("❌ Error submitting transaction: %s\n", err)
fmt.Printf("Error submitting transaction: %s\n", err)
return
}
if !response.Validated {
fmt.Println("❌ Cold wallet freezing failed!")
fmt.Printf("🌐 Hash: %s\n", response.Hash.String())
fmt.Println("Cold wallet freezing failed!")
fmt.Printf("Hash: %s\n", response.Hash.String())
fmt.Println()
return
}
fmt.Println("✅ Cold wallet frozen!")
fmt.Printf("🌐 Hash: %s\n", response.Hash.String())
fmt.Println("Cold wallet frozen!")
fmt.Printf("Hash: %s\n", response.Hash.String())
fmt.Println()
//
// Try to send tokens from hot wallet to customer one
//
fmt.Println("⏳ Trying to send tokens from hot wallet to customer one...")
fmt.Println("Trying to send tokens from hot wallet to customer one...")
hotToCustomerOnePayment := &transactions.Payment{
BaseTx: transactions.BaseTx{
Account: types.Address(hotWallet.ClassicAddress),
@@ -422,13 +422,13 @@ func main() {
flattenedTx = hotToCustomerOnePayment.Flatten()
err = client.Autofill(&flattenedTx)
if err != nil {
fmt.Printf("❌ Error autofilling transaction: %s\n", err)
fmt.Printf("Error autofilling transaction: %s\n", err)
return
}
txBlob, _, err = hotWallet.Sign(flattenedTx)
if err != nil {
fmt.Printf("❌ Error signing transaction: %s\n", err)
fmt.Printf("Error signing transaction: %s\n", err)
return
}
@@ -437,13 +437,13 @@ func main() {
return
}
fmt.Println("❌ Tokens not sent from hot wallet to customer one!")
fmt.Println("Tokens not sent from hot wallet to customer one!")
fmt.Println()
// //
// // Unfreeze cold wallet
// //
fmt.Println("⏳ Unfreezing cold wallet...")
fmt.Println("Unfreezing cold wallet...")
unfreezeColdWallet := &transactions.AccountSet{
BaseTx: transactions.BaseTx{
Account: types.Address(coldWallet.ClassicAddress),
@@ -455,37 +455,37 @@ func main() {
flattenedTx = unfreezeColdWallet.Flatten()
err = client.Autofill(&flattenedTx)
if err != nil {
fmt.Printf("❌ Error autofilling transaction: %s\n", err)
fmt.Printf("Error autofilling transaction: %s\n", err)
return
}
txBlob, _, err = coldWallet.Sign(flattenedTx)
if err != nil {
fmt.Printf("❌ Error signing transaction: %s\n", err)
fmt.Printf("Error signing transaction: %s\n", err)
return
}
response, err = client.SubmitTxBlobAndWait(txBlob, false)
if err != nil {
fmt.Printf("❌ Error submitting transaction: %s\n", err)
fmt.Printf("Error submitting transaction: %s\n", err)
return
}
if !response.Validated {
fmt.Println("❌ Cold wallet unfreezing failed!")
fmt.Printf("🌐 Hash: %s\n", response.Hash.String())
fmt.Println("Cold wallet unfreezing failed!")
fmt.Printf("Hash: %s\n", response.Hash.String())
fmt.Println()
return
}
fmt.Println("✅ Cold wallet unfrozen!")
fmt.Printf("🌐 Hash: %s\n", response.Hash.String())
fmt.Println("Cold wallet unfrozen!")
fmt.Printf("Hash: %s\n", response.Hash.String())
fmt.Println()
//
// Try to send tokens from hot wallet to customer one
//
fmt.Println("⏳ Trying to send tokens from hot wallet to customer one...")
fmt.Println("Trying to send tokens from hot wallet to customer one...")
hotToCustomerOnePayment = &transactions.Payment{
BaseTx: transactions.BaseTx{
Account: types.Address(hotWallet.ClassicAddress),
@@ -501,29 +501,29 @@ func main() {
flattenedTx = hotToCustomerOnePayment.Flatten()
err = client.Autofill(&flattenedTx)
if err != nil {
fmt.Printf("❌ Error autofilling transaction: %s\n", err)
fmt.Printf("Error autofilling transaction: %s\n", err)
return
}
txBlob, _, err = hotWallet.Sign(flattenedTx)
if err != nil {
fmt.Printf("❌ Error signing transaction: %s\n", err)
fmt.Printf("Error signing transaction: %s\n", err)
return
}
response, err = client.SubmitTxBlobAndWait(txBlob, false)
if err != nil {
fmt.Printf("❌ Error submitting transaction: %s\n", err)
fmt.Printf("Error submitting transaction: %s\n", err)
return
}
if !response.Validated {
fmt.Println("❌ Tokens not sent from hot wallet to customer one!")
fmt.Println("Tokens not sent from hot wallet to customer one!")
fmt.Println("Try again!")
return
}
fmt.Println("✅ Tokens sent from hot wallet to customer one!")
fmt.Printf("🌐 Hash: %s\n", response.Hash.String())
fmt.Println("Tokens sent from hot wallet to customer one!")
fmt.Printf("Hash: %s\n", response.Hash.String())
fmt.Println()
}

42
_code-samples/multisigning/go/rpc/main.go
View File

@@ -1,18 +1,18 @@
package main
import (
"encoding/hex"
"fmt"
"maps"
"strings"
"encoding/hex"
"fmt"
"maps"
"strings"
"github.com/Peersyst/xrpl-go/xrpl"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/ledger-entry-types"
"github.com/Peersyst/xrpl-go/xrpl/rpc"
"github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/xrpl"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/ledger-entry-types"
"github.com/Peersyst/xrpl-go/xrpl/rpc"
"github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
)
func main() {
@@ -44,28 +44,28 @@ func main() {
return
}
fmt.Println("⏳ Funding wallets...")
fmt.Println("Funding wallets...")
if err := client.FundWallet(&w1); err != nil {
fmt.Println(err)
return
}
fmt.Println("💸 Wallet 1 funded")
fmt.Println("Wallet 1 funded")
if err := client.FundWallet(&w2); err != nil {
fmt.Println(err)
return
}
fmt.Println("💸 Wallet 2 funded")
fmt.Println("Wallet 2 funded")
if err := client.FundWallet(&master); err != nil {
fmt.Println(err)
return
}
fmt.Println("💸 Master wallet funded")
fmt.Println("Master wallet funded")
fmt.Println()
fmt.Println("⏳ Setting up signer list...")
fmt.Println("Setting up signer list...")
ss := &transaction.SignerListSet{
BaseTx: transaction.BaseTx{
@@ -113,11 +113,11 @@ func main() {
return
}
fmt.Println("✅ SignerListSet transaction submitted!")
fmt.Printf("🌐 Hash: %s\n", res.Hash.String())
fmt.Println("SignerListSet transaction submitted!")
fmt.Printf("Hash: %s\n", res.Hash.String())
fmt.Println()
fmt.Println("⏳ Setting up AccountSet multisign transaction...")
fmt.Println("Setting up AccountSet multisign transaction...")
as := &transaction.AccountSet{
BaseTx: transaction.BaseTx{
@@ -161,6 +161,6 @@ func main() {
return
}
fmt.Println("✅ Multisigned transaction submitted!")
fmt.Printf("🌐 Result: %s\n", mRes.EngineResult)
fmt.Println("Multisigned transaction submitted!")
fmt.Printf("Result: %s\n", mRes.EngineResult)
}

56
_code-samples/multisigning/go/ws/main.go
View File

@@ -1,22 +1,22 @@
package main
import (
"encoding/hex"
"fmt"
"maps"
"strings"
"encoding/hex"
"fmt"
"maps"
"strings"
"github.com/Peersyst/xrpl-go/xrpl"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/ledger-entry-types"
"github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/xrpl/websocket"
"github.com/Peersyst/xrpl-go/xrpl"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/ledger-entry-types"
"github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/xrpl/websocket"
)
func main() {
fmt.Println("⏳ Connecting to testnet...")
fmt.Println("Connecting to testnet...")
client := websocket.NewClient(
websocket.NewClientConfig().
WithHost("wss://s.altnet.rippletest.net:51233").
@@ -30,11 +30,11 @@ func main() {
}
if !client.IsConnected() {
fmt.Println("❌ Failed to connect to testnet")
fmt.Println("Failed to connect to testnet")
return
}
fmt.Println("✅ Connected to testnet")
fmt.Println("Connected to testnet")
fmt.Println()
w1, err := wallet.FromSeed("sEdTtvLmJmrb7GaivhWoXRkvU4NDjVf", "")
@@ -55,28 +55,28 @@ func main() {
return
}
fmt.Println("⏳ Funding wallets...")
fmt.Println("Funding wallets...")
if err := client.FundWallet(&w1); err != nil {
fmt.Println(err)
return
}
fmt.Println("💸 Wallet 1 funded")
fmt.Println("Wallet 1 funded")
if err := client.FundWallet(&w2); err != nil {
fmt.Println(err)
return
}
fmt.Println("💸 Wallet 2 funded")
fmt.Println("Wallet 2 funded")
if err := client.FundWallet(&master); err != nil {
fmt.Println(err)
return
}
fmt.Println("💸 Master wallet funded")
fmt.Println("Master wallet funded")
fmt.Println()
fmt.Println("⏳ Setting up signer list...")
fmt.Println("Setting up signer list...")
ss := &transaction.SignerListSet{
BaseTx: transaction.BaseTx{
@@ -105,34 +105,34 @@ func main() {
},
}
fmt.Println("⏳ Flattening transaction...")
fmt.Println("Flattening transaction...")
flatSs := ss.Flatten()
fmt.Println("⏳ Autofilling transaction...")
fmt.Println("Autofilling transaction...")
if err := client.Autofill(&flatSs); err != nil {
fmt.Println(err)
return
}
fmt.Println("⏳ Signing transaction...")
fmt.Println("Signing transaction...")
blob, _, err := master.Sign(flatSs)
if err != nil {
fmt.Println(err)
return
}
fmt.Println("⏳ Submitting transaction...")
fmt.Println("Submitting transaction...")
res, err := client.SubmitTxBlobAndWait(blob, false)
if err != nil {
fmt.Println(err)
return
}
fmt.Println("✅ SignerListSet transaction submitted!")
fmt.Printf("🌐 Hash: %s\n", res.Hash.String())
fmt.Println("SignerListSet transaction submitted!")
fmt.Printf("Hash: %s\n", res.Hash.String())
fmt.Println()
fmt.Println("⏳ Setting up AccountSet multisign transaction...")
fmt.Println("Setting up AccountSet multisign transaction...")
as := &transaction.AccountSet{
BaseTx: transaction.BaseTx{
@@ -176,6 +176,6 @@ func main() {
return
}
fmt.Println("✅ Multisigned transaction submitted!")
fmt.Printf("🌐 Result: %s\n", mRes.EngineResult)
fmt.Println("Multisigned transaction submitted!")
fmt.Printf("Result: %s\n", mRes.EngineResult)
}

54
_code-samples/non-fungible-token/go/nft-accept/rpc/main.go
View File

@@ -1,15 +1,15 @@
package main
import (
"fmt"
"fmt"
"github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/rpc"
"github.com/Peersyst/xrpl-go/xrpl/rpc/types"
"github.com/Peersyst/xrpl-go/xrpl/transaction"
txnTypes "github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/rpc"
"github.com/Peersyst/xrpl-go/xrpl/rpc/types"
"github.com/Peersyst/xrpl-go/xrpl/transaction"
txnTypes "github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
)
func main() {
@@ -26,35 +26,35 @@ func main() {
client := rpc.NewClient(cfg)
// Step 1: Fund wallets
fmt.Println("⏳ Funding wallets...")
fmt.Println("Funding wallets...")
// Create and fund the NFT minter wallet
nftMinter, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Println("❌ Error creating NFT minter wallet:", err)
fmt.Println("Error creating NFT minter wallet:", err)
return
}
if err := client.FundWallet(&nftMinter); err != nil {
fmt.Println("❌ Error funding NFT minter wallet:", err)
fmt.Println("Error funding NFT minter wallet:", err)
return
}
fmt.Println("💸 NFT minter wallet funded!")
fmt.Println("NFT minter wallet funded!")
// Create and fund the NFT buyer wallet
nftBuyer, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Println("❌ Error creating NFT buyer wallet:", err)
fmt.Println("Error creating NFT buyer wallet:", err)
return
}
if err := client.FundWallet(&nftBuyer); err != nil {
fmt.Println("❌ Error funding NFT buyer wallet:", err)
fmt.Println("Error funding NFT buyer wallet:", err)
return
}
fmt.Println("💸 NFT buyer wallet funded!")
fmt.Println("NFT buyer wallet funded!")
fmt.Println()
// Step 2: Mint an NFT
fmt.Println("⏳ Minting NFT...")
fmt.Println("Minting NFT...")
nftMint := transaction.NFTokenMint{
BaseTx: transaction.BaseTx{
@@ -73,36 +73,36 @@ func main() {
Wallet: &nftMinter,
})
if err != nil {
fmt.Println("❌ Error minting NFT:", err)
fmt.Println("Error minting NFT:", err)
return
}
if !responseMint.Validated {
fmt.Println("❌ NFTokenMint txn is not in a validated ledger", responseMint)
fmt.Println("NFTokenMint txn is not in a validated ledger", responseMint)
return
}
fmt.Println("✅ NFT minted successfully! - 🌎 Hash: ", responseMint.Hash)
fmt.Println("NFT minted successfully! - Hash: ", responseMint.Hash)
fmt.Println()
// Step 3: Retrieve the NFT token offer ID
fmt.Println("⏳ Retrieving NFT offer ID...")
fmt.Println("Retrieving NFT offer ID...")
metaMap, ok := responseMint.Meta.(map[string]any)
if !ok {
fmt.Println("❌ Meta is not a map[string]any")
fmt.Println("Meta is not a map[string]any")
return
}
offerID, ok := metaMap["offer_id"].(string)
if !ok {
fmt.Println("❌ offer_id not found or not a string")
fmt.Println("offer_id not found or not a string")
return
}
fmt.Println("🌎 offer_id:", offerID)
fmt.Println("offer_id:", offerID)
fmt.Println()
// Step 4: Accept the NFT offer
fmt.Println("⏳ Accepting NFT offer...")
fmt.Println("Accepting NFT offer...")
nftAccept := transaction.NFTokenAcceptOffer{
BaseTx: transaction.BaseTx{
@@ -117,12 +117,12 @@ func main() {
Wallet: &nftBuyer,
})
if err != nil {
fmt.Println("❌ Error accepting NFT offer:", err)
fmt.Println("Error accepting NFT offer:", err)
return
}
if !response.Validated {
fmt.Println("❌ NFTokenAcceptOffer txn is not in a validated ledger", response)
fmt.Println("NFTokenAcceptOffer txn is not in a validated ledger", response)
return
}
fmt.Println("✅ NFT offer accepted successfully! - 🌎 Hash: ", response.Hash)
fmt.Println("NFT offer accepted successfully! - Hash: ", response.Hash)
}

62
_code-samples/non-fungible-token/go/nft-accept/ws/main.go
View File

@@ -1,20 +1,20 @@
package main
import (
"fmt"
"fmt"
"github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/transaction"
txnTypes "github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/xrpl/websocket"
"github.com/Peersyst/xrpl-go/xrpl/websocket/types"
"github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/transaction"
txnTypes "github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/xrpl/websocket"
"github.com/Peersyst/xrpl-go/xrpl/websocket/types"
)
func main() {
// Connect to the XRPL devnet
fmt.Println("⏳ Connecting to devnet...")
fmt.Println("Connecting to devnet...")
client := websocket.NewClient(
websocket.NewClientConfig().
WithHost("wss://s.devnet.rippletest.net:51233").
@@ -23,47 +23,47 @@ func main() {
defer client.Disconnect()
if err := client.Connect(); err != nil {
fmt.Println("❌ Error connecting to devnet:", err)
fmt.Println("Error connecting to devnet:", err)
return
}
if !client.IsConnected() {
fmt.Println("❌ Failed to connect to devnet")
fmt.Println("Failed to connect to devnet")
return
}
fmt.Println("✅ Connected to devnet")
fmt.Println("Connected to devnet")
fmt.Println()
// Fund wallets
fmt.Println("⏳ Funding wallets...")
fmt.Println("Funding wallets...")
// Create and fund the NFT minter wallet
nftMinter, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Println("❌ Error creating NFT minter wallet:", err)
fmt.Println("Error creating NFT minter wallet:", err)
return
}
if err := client.FundWallet(&nftMinter); err != nil {
fmt.Println("❌ Error funding NFT minter wallet:", err)
fmt.Println("Error funding NFT minter wallet:", err)
return
}
fmt.Println("💸 NFT minter wallet funded!")
fmt.Println("NFT minter wallet funded!")
// Create and fund the NFT buyer wallet
nftBuyer, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Println("❌ Error creating NFT buyer wallet:", err)
fmt.Println("Error creating NFT buyer wallet:", err)
return
}
if err := client.FundWallet(&nftBuyer); err != nil {
fmt.Println("❌ Error funding NFT buyer wallet:", err)
fmt.Println("Error funding NFT buyer wallet:", err)
return
}
fmt.Println("💸 NFT buyer wallet funded!")
fmt.Println("NFT buyer wallet funded!")
fmt.Println()
// Mint an NFT
fmt.Println("⏳ Minting NFT...")
fmt.Println("Minting NFT...")
nftMint := transaction.NFTokenMint{
BaseTx: transaction.BaseTx{
Account: nftMinter.ClassicAddress,
@@ -81,34 +81,34 @@ func main() {
Wallet: &nftMinter,
})
if err != nil {
fmt.Println("❌ Error minting NFT:", err)
fmt.Println("Error minting NFT:", err)
return
}
if !responseMint.Validated {
fmt.Println("❌ NFTokenMint transaction is not in a validated ledger:", responseMint)
fmt.Println("NFTokenMint transaction is not in a validated ledger:", responseMint)
return
}
fmt.Println("✅ NFT minted successfully! - 🌎 Hash:", responseMint.Hash)
fmt.Println("NFT minted successfully! - Hash:", responseMint.Hash)
fmt.Println()
// Extract the NFT token offer ID from the transaction metadata
fmt.Println("⏳ Extracting offer ID...")
fmt.Println("Extracting offer ID...")
metaMap, ok := responseMint.Meta.(map[string]any)
if !ok {
fmt.Println("❌ Meta is not a map[string]any")
fmt.Println("Meta is not a map[string]any")
return
}
offerID, ok := metaMap["offer_id"].(string)
if !ok {
fmt.Println("❌ offer_id not found or not a string")
fmt.Println("offer_id not found or not a string")
return
}
fmt.Println("🌎 offer_id:", offerID)
fmt.Println("offer_id:", offerID)
fmt.Println()
// Accept the NFT offer
fmt.Println("⏳ Accepting NFT offer...")
fmt.Println("Accepting NFT offer...")
nftAccept := transaction.NFTokenAcceptOffer{
BaseTx: transaction.BaseTx{
Account: nftBuyer.ClassicAddress,
@@ -122,12 +122,12 @@ func main() {
Wallet: &nftBuyer,
})
if err != nil {
fmt.Println("❌ Error accepting NFT offer:", err)
fmt.Println("Error accepting NFT offer:", err)
return
}
if !response.Validated {
fmt.Println("❌ NFTokenAcceptOffer transaction is not in a validated ledger:", response)
fmt.Println("NFTokenAcceptOffer transaction is not in a validated ledger:", response)
return
}
fmt.Println("✅ NFT offer accepted successfully! - 🌎 Hash:", response.Hash)
fmt.Println("NFT offer accepted successfully! - Hash:", response.Hash)
}

48
_code-samples/non-fungible-token/go/nft-burn/rpc/main.go
View File

@@ -1,15 +1,15 @@
package main
import (
"fmt"
"fmt"
"github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/rpc"
"github.com/Peersyst/xrpl-go/xrpl/rpc/types"
"github.com/Peersyst/xrpl-go/xrpl/transaction"
txnTypes "github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/rpc"
"github.com/Peersyst/xrpl-go/xrpl/rpc/types"
"github.com/Peersyst/xrpl-go/xrpl/transaction"
txnTypes "github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
)
func main() {
@@ -26,23 +26,23 @@ func main() {
client := rpc.NewClient(cfg)
// Step 1: Fund wallets
fmt.Println("⏳ Funding wallets...")
fmt.Println("Funding wallets...")
// Create and fund the NFT minter wallet
nftMinter, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Println("❌ Error creating NFT minter wallet:", err)
fmt.Println("Error creating NFT minter wallet:", err)
return
}
if err := client.FundWallet(&nftMinter); err != nil {
fmt.Println("❌ Error funding NFT minter wallet:", err)
fmt.Println("Error funding NFT minter wallet:", err)
return
}
fmt.Println("💸 NFT minter wallet funded!")
fmt.Println("NFT minter wallet funded!")
fmt.Println()
// Step 2: Mint an NFT
fmt.Println("⏳ Minting NFT...")
fmt.Println("Minting NFT...")
nftMint := transaction.NFTokenMint{
BaseTx: transaction.BaseTx{
@@ -59,36 +59,36 @@ func main() {
Wallet: &nftMinter,
})
if err != nil {
fmt.Println("❌ Error minting NFT:", err)
fmt.Println("Error minting NFT:", err)
return
}
if !responseMint.Validated {
fmt.Println("❌ NFTokenMint txn is not in a validated ledger", responseMint)
fmt.Println("NFTokenMint txn is not in a validated ledger", responseMint)
return
}
fmt.Println("✅ NFT minted successfully! - 🌎 Hash: ", responseMint.Hash)
fmt.Println("NFT minted successfully! - Hash: ", responseMint.Hash)
fmt.Println()
// Step 3: Retrieve the token ID
fmt.Println("⏳ Retrieving NFT ID...")
fmt.Println("Retrieving NFT ID...")
metaMap, ok := responseMint.Meta.(map[string]any)
if !ok {
fmt.Println("❌ Meta is not a map[string]any")
fmt.Println("Meta is not a map[string]any")
return
}
nftokenID, ok := metaMap["nftoken_id"].(string)
if !ok {
fmt.Println("❌ nftoken_id not found or not a string")
fmt.Println("nftoken_id not found or not a string")
return
}
fmt.Println("🌎 nftoken_id:", nftokenID)
fmt.Println("nftoken_id:", nftokenID)
fmt.Println()
// Step 4: Burn the NFT
fmt.Println("⏳ Burn the NFT...")
fmt.Println("Burn the NFT...")
nftBurn := transaction.NFTokenBurn{
BaseTx: transaction.BaseTx{
@@ -103,12 +103,12 @@ func main() {
Wallet: &nftMinter,
})
if err != nil {
fmt.Println("❌ Error burning NFT:", err)
fmt.Println("Error burning NFT:", err)
return
}
if !responseBurn.Validated {
fmt.Println("❌ NFTokenBurn transactiob is not in a validated ledger", responseBurn)
fmt.Println("NFTokenBurn transactiob is not in a validated ledger", responseBurn)
return
}
fmt.Println("✅ NFT burned successfully! - 🌎 Hash: ", responseBurn.Hash)
fmt.Println("NFT burned successfully! - Hash: ", responseBurn.Hash)
}

56
_code-samples/non-fungible-token/go/nft-burn/ws/main.go
View File

@@ -1,20 +1,20 @@
package main
import (
"fmt"
"fmt"
"github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/transaction"
txnTypes "github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/xrpl/websocket"
"github.com/Peersyst/xrpl-go/xrpl/websocket/types"
"github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/transaction"
txnTypes "github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/xrpl/websocket"
"github.com/Peersyst/xrpl-go/xrpl/websocket/types"
)
func main() {
// Connect to the XRPL devnet
fmt.Println("⏳ Connecting to devnet...")
fmt.Println("Connecting to devnet...")
client := websocket.NewClient(
websocket.NewClientConfig().
WithHost("wss://s.devnet.rippletest.net:51233").
@@ -23,35 +23,35 @@ func main() {
defer client.Disconnect()
if err := client.Connect(); err != nil {
fmt.Println("❌ Error connecting to devnet:", err)
fmt.Println("Error connecting to devnet:", err)
return
}
if !client.IsConnected() {
fmt.Println("❌ Failed to connect to devnet")
fmt.Println("Failed to connect to devnet")
return
}
fmt.Println("✅ Connected to devnet")
fmt.Println("Connected to devnet")
fmt.Println()
// Step 1: Fund wallets
fmt.Println("⏳ Funding wallets...")
fmt.Println("Funding wallets...")
// Create and fund the NFT minter wallet
nftMinter, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Println("❌ Error creating NFT minter wallet:", err)
fmt.Println("Error creating NFT minter wallet:", err)
return
}
if err := client.FundWallet(&nftMinter); err != nil {
fmt.Println("❌ Error funding NFT minter wallet:", err)
fmt.Println("Error funding NFT minter wallet:", err)
return
}
fmt.Println("💸 NFT minter wallet funded!")
fmt.Println("NFT minter wallet funded!")
fmt.Println()
// Step 2: Mint an NFT
fmt.Println("⏳ Minting NFT...")
fmt.Println("Minting NFT...")
nftMint := transaction.NFTokenMint{
BaseTx: transaction.BaseTx{
@@ -68,36 +68,36 @@ func main() {
Wallet: &nftMinter,
})
if err != nil {
fmt.Println("❌ Error minting NFT:", err)
fmt.Println("Error minting NFT:", err)
return
}
if !responseMint.Validated {
fmt.Println("❌ NFTokenMint txn is not in a validated ledger", responseMint)
fmt.Println("NFTokenMint txn is not in a validated ledger", responseMint)
return
}
fmt.Println("✅ NFT minted successfully! - 🌎 Hash: ", responseMint.Hash)
fmt.Println("NFT minted successfully! - Hash: ", responseMint.Hash)
fmt.Println()
// Step 3: Retrieve the token ID
fmt.Println("⏳ Retrieving NFT ID...")
fmt.Println("Retrieving NFT ID...")
metaMap, ok := responseMint.Meta.(map[string]any)
if !ok {
fmt.Println("❌ Meta is not a map[string]any")
fmt.Println("Meta is not a map[string]any")
return
}
nftokenID, ok := metaMap["nftoken_id"].(string)
if !ok {
fmt.Println("❌ nftoken_id not found or not a string")
fmt.Println("nftoken_id not found or not a string")
return
}
fmt.Println("🌎 nftoken_id:", nftokenID)
fmt.Println("nftoken_id:", nftokenID)
fmt.Println()
// Step 4: Burn the NFT
fmt.Println("⏳ Burn the NFT...")
fmt.Println("Burn the NFT...")
nftBurn := transaction.NFTokenBurn{
BaseTx: transaction.BaseTx{
@@ -112,12 +112,12 @@ func main() {
Wallet: &nftMinter,
})
if err != nil {
fmt.Println("❌ Error burning NFT:", err)
fmt.Println("Error burning NFT:", err)
return
}
if !responseBurn.Validated {
fmt.Println("❌ NFTokenBurn transactiob is not in a validated ledger", responseBurn)
fmt.Println("NFTokenBurn transactiob is not in a validated ledger", responseBurn)
return
}
fmt.Println("✅ NFT burned successfully! - 🌎 Hash: ", responseBurn.Hash)
fmt.Println("NFT burned successfully! - Hash: ", responseBurn.Hash)
}

64
_code-samples/non-fungible-token/go/nft-cancel/rpc/main.go
View File

@@ -1,15 +1,15 @@
package main
import (
"fmt"
"fmt"
"github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/rpc"
"github.com/Peersyst/xrpl-go/xrpl/rpc/types"
"github.com/Peersyst/xrpl-go/xrpl/transaction"
txnTypes "github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/rpc"
"github.com/Peersyst/xrpl-go/xrpl/rpc/types"
"github.com/Peersyst/xrpl-go/xrpl/transaction"
txnTypes "github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
)
func main() {
@@ -26,22 +26,22 @@ func main() {
client := rpc.NewClient(cfg)
// Step 1: Fund wallet
fmt.Println("⏳ Funding wallet...")
fmt.Println("Funding wallet...")
// Create and fund the NFT minter wallet
nftMinter, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Println("❌ Error creating NFT minter wallet:", err)
fmt.Println("Error creating NFT minter wallet:", err)
return
}
if err := client.FundWallet(&nftMinter); err != nil {
fmt.Println("❌ Error funding NFT minter wallet:", err)
fmt.Println("Error funding NFT minter wallet:", err)
return
}
fmt.Println("💸 NFT minter wallet funded!")
fmt.Println("NFT minter wallet funded!")
// Step 2: Mint two NFTs
fmt.Println("⏳ Minting first NFT...")
fmt.Println("Minting first NFT...")
nftMint := transaction.NFTokenMint{
BaseTx: transaction.BaseTx{
@@ -58,37 +58,37 @@ func main() {
Wallet: &nftMinter,
})
if err != nil {
fmt.Println("❌ Error minting first NFT:", err)
fmt.Println("Error minting first NFT:", err)
return
}
if !responseMint.Validated {
fmt.Println("❌ First NFTokenMint transaction is not in a validated ledger", responseMint)
fmt.Println("First NFTokenMint transaction is not in a validated ledger", responseMint)
return
}
fmt.Println("✅ First NFT minted successfully! - 🌎 Hash: ", responseMint.Hash)
fmt.Println("First NFT minted successfully! - Hash: ", responseMint.Hash)
fmt.Println()
// Step 3: Retrieve the NFT token ID
fmt.Println("⏳ Retrieving NFT ID...")
fmt.Println("Retrieving NFT ID...")
metaMap, ok := responseMint.Meta.(map[string]any)
if !ok {
fmt.Println("❌ Meta is not a map[string]any")
fmt.Println("Meta is not a map[string]any")
return
}
nftokenID1, ok := metaMap["nftoken_id"].(string)
if !ok {
fmt.Println("❌ nftoken_id not found or not a string")
fmt.Println("nftoken_id not found or not a string")
return
}
fmt.Println("🌎 nftoken_id:", nftokenID1)
fmt.Println("nftoken_id:", nftokenID1)
fmt.Println()
// ------
fmt.Println("⏳ Minting second NFT...")
fmt.Println("Minting second NFT...")
nftMint2 := transaction.NFTokenMint{
BaseTx: transaction.BaseTx{
@@ -105,36 +105,36 @@ func main() {
Wallet: &nftMinter,
})
if err != nil {
fmt.Println("❌ Error minting second NFT:", err)
fmt.Println("Error minting second NFT:", err)
return
}
if !responseMint.Validated {
fmt.Println("❌ Second NFTokenMint transaction is not in a validated ledger", responseMint)
fmt.Println("Second NFTokenMint transaction is not in a validated ledger", responseMint)
return
}
fmt.Println("✅ Second NFT minted successfully! - 🌎 Hash: ", responseMint.Hash)
fmt.Println("Second NFT minted successfully! - Hash: ", responseMint.Hash)
fmt.Println()
// Step 3: Retrieve the second NFT token ID
fmt.Println("⏳ Retrieving second NFT ID...")
fmt.Println("Retrieving second NFT ID...")
metaMap2, ok := responseMint2.Meta.(map[string]any)
if !ok {
fmt.Println("❌ Meta is not a map[string]any")
fmt.Println("Meta is not a map[string]any")
return
}
nftokenID2, ok := metaMap2["nftoken_id"].(string)
if !ok {
fmt.Println("❌ nftoken_id not found or not a string")
fmt.Println("nftoken_id not found or not a string")
return
}
fmt.Println("🌎 nftoken_id:", nftokenID2)
fmt.Println("nftoken_id:", nftokenID2)
fmt.Println()
// Step 4: Cancel the NFT offers
fmt.Println("⏳ Canceling NFT offers...")
fmt.Println("Canceling NFT offers...")
nftCancel := transaction.NFTokenCancelOffer{
BaseTx: transaction.BaseTx{
@@ -152,12 +152,12 @@ func main() {
Wallet: &nftMinter,
})
if err != nil {
fmt.Println("❌ Error canceling NFT offers:", err)
fmt.Println("Error canceling NFT offers:", err)
return
}
if !response.Validated {
fmt.Println("❌ NFTokenCancelOffer transaction is not in a validated ledger", response)
fmt.Println("NFTokenCancelOffer transaction is not in a validated ledger", response)
return
}
fmt.Println("✅ NFT offers canceled successfully! - 🌎 Hash: ", response.Hash)
fmt.Println("NFT offers canceled successfully! - Hash: ", response.Hash)
}

72
_code-samples/non-fungible-token/go/nft-cancel/ws/main.go
View File

@@ -1,20 +1,20 @@
package main
import (
"fmt"
"fmt"
"github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/transaction"
txnTypes "github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/xrpl/websocket"
"github.com/Peersyst/xrpl-go/xrpl/websocket/types"
"github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/transaction"
txnTypes "github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/xrpl/websocket"
"github.com/Peersyst/xrpl-go/xrpl/websocket/types"
)
func main() {
// Connect to the XRPL devnet
fmt.Println("⏳ Connecting to devnet...")
fmt.Println("Connecting to devnet...")
client := websocket.NewClient(
websocket.NewClientConfig().
WithHost("wss://s.devnet.rippletest.net:51233").
@@ -23,34 +23,34 @@ func main() {
defer client.Disconnect()
if err := client.Connect(); err != nil {
fmt.Println("❌ Error connecting to devnet:", err)
fmt.Println("Error connecting to devnet:", err)
return
}
if !client.IsConnected() {
fmt.Println("❌ Failed to connect to devnet")
fmt.Println("Failed to connect to devnet")
return
}
fmt.Println("✅ Connected to devnet")
fmt.Println("Connected to devnet")
fmt.Println()
// Step 1: Fund wallet
fmt.Println("⏳ Funding wallet...")
fmt.Println("Funding wallet...")
// Create and fund the NFT minter wallet
nftMinter, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Println("❌ Error creating NFT minter wallet:", err)
fmt.Println("Error creating NFT minter wallet:", err)
return
}
if err := client.FundWallet(&nftMinter); err != nil {
fmt.Println("❌ Error funding NFT minter wallet:", err)
fmt.Println("Error funding NFT minter wallet:", err)
return
}
fmt.Println("💸 NFT minter wallet funded!")
fmt.Println("NFT minter wallet funded!")
// Step 2: Mint two NFTs
fmt.Println("⏳ Minting first NFT...")
fmt.Println("Minting first NFT...")
nftMint := transaction.NFTokenMint{
BaseTx: transaction.BaseTx{
@@ -67,37 +67,37 @@ func main() {
Wallet: &nftMinter,
})
if err != nil {
fmt.Println("❌ Error minting first NFT:", err)
fmt.Println("Error minting first NFT:", err)
return
}
if !responseMint.Validated {
fmt.Println("❌ First NFTokenMint transaction is not in a validated ledger", responseMint)
fmt.Println("First NFTokenMint transaction is not in a validated ledger", responseMint)
return
}
fmt.Println("✅ First NFT minted successfully! - 🌎 Hash: ", responseMint.Hash)
fmt.Println("First NFT minted successfully! - Hash: ", responseMint.Hash)
fmt.Println()
// Step 3: Retrieve the NFT token ID
fmt.Println("⏳ Retrieving NFT ID...")
fmt.Println("Retrieving NFT ID...")
metaMap, ok := responseMint.Meta.(map[string]any)
if !ok {
fmt.Println("❌ Meta is not a map[string]any")
fmt.Println("Meta is not a map[string]any")
return
}
nftokenID1, ok := metaMap["nftoken_id"].(string)
if !ok {
fmt.Println("❌ nftoken_id not found or not a string")
fmt.Println("nftoken_id not found or not a string")
return
}
fmt.Println("🌎 nftoken_id:", nftokenID1)
fmt.Println("nftoken_id:", nftokenID1)
fmt.Println()
// ------
fmt.Println("⏳ Minting second NFT...")
fmt.Println("Minting second NFT...")
nftMint2 := transaction.NFTokenMint{
BaseTx: transaction.BaseTx{
@@ -114,36 +114,36 @@ func main() {
Wallet: &nftMinter,
})
if err != nil {
fmt.Println("❌ Error minting second NFT:", err)
fmt.Println("Error minting second NFT:", err)
return
}
if !responseMint.Validated {
fmt.Println("❌ Second NFTokenMint transaction is not in a validated ledger", responseMint)
fmt.Println("Second NFTokenMint transaction is not in a validated ledger", responseMint)
return
}
fmt.Println("✅ Second NFT minted successfully! - 🌎 Hash: ", responseMint.Hash)
fmt.Println("Second NFT minted successfully! - Hash: ", responseMint.Hash)
fmt.Println()
// Step 3: Retrieve the second NFT token ID
fmt.Println("⏳ Retrieving second NFT ID...")
fmt.Println("Retrieving second NFT ID...")
metaMap2, ok := responseMint2.Meta.(map[string]any)
if !ok {
fmt.Println("❌ Meta is not a map[string]any")
fmt.Println("Meta is not a map[string]any")
return
}
nftokenID2, ok := metaMap2["nftoken_id"].(string)
if !ok {
fmt.Println("❌ nftoken_id not found or not a string")
fmt.Println("nftoken_id not found or not a string")
return
}
fmt.Println("🌎 nftoken_id:", nftokenID2)
fmt.Println("nftoken_id:", nftokenID2)
fmt.Println()
// Step 4: Cancel the NFT offers
fmt.Println("⏳ Canceling NFT offers...")
fmt.Println("Canceling NFT offers...")
nftCancel := transaction.NFTokenCancelOffer{
BaseTx: transaction.BaseTx{
@@ -161,12 +161,12 @@ func main() {
Wallet: &nftMinter,
})
if err != nil {
fmt.Println("❌ Error canceling NFT offers:", err)
fmt.Println("Error canceling NFT offers:", err)
return
}
if !response.Validated {
fmt.Println("❌ NFTokenCancelOffer transaction is not in a validated ledger", response)
fmt.Println("NFTokenCancelOffer transaction is not in a validated ledger", response)
return
}
fmt.Println("✅ NFT offers canceled successfully! - 🌎 Hash: ", response.Hash)
fmt.Println("NFT offers canceled successfully! - Hash: ", response.Hash)
}

42
_code-samples/non-fungible-token/go/nft-modify/rpc/main.go
View File

@@ -1,15 +1,15 @@
package main
import (
"fmt"
"fmt"
"github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/rpc"
"github.com/Peersyst/xrpl-go/xrpl/rpc/types"
"github.com/Peersyst/xrpl-go/xrpl/transaction"
txnTypes "github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/rpc"
"github.com/Peersyst/xrpl-go/xrpl/rpc/types"
"github.com/Peersyst/xrpl-go/xrpl/transaction"
txnTypes "github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
)
func main() {
@@ -24,19 +24,19 @@ func main() {
client := rpc.NewClient(cfg)
fmt.Println()
fmt.Println("⏳ Funding wallet...")
fmt.Println("Funding wallet...")
// Create and fund the nft wallet
nftWallet, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Println("❌ Error creating nft wallet:", err)
fmt.Println("Error creating nft wallet:", err)
return
}
if err := client.FundWallet(&nftWallet); err != nil {
fmt.Println("❌ Error funding nft wallet:", err)
fmt.Println("Error funding nft wallet:", err)
return
}
fmt.Println("💸 NFT wallet funded! - #️⃣: ", nftWallet.ClassicAddress)
fmt.Println("NFT wallet funded: ", nftWallet.ClassicAddress)
fmt.Println()
// Mint NFT
@@ -56,29 +56,29 @@ func main() {
Wallet: &nftWallet,
})
if err != nil {
fmt.Println("❌ Error minting NFT:", err)
fmt.Println("Error minting NFT:", err)
return
}
if !responseMint.Validated {
fmt.Println("❌ NFTokenMint txn is not in a validated ledger", responseMint)
fmt.Println("NFTokenMint txn is not in a validated ledger", responseMint)
return
}
fmt.Println("✅ NFT minted successfully! - 🌎 Hash: ", responseMint.Hash)
fmt.Println("NFT minted successfully! - Hash: ", responseMint.Hash)
fmt.Println()
metaMap, ok := responseMint.Meta.(map[string]any)
if !ok {
fmt.Println("❌ Meta is not a map[string]any")
fmt.Println("Meta is not a map[string]any")
return
}
nftokenID, ok := metaMap["nftoken_id"].(string)
if !ok {
fmt.Println("❌ nftoken_id not found or not a string")
fmt.Println("nftoken_id not found or not a string")
return
}
fmt.Println("🌎 nftoken_id:", nftokenID)
fmt.Println("nftoken_id:", nftokenID)
fmt.Println()
// Update NFT
@@ -96,12 +96,12 @@ func main() {
Wallet: &nftWallet,
})
if err != nil {
fmt.Println("❌ Error modifying NFT:", err)
fmt.Println("Error modifying NFT:", err)
return
}
if !responseModify.Validated {
fmt.Println("❌ NFTokenModify txn is not in a validated ledger", responseModify)
fmt.Println("NFTokenModify txn is not in a validated ledger", responseModify)
return
}
fmt.Println("✅ NFT URI modified successfully! - 🌎 Hash: ", responseModify.Hash)
fmt.Println("NFT URI modified successfully! - Hash: ", responseModify.Hash)
}

48
_code-samples/non-fungible-token/go/nft-modify/ws/main.go
View File

@@ -1,19 +1,19 @@
package main
import (
"fmt"
"fmt"
"github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/transaction"
txnTypes "github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/xrpl/websocket"
"github.com/Peersyst/xrpl-go/xrpl/websocket/types"
"github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/transaction"
txnTypes "github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/xrpl/websocket"
"github.com/Peersyst/xrpl-go/xrpl/websocket/types"
)
func main() {
fmt.Println("⏳ Connecting to devnet...")
fmt.Println("Connecting to devnet...")
client := websocket.NewClient(
websocket.NewClientConfig().
WithHost("wss://s.devnet.rippletest.net:51233").
@@ -28,25 +28,25 @@ func main() {
}
if !client.IsConnected() {
fmt.Println("❌ Failed to connect to devnet")
fmt.Println("Failed to connect to devnet")
return
}
fmt.Println("✅ Connected to devnet")
fmt.Println("Connected to devnet")
fmt.Println()
// Create and fund the nft wallet
fmt.Println("⏳ Funding wallet...")
fmt.Println("Funding wallet...")
nftWallet, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Println("❌ Error creating nft wallet:", err)
fmt.Println("Error creating nft wallet:", err)
return
}
if err := client.FundWallet(&nftWallet); err != nil {
fmt.Println("❌ Error funding nft wallet:", err)
fmt.Println("Error funding nft wallet:", err)
return
}
fmt.Println("💸 NFT wallet funded!")
fmt.Println("NFT wallet funded!")
fmt.Println()
// Mint NFT
@@ -66,29 +66,29 @@ func main() {
Wallet: &nftWallet,
})
if err != nil {
fmt.Println("❌ Error minting NFT:", err)
fmt.Println("Error minting NFT:", err)
return
}
if !responseMint.Validated {
fmt.Println("❌ NFTokenMint txn is not in a validated ledger", responseMint)
fmt.Println("NFTokenMint txn is not in a validated ledger", responseMint)
return
}
fmt.Println("✅ NFT minted successfully! - 🌎 Hash: ", responseMint.Hash)
fmt.Println("NFT minted successfully! - Hash: ", responseMint.Hash)
fmt.Println()
metaMap, ok := responseMint.Meta.(map[string]any)
if !ok {
fmt.Println("❌ Meta is not a map[string]any")
fmt.Println("Meta is not a map[string]any")
return
}
nftokenID, ok := metaMap["nftoken_id"].(string)
if !ok {
fmt.Println("❌ nftoken_id not found or not a string")
fmt.Println("nftoken_id not found or not a string")
return
}
fmt.Println("🌎 nftoken_id:", nftokenID)
fmt.Println("nftoken_id:", nftokenID)
fmt.Println()
// Update NFT
@@ -106,12 +106,12 @@ func main() {
Wallet: &nftWallet,
})
if err != nil {
fmt.Println("❌ Error modifying NFT:", err)
fmt.Println("Error modifying NFT:", err)
return
}
if !responseModify.Validated {
fmt.Println("❌ NFTokenModify txn is not in a validated ledger", responseModify)
fmt.Println("NFTokenModify txn is not in a validated ledger", responseModify)
return
}
fmt.Println("✅ NFT URI modified successfully! - 🌎 Hash: ", responseModify.Hash)
fmt.Println("NFT URI modified successfully! - Hash: ", responseModify.Hash)
}

46
_code-samples/partial-payment/go/rpc/main.go
View File

@@ -1,15 +1,15 @@
package main
import (
"fmt"
"time"
"fmt"
"time"
"github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/rpc"
"github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/rpc"
"github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
)
func main() {
@@ -23,7 +23,7 @@ func main() {
client := rpc.NewClient(cfg)
fmt.Println("⏳ Funding wallets...")
fmt.Println("Funding wallets...")
w1, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Println(err)
@@ -40,18 +40,18 @@ func main() {
return
}
fmt.Println("💸 Wallet 1 funded")
fmt.Println("Wallet 1 funded")
if err := client.FundWallet(&w2); err != nil {
fmt.Println(err)
return
}
fmt.Println("💸 Wallet 2 funded")
fmt.Println("Wallet 2 funded")
fmt.Println()
time.Sleep(5 * time.Second)
fmt.Println("⏳ Sending TrustSet transaction...")
fmt.Println("Sending TrustSet transaction...")
ts := &transaction.TrustSet{
BaseTx: transaction.BaseTx{
Account: w2.ClassicAddress,
@@ -83,12 +83,12 @@ func main() {
return
}
fmt.Println("✅ TrustSet transaction submitted!")
fmt.Printf("🌐 Hash: %s\n", res.Hash.String())
fmt.Printf("🌐 Validated: %t\n", res.Validated)
fmt.Println("TrustSet transaction submitted!")
fmt.Printf("Hash: %s\n", res.Hash.String())
fmt.Printf("Validated: %t\n", res.Validated)
fmt.Println()
fmt.Println("⏳ Issuing tokens for wallet 2...")
fmt.Println("Issuing tokens for wallet 2...")
p := &transaction.Payment{
BaseTx: transaction.BaseTx{
Account: w1.GetAddress(),
@@ -121,12 +121,12 @@ func main() {
return
}
fmt.Println("✅ Payment transaction submitted!")
fmt.Printf("🌐 Hash: %s\n", res.Hash.String())
fmt.Printf("🌐 Validated: %t\n", res.Validated)
fmt.Println("Payment transaction submitted!")
fmt.Printf("Hash: %s\n", res.Hash.String())
fmt.Printf("Validated: %t\n", res.Validated)
fmt.Println()
fmt.Println("⏳ Submitting Partial Payment transaction...")
fmt.Println("Submitting Partial Payment transaction...")
pp := &transaction.Payment{
BaseTx: transaction.BaseTx{
Account: w2.GetAddress(),
@@ -161,8 +161,8 @@ func main() {
return
}
fmt.Println("✅ Partial Payment transaction submitted!")
fmt.Printf("🌐 Hash: %s\n", res.Hash.String())
fmt.Printf("🌐 Validated: %t\n", res.Validated)
fmt.Println("Partial Payment transaction submitted!")
fmt.Printf("Hash: %s\n", res.Hash.String())
fmt.Printf("Validated: %t\n", res.Validated)
fmt.Println()
}

52
_code-samples/partial-payment/go/ws/main.go
View File

@@ -1,19 +1,19 @@
package main
import (
"fmt"
"time"
"fmt"
"time"
"github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/xrpl/websocket"
"github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/xrpl/websocket"
)
func main() {
fmt.Println("⏳ Connecting to testnet...")
fmt.Println("Connecting to testnet...")
client := websocket.NewClient(
websocket.NewClientConfig().
WithHost("wss://s.altnet.rippletest.net:51233").
@@ -27,14 +27,14 @@ func main() {
}
if !client.IsConnected() {
fmt.Println("❌ Failed to connect to testnet")
fmt.Println("Failed to connect to testnet")
return
}
fmt.Println("✅ Connected to testnet")
fmt.Println("Connected to testnet")
fmt.Println()
fmt.Println("⏳ Funding wallets...")
fmt.Println("Funding wallets...")
w1, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Println(err)
@@ -51,18 +51,18 @@ func main() {
return
}
fmt.Println("💸 Wallet 1 funded")
fmt.Println("Wallet 1 funded")
if err := client.FundWallet(&w2); err != nil {
fmt.Println(err)
return
}
fmt.Println("💸 Wallet 2 funded")
fmt.Println("Wallet 2 funded")
fmt.Println()
time.Sleep(5 * time.Second)
fmt.Println("⏳ Sending TrustSet transaction...")
fmt.Println("Sending TrustSet transaction...")
ts := &transaction.TrustSet{
BaseTx: transaction.BaseTx{
Account: w2.ClassicAddress,
@@ -94,12 +94,12 @@ func main() {
return
}
fmt.Println("✅ TrustSet transaction submitted!")
fmt.Printf("🌐 Hash: %s\n", res.Hash.String())
fmt.Printf("🌐 Validated: %t\n", res.Validated)
fmt.Println("TrustSet transaction submitted!")
fmt.Printf("Hash: %s\n", res.Hash.String())
fmt.Printf("Validated: %t\n", res.Validated)
fmt.Println()
fmt.Println("⏳ Issuing tokens for wallet 2...")
fmt.Println("Issuing tokens for wallet 2...")
p := &transaction.Payment{
BaseTx: transaction.BaseTx{
Account: w1.GetAddress(),
@@ -132,12 +132,12 @@ func main() {
return
}
fmt.Println("✅ Payment transaction submitted!")
fmt.Printf("🌐 Hash: %s\n", res.Hash.String())
fmt.Printf("🌐 Validated: %t\n", res.Validated)
fmt.Println("Payment transaction submitted!")
fmt.Printf("Hash: %s\n", res.Hash.String())
fmt.Printf("Validated: %t\n", res.Validated)
fmt.Println()
fmt.Println("⏳ Submitting Partial Payment transaction...")
fmt.Println("Submitting Partial Payment transaction...")
pp := &transaction.Payment{
BaseTx: transaction.BaseTx{
Account: w2.GetAddress(),
@@ -172,8 +172,8 @@ func main() {
return
}
fmt.Println("✅ Partial Payment transaction submitted!")
fmt.Printf("🌐 Hash: %s\n", res.Hash.String())
fmt.Printf("🌐 Validated: %t\n", res.Validated)
fmt.Println("Partial Payment transaction submitted!")
fmt.Printf("Hash: %s\n", res.Hash.String())
fmt.Printf("Validated: %t\n", res.Validated)
fmt.Println()
}

36
_code-samples/paths/go/rpc/main.go
View File

@@ -1,17 +1,17 @@
package main
import (
"fmt"
"fmt"
"github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/queries/path"
"github.com/Peersyst/xrpl-go/xrpl/rpc"
"github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/queries/path"
"github.com/Peersyst/xrpl-go/xrpl/rpc"
"github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
pathtypes "github.com/Peersyst/xrpl-go/xrpl/queries/path/types"
pathtypes "github.com/Peersyst/xrpl-go/xrpl/queries/path/types"
)
const (
@@ -43,16 +43,16 @@ func main() {
return
}
fmt.Println("⏳ Funding wallet...")
fmt.Println("Funding wallet...")
if err := client.FundWallet(&wallet); err != nil {
fmt.Println(err)
return
}
fmt.Println("💸 Wallet funded")
fmt.Println("Wallet funded")
fmt.Println()
fmt.Println("⏳ Getting paths...")
fmt.Println("Getting paths...")
res, err := client.GetRipplePathFind(&path.RipplePathFindRequest{
SourceAccount: wallet.GetAddress(),
SourceCurrencies: []pathtypes.RipplePathFindCurrency{
@@ -68,15 +68,15 @@ func main() {
return
}
fmt.Printf("🌐 Computed paths: %d\n", len(res.Alternatives))
fmt.Printf("Computed paths: %d\n", len(res.Alternatives))
fmt.Println()
if len(res.Alternatives) == 0 {
fmt.Println("❌ No alternatives found")
fmt.Println("No alternatives found")
return
}
fmt.Println("⏳ Submitting Payment through path: ", res.Alternatives[0].PathsComputed)
fmt.Println("Submitting Payment through path: ", res.Alternatives[0].PathsComputed)
p := &transaction.Payment{
BaseTx: transaction.BaseTx{
Account: wallet.GetAddress(),
@@ -105,7 +105,7 @@ func main() {
return
}
fmt.Println("✅ Payment submitted")
fmt.Printf("🌐 Hash: %s\n", hash)
fmt.Printf("🌐 Validated: %t\n", txRes.Validated)
fmt.Println("Payment submitted")
fmt.Printf("Hash: %s\n", hash)
fmt.Printf("Validated: %t\n", txRes.Validated)
}

42
_code-samples/paths/go/ws/main.go
View File

@@ -1,17 +1,17 @@
package main
import (
"fmt"
"fmt"
"github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/queries/path"
"github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/xrpl/websocket"
"github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/queries/path"
"github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/xrpl/websocket"
pathtypes "github.com/Peersyst/xrpl-go/xrpl/queries/path/types"
pathtypes "github.com/Peersyst/xrpl-go/xrpl/queries/path/types"
)
const (
@@ -27,7 +27,7 @@ var (
)
func main() {
fmt.Println("⏳ Connecting to testnet...")
fmt.Println("Connecting to testnet...")
client := websocket.NewClient(
websocket.NewClientConfig().
WithHost("wss://s.altnet.rippletest.net:51233").
@@ -41,11 +41,11 @@ func main() {
}
if !client.IsConnected() {
fmt.Println("❌ Failed to connect to testnet")
fmt.Println("Failed to connect to testnet")
return
}
fmt.Println("✅ Connected to testnet")
fmt.Println("Connected to testnet")
fmt.Println()
wallet, err := wallet.New(crypto.ED25519())
@@ -54,16 +54,16 @@ func main() {
return
}
fmt.Println("⏳ Funding wallet...")
fmt.Println("Funding wallet...")
if err := client.FundWallet(&wallet); err != nil {
fmt.Println(err)
return
}
fmt.Println("💸 Wallet funded")
fmt.Println("Wallet funded")
fmt.Println()
fmt.Println("⏳ Getting paths...")
fmt.Println("Getting paths...")
res, err := client.GetRipplePathFind(&path.RipplePathFindRequest{
SourceAccount: wallet.GetAddress(),
SourceCurrencies: []pathtypes.RipplePathFindCurrency{
@@ -79,15 +79,15 @@ func main() {
return
}
fmt.Printf("🌐 Computed paths: %d\n", len(res.Alternatives))
fmt.Printf("Computed paths: %d\n", len(res.Alternatives))
fmt.Println()
if len(res.Alternatives) == 0 {
fmt.Println("❌ No alternatives found")
fmt.Println("No alternatives found")
return
}
fmt.Println("⏳ Submitting Payment through path: ", res.Alternatives[0].PathsComputed)
fmt.Println("Submitting Payment through path: ", res.Alternatives[0].PathsComputed)
p := &transaction.Payment{
BaseTx: transaction.BaseTx{
Account: wallet.GetAddress(),
@@ -116,7 +116,7 @@ func main() {
return
}
fmt.Println("✅ Payment submitted")
fmt.Printf("🌐 Hash: %s\n", hash)
fmt.Printf("🌐 Validated: %t\n", txRes.Validated)
fmt.Println("Payment submitted")
fmt.Printf("Hash: %s\n", hash)
fmt.Printf("Validated: %t\n", txRes.Validated)
}

32
_code-samples/send-a-memo/go/rpc/main.go
View File

@@ -1,16 +1,16 @@
package main
import (
"encoding/hex"
"fmt"
"strconv"
"encoding/hex"
"fmt"
"strconv"
"github.com/Peersyst/xrpl-go/xrpl/currency"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/rpc"
transactions "github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/xrpl/currency"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/rpc"
transactions "github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
)
func main() {
@@ -39,18 +39,18 @@ func main() {
balance, err := client.GetXrpBalance(w.GetAddress())
if err != nil || balance == "0" {
fmt.Println("⏳ Funding wallet...")
fmt.Println("Funding wallet...")
err = client.FundWallet(&w)
if err != nil {
fmt.Println(err)
return
}
fmt.Println("💸 Wallet funded")
fmt.Println("Wallet funded")
}
balance, _ = client.GetXrpBalance(w.GetAddress())
fmt.Printf("💸 Balance: %s\n", balance)
fmt.Printf("Balance: %s\n", balance)
amount, err := currency.XrpToDrops("1")
if err != nil {
@@ -64,7 +64,7 @@ func main() {
return
}
fmt.Println("⏳ Sending payment...")
fmt.Println("Sending payment...")
payment := transactions.Payment{
BaseTx: transactions.BaseTx{
Account: types.Address(w.GetAddress()),
@@ -109,7 +109,7 @@ func main() {
return
}
fmt.Println("✅ Payment submitted")
fmt.Printf("🌐 Hash: %s\n", response.Hash.String())
fmt.Printf("🌐 Validated: %t\n", response.Validated)
fmt.Println("Payment submitted")
fmt.Printf("Hash: %s\n", response.Hash.String())
fmt.Printf("Validated: %t\n", response.Validated)
}

36
_code-samples/send-a-memo/go/ws/main.go
View File

@@ -1,16 +1,16 @@
package main
import (
"encoding/hex"
"fmt"
"strconv"
"encoding/hex"
"fmt"
"strconv"
"github.com/Peersyst/xrpl-go/xrpl/currency"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
transactions "github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/xrpl/websocket"
"github.com/Peersyst/xrpl-go/xrpl/currency"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
transactions "github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/xrpl/websocket"
)
func main() {
@@ -33,30 +33,30 @@ func main() {
)
defer client.Disconnect()
fmt.Println("⏳ Connecting to server...")
fmt.Println("Connecting to server...")
if err := client.Connect(); err != nil {
fmt.Println(err)
return
}
fmt.Println("✅ Connected to server")
fmt.Println("Connected to server")
fmt.Println()
balance, err := client.GetXrpBalance(w.GetAddress())
if err != nil || balance == "0" {
fmt.Println("⏳ Funding wallet...")
fmt.Println("Funding wallet...")
err = client.FundWallet(&w)
if err != nil {
fmt.Println(err)
return
}
fmt.Println("💸 Wallet funded")
fmt.Println("Wallet funded")
}
balance, _ = client.GetXrpBalance(w.GetAddress())
fmt.Printf("💸 Balance: %s\n", balance)
fmt.Printf("Balance: %s\n", balance)
amount, err := currency.XrpToDrops("1")
if err != nil {
@@ -70,7 +70,7 @@ func main() {
return
}
fmt.Println("⏳ Sending payment...")
fmt.Println("Sending payment...")
payment := transactions.Payment{
BaseTx: transactions.BaseTx{
Account: types.Address(w.GetAddress()),
@@ -115,7 +115,7 @@ func main() {
return
}
fmt.Println("✅ Payment submitted")
fmt.Printf("🌐 Hash: %s\n", response.Hash.String())
fmt.Printf("🌐 Validated: %t\n", response.Validated)
fmt.Println("Payment submitted")
fmt.Printf("Hash: %s\n", response.Hash.String())
fmt.Printf("Validated: %t\n", response.Validated)
}

38
_code-samples/send-xrp/go/rpc/main.go
View File

@@ -1,17 +1,17 @@
package main
import (
"fmt"
"strconv"
"fmt"
"strconv"
"github.com/Peersyst/xrpl-go/xrpl/currency"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/rpc"
"github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/xrpl/currency"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/rpc"
"github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
rpctypes "github.com/Peersyst/xrpl-go/xrpl/rpc/types"
rpctypes "github.com/Peersyst/xrpl-go/xrpl/rpc/types"
)
const (
@@ -38,13 +38,13 @@ func main() {
return
}
fmt.Println("⏳ Funding wallet...")
fmt.Println("Funding wallet...")
if err := client.FundWallet(&w); err != nil {
fmt.Println(err)
return
}
fmt.Println("💸 Wallet funded")
fmt.Println("Wallet funded")
fmt.Println()
xrpAmount, err := currency.XrpToDrops("1")
@@ -59,7 +59,7 @@ func main() {
return
}
fmt.Println("⏳ Sending 1 XRP to rPT1Sjq2YGrBMTttX4GZHjKu9dyfzbpAYe...")
fmt.Println("Sending 1 XRP to rPT1Sjq2YGrBMTttX4GZHjKu9dyfzbpAYe...")
p := &transaction.Payment{
BaseTx: transaction.BaseTx{
Account: types.Address(w.GetAddress()),
@@ -88,11 +88,11 @@ func main() {
return
}
fmt.Println("✅ Payment submitted")
fmt.Printf("🌐 Hash: %s\n", res.Hash)
fmt.Printf("🌐 Validated: %t\n", res.Validated)
fmt.Println("Payment submitted")
fmt.Printf("Hash: %s\n", res.Hash)
fmt.Printf("Validated: %t\n", res.Validated)
fmt.Println()
fmt.Println("⏳ Using SubmitTxAndWait with wallet")
fmt.Println("Using SubmitTxAndWait with wallet")
fmt.Println()
flattenedTx2 := p.Flatten()
@@ -105,7 +105,7 @@ func main() {
return
}
fmt.Println("✅ Payment submitted via SubmitTxAndWait")
fmt.Printf("🌐 Hash: %s\n", resp.Hash)
fmt.Printf("🌐 Validated: %t\n", resp.Validated)
fmt.Println("Payment submitted via SubmitTxAndWait")
fmt.Printf("Hash: %s\n", resp.Hash)
fmt.Printf("Validated: %t\n", resp.Validated)
}

34
_code-samples/send-xrp/go/ws/main.go
View File

@@ -1,17 +1,17 @@
package main
import (
"fmt"
"strconv"
"fmt"
"strconv"
"github.com/Peersyst/xrpl-go/xrpl/currency"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/queries/transactions"
"github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/xrpl/websocket"
wstypes "github.com/Peersyst/xrpl-go/xrpl/websocket/types"
"github.com/Peersyst/xrpl-go/xrpl/currency"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/queries/transactions"
"github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/xrpl/websocket"
wstypes "github.com/Peersyst/xrpl-go/xrpl/websocket/types"
)
func main() {
@@ -28,11 +28,11 @@ if err := client.Connect(); err != nil {
}
if !client.IsConnected() {
fmt.Println("❌ Failed to connect to testnet")
fmt.Println("Failed to connect to testnet")
return
}
fmt.Println("✅ Connected to testnet")
fmt.Println("Connected to testnet")
fmt.Println()
// Example credentials
@@ -44,13 +44,13 @@ if err != nil {
}
// Funding the wallet
fmt.Println("⏳ Funding wallet...")
fmt.Println("Funding wallet...")
if err := client.FundWallet(&w); err != nil {
fmt.Println(err)
return
}
fmt.Println("💸 Wallet funded")
fmt.Println("Wallet funded")
fmt.Println()
xrpAmount, err := currency.XrpToDrops("1")
@@ -110,10 +110,10 @@ if err != nil {
// SubmitTxBlobAndWait() handles this automatically, but it can take 4-7s.
// Check transaction results -------------------------------------------------
fmt.Printf("🌐 Hash: %s\n", res_blob.Hash)
fmt.Printf("🌐 Meta: %t\n", res_blob.Meta)
fmt.Printf("Hash: %s\n", res_blob.Hash)
fmt.Printf("Meta: %t\n", res_blob.Meta)
res, _ := client.Request(&transactions.TxRequest{
Transaction: res_flat.Hash.String(),
})
fmt.Printf("🌐 Result: %s\n", res.Result)
fmt.Printf("Result: %s\n", res.Result)
}

38
_code-samples/set-regular-key/go/rpc/main.go
View File

@@ -1,14 +1,14 @@
package main
import (
"fmt"
"fmt"
"github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/rpc"
"github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/rpc"
"github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
)
func main() {
@@ -40,30 +40,30 @@ func main() {
return
}
fmt.Println("⏳ Funding wallets...")
fmt.Println("Funding wallets...")
if err := client.FundWallet(&w1); err != nil {
fmt.Println(err)
return
}
fmt.Println("💸 Wallet 1 funded")
fmt.Println("Wallet 1 funded")
if err := client.FundWallet(&w2); err != nil {
fmt.Println(err)
return
}
fmt.Println("💸 Wallet 2 funded")
fmt.Println("Wallet 2 funded")
if err := client.FundWallet(&regularKeyWallet); err != nil {
fmt.Println(err)
return
}
fmt.Println("💸 Regular key wallet funded")
fmt.Println("Regular key wallet funded")
fmt.Println()
fmt.Println("⏳ Setting regular key...")
fmt.Println("Setting regular key...")
rk := &transaction.SetRegularKey{
BaseTx: transaction.BaseTx{
Account: w1.GetAddress(),
@@ -91,12 +91,12 @@ func main() {
return
}
fmt.Println("✅ SetRegularKey transaction submitted")
fmt.Printf("🌐 Hash: %s\n", res.Hash)
fmt.Printf("🌐 Validated: %t\n", res.Validated)
fmt.Println("SetRegularKey transaction submitted")
fmt.Printf("Hash: %s\n", res.Hash)
fmt.Printf("Validated: %t\n", res.Validated)
fmt.Println()
fmt.Println("⏳ Checking if regular key is set...")
fmt.Println("Checking if regular key is set...")
p := &transaction.Payment{
BaseTx: transaction.BaseTx{
Account: w1.GetAddress(),
@@ -125,7 +125,7 @@ func main() {
return
}
fmt.Println("✅ Payment transaction submitted")
fmt.Printf("🌐 Hash: %s\n", res.Hash)
fmt.Printf("🌐 Validated: %t\n", res.Validated)
fmt.Println("Payment transaction submitted")
fmt.Printf("Hash: %s\n", res.Hash)
fmt.Printf("Validated: %t\n", res.Validated)
}

44
_code-samples/set-regular-key/go/ws/main.go
View File

@@ -1,18 +1,18 @@
package main
import (
"fmt"
"fmt"
"github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/xrpl/websocket"
"github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/xrpl/websocket"
)
func main() {
fmt.Println("⏳ Connecting to testnet...")
fmt.Println("Connecting to testnet...")
client := websocket.NewClient(
websocket.NewClientConfig().
WithHost("wss://s.altnet.rippletest.net:51233").
@@ -26,11 +26,11 @@ func main() {
}
if !client.IsConnected() {
fmt.Println("❌ Failed to connect to testnet")
fmt.Println("Failed to connect to testnet")
return
}
fmt.Println("✅ Connected to testnet")
fmt.Println("Connected to testnet")
fmt.Println()
w1, err := wallet.New(crypto.ED25519())
@@ -51,30 +51,30 @@ func main() {
return
}
fmt.Println("⏳ Funding wallets...")
fmt.Println("Funding wallets...")
if err := client.FundWallet(&w1); err != nil {
fmt.Println(err)
return
}
fmt.Println("💸 Wallet 1 funded")
fmt.Println("Wallet 1 funded")
if err := client.FundWallet(&w2); err != nil {
fmt.Println(err)
return
}
fmt.Println("💸 Wallet 2 funded")
fmt.Println("Wallet 2 funded")
if err := client.FundWallet(&regularKeyWallet); err != nil {
fmt.Println(err)
return
}
fmt.Println("💸 Regular key wallet funded")
fmt.Println("Regular key wallet funded")
fmt.Println()
fmt.Println("⏳ Setting regular key...")
fmt.Println("Setting regular key...")
rk := &transaction.SetRegularKey{
BaseTx: transaction.BaseTx{
Account: w1.GetAddress(),
@@ -102,12 +102,12 @@ func main() {
return
}
fmt.Println("✅ SetRegularKey transaction submitted")
fmt.Printf("🌐 Hash: %s\n", res.Hash)
fmt.Printf("🌐 Validated: %t\n", res.Validated)
fmt.Println("SetRegularKey transaction submitted")
fmt.Printf("Hash: %s\n", res.Hash)
fmt.Printf("Validated: %t\n", res.Validated)
fmt.Println()
fmt.Println("⏳ Checking if regular key is set...")
fmt.Println("Checking if regular key is set...")
p := &transaction.Payment{
BaseTx: transaction.BaseTx{
Account: w1.GetAddress(),
@@ -136,7 +136,7 @@ func main() {
return
}
fmt.Println("✅ Payment transaction submitted")
fmt.Printf("🌐 Hash: %s\n", res.Hash)
fmt.Printf("🌐 Validated: %t\n", res.Validated)
fmt.Println("Payment transaction submitted")
fmt.Printf("Hash: %s\n", res.Hash)
fmt.Printf("Validated: %t\n", res.Validated)
}

40
_code-samples/use-tickets/go/main.go
View File

@@ -1,15 +1,15 @@
package main
import (
"encoding/json"
"fmt"
"encoding/json"
"fmt"
"github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/queries/account"
"github.com/Peersyst/xrpl-go/xrpl/rpc"
"github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/queries/account"
"github.com/Peersyst/xrpl-go/xrpl/rpc"
"github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/wallet"
)
func main() {
@@ -29,13 +29,13 @@ func main() {
return
}
fmt.Println("⏳ Funding wallet...")
fmt.Println("Funding wallet...")
if err := client.FundWallet(&w); err != nil {
fmt.Println(err)
return
}
fmt.Println("💸 Wallet funded")
fmt.Println("Wallet funded")
fmt.Println()
info, err := client.GetAccountInfo(&account.InfoRequest{
@@ -46,10 +46,10 @@ func main() {
return
}
fmt.Println("🌐 Current wallet sequence:", info.AccountData.Sequence)
fmt.Println("Current wallet sequence:", info.AccountData.Sequence)
fmt.Println()
fmt.Println("⏳ Submitting TicketCreate transaction...")
fmt.Println("Submitting TicketCreate transaction...")
tc := &transaction.TicketCreate{
BaseTx: transaction.BaseTx{
Account: w.GetAddress(),
@@ -77,9 +77,9 @@ func main() {
return
}
fmt.Println("✅ TicketCreate transaction submitted")
fmt.Printf("🌐 Hash: %s\n", res.Hash)
fmt.Printf("🌐 Validated: %t\n", res.Validated)
fmt.Println("TicketCreate transaction submitted")
fmt.Printf("Hash: %s\n", res.Hash)
fmt.Printf("Validated: %t\n", res.Validated)
fmt.Println()
objects, err := client.GetAccountObjects(&account.ObjectsRequest{
@@ -90,7 +90,7 @@ func main() {
return
}
fmt.Println("🌐 Account objects:", objects.AccountObjects[0]["TicketSequence"])
fmt.Println("Account objects:", objects.AccountObjects[0]["TicketSequence"])
seq, err := objects.AccountObjects[0]["TicketSequence"].(json.Number).Int64()
if err != nil {
@@ -98,7 +98,7 @@ func main() {
return
}
fmt.Println("⏳ Submitting AccountSet transaction...")
fmt.Println("Submitting AccountSet transaction...")
as := &transaction.AccountSet{
BaseTx: transaction.BaseTx{
Account: w.GetAddress(),
@@ -128,7 +128,7 @@ func main() {
return
}
fmt.Println("✅ AccountSet transaction submitted")
fmt.Printf("🌐 Hash: %s\n", res.Hash)
fmt.Printf("🌐 Validated: %t\n", res.Validated)
fmt.Println("AccountSet transaction submitted")
fmt.Printf("Hash: %s\n", res.Hash)
fmt.Printf("Validated: %t\n", res.Validated)
}