From e1153eb00897add1272e3bddb1a81aaa74edc640 Mon Sep 17 00:00:00 2001 From: banasa44 Date: Wed, 23 Jul 2025 10:51:03 +0200 Subject: [PATCH] chore(samples): replace tab for 4 spaces --- _code-samples/batch/go/rpc/main.go | 350 +++--- _code-samples/batch/go/ws/main.go | 354 +++--- _code-samples/checks/go/rpc/main.go | 252 ++-- _code-samples/checks/go/ws/main.go | 270 ++--- _code-samples/clawback/go/rpc/main.go | 416 +++---- _code-samples/clawback/go/ws/main.go | 428 +++---- _code-samples/credential/go/rpc/main.go | 162 +-- _code-samples/credential/go/ws/main.go | 180 +-- _code-samples/delegate-set/go/rpc/main.go | 220 ++-- _code-samples/delegate-set/go/ws/main.go | 250 ++-- _code-samples/deposit-preauth/go/rpc/main.go | 342 +++--- _code-samples/deposit-preauth/go/ws/main.go | 362 +++--- _code-samples/freeze/go/rpc/main.go | 562 ++++----- _code-samples/freeze/go/ws/main.go | 576 ++++----- _code-samples/get-started/go/base/rpc/main.go | 30 +- _code-samples/get-started/go/base/ws/main.go | 26 +- .../get-started/go/get-acc-info/rpc/main.go | 94 +- .../get-started/go/get-acc-info/ws/main.go | 114 +- _code-samples/get-tx/go/main.go | 68 +- _code-samples/issue-a-token/go/rpc/main.go | 1024 ++++++++-------- _code-samples/issue-a-token/go/ws/main.go | 1036 ++++++++--------- .../go/monitor-incoming-payments.go | 132 +-- _code-samples/multisigning/go/rpc/main.go | 264 ++--- _code-samples/multisigning/go/ws/main.go | 290 ++--- .../go/nft-accept/rpc/main.go | 212 ++-- .../go/nft-accept/ws/main.go | 228 ++-- .../go/nft-burn/rpc/main.go | 186 +-- .../non-fungible-token/go/nft-burn/ws/main.go | 202 ++-- .../go/nft-cancel/rpc/main.go | 268 ++--- .../go/nft-cancel/ws/main.go | 284 ++--- .../go/nft-modify/rpc/main.go | 180 +-- .../go/nft-modify/ws/main.go | 194 +-- _code-samples/partial-payment/go/rpc/main.go | 270 ++--- _code-samples/partial-payment/go/ws/main.go | 288 ++--- _code-samples/paths/go/rpc/main.go | 166 +-- _code-samples/paths/go/ws/main.go | 184 +-- _code-samples/secure-signing/go/main.go | 58 +- _code-samples/send-a-memo/go/rpc/main.go | 184 +-- _code-samples/send-a-memo/go/ws/main.go | 194 +-- _code-samples/send-xrp/go/rpc/main.go | 168 +-- _code-samples/send-xrp/go/ws/main.go | 84 +- _code-samples/set-regular-key/go/rpc/main.go | 202 ++-- _code-samples/set-regular-key/go/ws/main.go | 220 ++-- _code-samples/use-tickets/go/main.go | 208 ++-- 44 files changed, 5891 insertions(+), 5891 deletions(-) diff --git a/_code-samples/batch/go/rpc/main.go b/_code-samples/batch/go/rpc/main.go index 3675a7432d..8280b1b032 100644 --- a/_code-samples/batch/go/rpc/main.go +++ b/_code-samples/batch/go/rpc/main.go @@ -1,208 +1,208 @@ 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 ( - CreatePaymentTx = func(sender, receiver *wallet.Wallet, amount txnTypes.CurrencyAmount) *transaction.Payment { - return &transaction.Payment{ - BaseTx: transaction.BaseTx{ - Account: sender.GetAddress(), - TransactionType: transaction.PaymentTx, - Flags: txnTypes.TfInnerBatchTxn, - }, - Amount: amount, - Destination: receiver.GetAddress(), - } - } + CreatePaymentTx = func(sender, receiver *wallet.Wallet, amount txnTypes.CurrencyAmount) *transaction.Payment { + return &transaction.Payment{ + BaseTx: transaction.BaseTx{ + Account: sender.GetAddress(), + TransactionType: transaction.PaymentTx, + Flags: txnTypes.TfInnerBatchTxn, + }, + Amount: amount, + Destination: receiver.GetAddress(), + } + } ) func main() { - // Configure the client - cfg, err := rpc.NewClientConfig( - "https://s.devnet.rippletest.net:51234/", - rpc.WithFaucetProvider(faucet.NewDevnetFaucetProvider()), - ) - if err != nil { - panic(err) - } - client := rpc.NewClient(cfg) + // Configure the client + cfg, err := rpc.NewClientConfig( + "https://s.devnet.rippletest.net:51234/", + rpc.WithFaucetProvider(faucet.NewDevnetFaucetProvider()), + ) + if err != nil { + panic(err) + } + client := rpc.NewClient(cfg) - // Create and fund wallets - userWallet, err := wallet.New(crypto.ED25519()) - if err != nil { - fmt.Println(err) - return - } + // Create and fund wallets + userWallet, err := wallet.New(crypto.ED25519()) + if err != nil { + fmt.Println(err) + return + } - user2Wallet, err := wallet.New(crypto.ED25519()) - if err != nil { - fmt.Println(err) - return - } + user2Wallet, err := wallet.New(crypto.ED25519()) + if err != nil { + fmt.Println(err) + return + } - receiverWallet, err := wallet.New(crypto.ED25519()) - if err != nil { - fmt.Println(err) - return - } + receiverWallet, err := wallet.New(crypto.ED25519()) + if err != nil { + fmt.Println(err) + return + } - fmt.Println("⏳ Funding wallets...") - if err := client.FundWallet(&userWallet); err != nil { - fmt.Println(err) - return - } - if err := client.FundWallet(&user2Wallet); err != nil { - fmt.Println(err) - return - } - fmt.Println("💸 Wallets funded") + fmt.Println("⏳ Funding wallets...") + if err := client.FundWallet(&userWallet); err != nil { + fmt.Println(err) + return + } + if err := client.FundWallet(&user2Wallet); err != nil { + fmt.Println(err) + return + } + fmt.Println("💸 Wallets funded") - // Check initial balances - userBalance, err := client.GetXrpBalance(userWallet.ClassicAddress) - if err != nil { - userBalance = "0" - } - user2Balance, err := client.GetXrpBalance(user2Wallet.ClassicAddress) - if err != nil { - user2Balance = "0" - } + // Check initial balances + userBalance, err := client.GetXrpBalance(userWallet.ClassicAddress) + if err != nil { + userBalance = "0" + } + user2Balance, err := client.GetXrpBalance(user2Wallet.ClassicAddress) + if err != nil { + user2Balance = "0" + } - receiverBalance, err := client.GetXrpBalance(receiverWallet.ClassicAddress) - if err != nil { - receiverBalance = "0" - } + receiverBalance, err := client.GetXrpBalance(receiverWallet.ClassicAddress) + if err != nil { + 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.Println() + 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") + fmt.Printf("Batch transaction test\n") - // Create test batch transaction - batchTx := &transaction.Batch{ - BaseTx: transaction.BaseTx{ - Account: txnTypes.Address(userWallet.ClassicAddress), - TransactionType: transaction.BatchTx, - }, - RawTransactions: []txnTypes.RawTransaction{ - {RawTransaction: CreatePaymentTx(&userWallet, &receiverWallet, txnTypes.XRPCurrencyAmount(5000000)).Flatten()}, - {RawTransaction: CreatePaymentTx(&userWallet, &receiverWallet, txnTypes.XRPCurrencyAmount(5000000)).Flatten()}, - }, - } - batchTx.SetAllOrNothingFlag() + // Create test batch transaction + batchTx := &transaction.Batch{ + BaseTx: transaction.BaseTx{ + Account: txnTypes.Address(userWallet.ClassicAddress), + TransactionType: transaction.BatchTx, + }, + RawTransactions: []txnTypes.RawTransaction{ + {RawTransaction: CreatePaymentTx(&userWallet, &receiverWallet, txnTypes.XRPCurrencyAmount(5000000)).Flatten()}, + {RawTransaction: CreatePaymentTx(&userWallet, &receiverWallet, txnTypes.XRPCurrencyAmount(5000000)).Flatten()}, + }, + } + batchTx.SetAllOrNothingFlag() - flattenedBatchTx := batchTx.Flatten() - fmt.Println("⏳ Autofilling flattened batch transaction...") - if err := client.Autofill(&flattenedBatchTx); err != nil { - fmt.Println("Autofill error:", err) - return - } + flattenedBatchTx := batchTx.Flatten() + fmt.Println("⏳ Autofilling flattened batch transaction...") + if err := client.Autofill(&flattenedBatchTx); err != nil { + fmt.Println("Autofill error:", err) + return + } - fmt.Println("⏳ Signing batch transaction...") - response, err := client.SubmitTxAndWait(flattenedBatchTx, &types.SubmitOptions{ - Autofill: false, - Wallet: &userWallet, - }) - if err != nil { - fmt.Println(err) - return - } + fmt.Println("⏳ Signing batch transaction...") + response, err := client.SubmitTxAndWait(flattenedBatchTx, &types.SubmitOptions{ + Autofill: false, + Wallet: &userWallet, + }) + if err != nil { + fmt.Println(err) + return + } - fmt.Println("✅ Batch transaction submitted") - fmt.Printf("🌐 Hash: %s\n", response.Hash.String()) - fmt.Printf("🌐 Validated: %t\n", response.Validated) - fmt.Println() + 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 - finalUserBalance, err := client.GetXrpBalance(userWallet.ClassicAddress) - if err != nil { - finalUserBalance = "0" - } - finalReceiverBalance, err := client.GetXrpBalance(receiverWallet.ClassicAddress) - if err != nil { - finalReceiverBalance = "0" - } + // Check final balances + finalUserBalance, err := client.GetXrpBalance(userWallet.ClassicAddress) + if err != nil { + finalUserBalance = "0" + } + finalReceiverBalance, err := client.GetXrpBalance(receiverWallet.ClassicAddress) + if err != nil { + 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") + fmt.Println() + fmt.Printf("Multisig Batch transaction test\n") - // Create test batch transaction - multiBatchTx := &transaction.Batch{ - BaseTx: transaction.BaseTx{ - Account: txnTypes.Address(userWallet.ClassicAddress), - TransactionType: transaction.BatchTx, - }, - RawTransactions: []txnTypes.RawTransaction{ - {RawTransaction: CreatePaymentTx(&userWallet, &receiverWallet, txnTypes.XRPCurrencyAmount(5000000)).Flatten()}, - {RawTransaction: CreatePaymentTx(&user2Wallet, &receiverWallet, txnTypes.XRPCurrencyAmount(5000000)).Flatten()}, - }, - BatchSigners: []txnTypes.BatchSigner{ - { - BatchSigner: txnTypes.BatchSignerData{ - Account: txnTypes.Address(user2Wallet.ClassicAddress), - SigningPubKey: user2Wallet.PublicKey, - }, - }, - }, - } - multiBatchTx.SetAllOrNothingFlag() + // Create test batch transaction + multiBatchTx := &transaction.Batch{ + BaseTx: transaction.BaseTx{ + Account: txnTypes.Address(userWallet.ClassicAddress), + TransactionType: transaction.BatchTx, + }, + RawTransactions: []txnTypes.RawTransaction{ + {RawTransaction: CreatePaymentTx(&userWallet, &receiverWallet, txnTypes.XRPCurrencyAmount(5000000)).Flatten()}, + {RawTransaction: CreatePaymentTx(&user2Wallet, &receiverWallet, txnTypes.XRPCurrencyAmount(5000000)).Flatten()}, + }, + BatchSigners: []txnTypes.BatchSigner{ + { + BatchSigner: txnTypes.BatchSignerData{ + Account: txnTypes.Address(user2Wallet.ClassicAddress), + SigningPubKey: user2Wallet.PublicKey, + }, + }, + }, + } + multiBatchTx.SetAllOrNothingFlag() - flattenedMultiBatchTx := multiBatchTx.Flatten() - fmt.Println("⏳ Autofilling flattened multi batch transaction...") - if err := client.AutofillMultisigned(&flattenedMultiBatchTx, 1); err != nil { - fmt.Println("Autofill error:", err) - return - } + flattenedMultiBatchTx := multiBatchTx.Flatten() + 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...") - if err := wallet.SignMultiBatch(user2Wallet, &flattenedMultiBatchTx, nil); err != nil { - fmt.Println("Signing error:", err) - return - } + fmt.Println("⏳ Signing multi batch transaction...") + if err := wallet.SignMultiBatch(user2Wallet, &flattenedMultiBatchTx, nil); err != nil { + fmt.Println("Signing error:", err) + return + } - response, err = client.SubmitTxAndWait(flattenedMultiBatchTx, &types.SubmitOptions{ - Autofill: false, - Wallet: &userWallet, - }) - if err != nil { - fmt.Println(err) - return - } + response, err = client.SubmitTxAndWait(flattenedMultiBatchTx, &types.SubmitOptions{ + Autofill: false, + Wallet: &userWallet, + }) + if err != nil { + fmt.Println(err) + return + } - fmt.Println("✅ Multisig Batch transaction submitted") - fmt.Printf("🌐 Hash: %s\n", response.Hash.String()) - fmt.Printf("🌐 Validated: %t\n", response.Validated) - fmt.Println() + 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 - finalUser2Balance, err := client.GetXrpBalance(user2Wallet.ClassicAddress) - if err != nil { - finalUser2Balance = "0" - } - finalUserBalance, err = client.GetXrpBalance(userWallet.ClassicAddress) - if err != nil { - finalUserBalance = "0" - } - finalReceiverBalance, err = client.GetXrpBalance(receiverWallet.ClassicAddress) - 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) + // Check final balances + finalUser2Balance, err := client.GetXrpBalance(user2Wallet.ClassicAddress) + if err != nil { + finalUser2Balance = "0" + } + finalUserBalance, err = client.GetXrpBalance(userWallet.ClassicAddress) + if err != nil { + finalUserBalance = "0" + } + finalReceiverBalance, err = client.GetXrpBalance(receiverWallet.ClassicAddress) + 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) } diff --git a/_code-samples/batch/go/ws/main.go b/_code-samples/batch/go/ws/main.go index db6bd304ba..921986e8b2 100644 --- a/_code-samples/batch/go/ws/main.go +++ b/_code-samples/batch/go/ws/main.go @@ -1,210 +1,210 @@ 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 ( - CreatePaymentTx = func(sender, receiver *wallet.Wallet, amount txnTypes.CurrencyAmount) *transaction.Payment { - return &transaction.Payment{ - BaseTx: transaction.BaseTx{ - Account: sender.GetAddress(), - TransactionType: transaction.PaymentTx, - Flags: txnTypes.TfInnerBatchTxn, - }, - Amount: amount, - Destination: receiver.GetAddress(), - } - } + CreatePaymentTx = func(sender, receiver *wallet.Wallet, amount txnTypes.CurrencyAmount) *transaction.Payment { + return &transaction.Payment{ + BaseTx: transaction.BaseTx{ + Account: sender.GetAddress(), + TransactionType: transaction.PaymentTx, + Flags: txnTypes.TfInnerBatchTxn, + }, + Amount: amount, + Destination: receiver.GetAddress(), + } + } ) func main() { - // Connect to testnet - client := websocket.NewClient( - websocket.NewClientConfig(). - WithHost("wss://s.devnet.rippletest.net:51233"). - WithFaucetProvider(faucet.NewDevnetFaucetProvider()), - ) - defer client.Disconnect() + // Connect to testnet + client := websocket.NewClient( + websocket.NewClientConfig(). + WithHost("wss://s.devnet.rippletest.net:51233"). + WithFaucetProvider(faucet.NewDevnetFaucetProvider()), + ) + defer client.Disconnect() - if err := client.Connect(); err != nil { - fmt.Println(err) - return - } + if err := client.Connect(); err != nil { + fmt.Println(err) + return + } - // Create and fund wallets - userWallet, err := wallet.New(crypto.ED25519()) - if err != nil { - fmt.Println(err) - return - } + // Create and fund wallets + userWallet, err := wallet.New(crypto.ED25519()) + if err != nil { + fmt.Println(err) + return + } - user2Wallet, err := wallet.New(crypto.ED25519()) - if err != nil { - fmt.Println(err) - return - } - receiverWallet, err := wallet.New(crypto.ED25519()) - if err != nil { - fmt.Println(err) - return - } + user2Wallet, err := wallet.New(crypto.ED25519()) + if err != nil { + fmt.Println(err) + return + } + receiverWallet, err := wallet.New(crypto.ED25519()) + if err != nil { + fmt.Println(err) + return + } - fmt.Println("⏳ Funding wallets...") - if err := client.FundWallet(&userWallet); err != nil { - fmt.Println(err) - return - } - if err := client.FundWallet(&user2Wallet); err != nil { - fmt.Println(err) - return - } - fmt.Println("💸 Wallets funded") + fmt.Println("⏳ Funding wallets...") + if err := client.FundWallet(&userWallet); err != nil { + fmt.Println(err) + return + } + if err := client.FundWallet(&user2Wallet); err != nil { + fmt.Println(err) + return + } + fmt.Println("💸 Wallets funded") - // Check initial balances - userBalance, err := client.GetXrpBalance(userWallet.ClassicAddress) - if err != nil { - userBalance = "0" - } - user2Balance, err := client.GetXrpBalance(user2Wallet.ClassicAddress) - if err != nil { - user2Balance = "0" - } + // Check initial balances + userBalance, err := client.GetXrpBalance(userWallet.ClassicAddress) + if err != nil { + userBalance = "0" + } + user2Balance, err := client.GetXrpBalance(user2Wallet.ClassicAddress) + if err != nil { + user2Balance = "0" + } - receiverBalance, err := client.GetXrpBalance(receiverWallet.ClassicAddress) - if err != nil { - receiverBalance = "0" - } + receiverBalance, err := client.GetXrpBalance(receiverWallet.ClassicAddress) + if err != nil { + 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.Println() + 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") + fmt.Printf("Batch transaction test\n") - // Create test batch transaction - batchTx := &transaction.Batch{ - BaseTx: transaction.BaseTx{ - Account: txnTypes.Address(userWallet.ClassicAddress), - TransactionType: transaction.BatchTx, - }, - RawTransactions: []txnTypes.RawTransaction{ - {RawTransaction: CreatePaymentTx(&userWallet, &receiverWallet, txnTypes.XRPCurrencyAmount(5000000)).Flatten()}, - {RawTransaction: CreatePaymentTx(&userWallet, &receiverWallet, txnTypes.XRPCurrencyAmount(5000000)).Flatten()}, - }, - } - batchTx.SetAllOrNothingFlag() + // Create test batch transaction + batchTx := &transaction.Batch{ + BaseTx: transaction.BaseTx{ + Account: txnTypes.Address(userWallet.ClassicAddress), + TransactionType: transaction.BatchTx, + }, + RawTransactions: []txnTypes.RawTransaction{ + {RawTransaction: CreatePaymentTx(&userWallet, &receiverWallet, txnTypes.XRPCurrencyAmount(5000000)).Flatten()}, + {RawTransaction: CreatePaymentTx(&userWallet, &receiverWallet, txnTypes.XRPCurrencyAmount(5000000)).Flatten()}, + }, + } + batchTx.SetAllOrNothingFlag() - flattenedBatchTx := batchTx.Flatten() - fmt.Println("⏳ Autofilling flattened batch transaction...") - if err := client.Autofill(&flattenedBatchTx); err != nil { - fmt.Println("Autofill error:", err) - return - } + flattenedBatchTx := batchTx.Flatten() + fmt.Println("⏳ Autofilling flattened batch transaction...") + if err := client.Autofill(&flattenedBatchTx); err != nil { + fmt.Println("Autofill error:", err) + return + } - fmt.Println("⏳ Signing batch transaction...") - response, err := client.SubmitTxAndWait(flattenedBatchTx, &types.SubmitOptions{ - Autofill: false, - Wallet: &userWallet, - }) - if err != nil { - fmt.Println(err) - return - } + fmt.Println("⏳ Signing batch transaction...") + response, err := client.SubmitTxAndWait(flattenedBatchTx, &types.SubmitOptions{ + Autofill: false, + Wallet: &userWallet, + }) + if err != nil { + fmt.Println(err) + return + } - fmt.Println("✅ Batch transaction submitted") - fmt.Printf("🌐 Hash: %s\n", response.Hash.String()) - fmt.Printf("🌐 Validated: %t\n", response.Validated) - fmt.Println() + 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 - finalUserBalance, err := client.GetXrpBalance(userWallet.ClassicAddress) - if err != nil { - finalUserBalance = "0" - } - finalReceiverBalance, err := client.GetXrpBalance(receiverWallet.ClassicAddress) - if err != nil { - finalReceiverBalance = "0" - } + // Check final balances + finalUserBalance, err := client.GetXrpBalance(userWallet.ClassicAddress) + if err != nil { + finalUserBalance = "0" + } + finalReceiverBalance, err := client.GetXrpBalance(receiverWallet.ClassicAddress) + if err != nil { + 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") + fmt.Println() + fmt.Printf("Multisig Batch transaction test\n") - // Create test batch transaction - multiBatchTx := &transaction.Batch{ - BaseTx: transaction.BaseTx{ - Account: txnTypes.Address(userWallet.ClassicAddress), - TransactionType: transaction.BatchTx, - }, - RawTransactions: []txnTypes.RawTransaction{ - {RawTransaction: CreatePaymentTx(&userWallet, &receiverWallet, txnTypes.XRPCurrencyAmount(5000000)).Flatten()}, - {RawTransaction: CreatePaymentTx(&user2Wallet, &receiverWallet, txnTypes.XRPCurrencyAmount(5000000)).Flatten()}, - }, - BatchSigners: []txnTypes.BatchSigner{ - { - BatchSigner: txnTypes.BatchSignerData{ - Account: txnTypes.Address(user2Wallet.ClassicAddress), - SigningPubKey: user2Wallet.PublicKey, - }, - }, - }, - } - multiBatchTx.SetAllOrNothingFlag() + // Create test batch transaction + multiBatchTx := &transaction.Batch{ + BaseTx: transaction.BaseTx{ + Account: txnTypes.Address(userWallet.ClassicAddress), + TransactionType: transaction.BatchTx, + }, + RawTransactions: []txnTypes.RawTransaction{ + {RawTransaction: CreatePaymentTx(&userWallet, &receiverWallet, txnTypes.XRPCurrencyAmount(5000000)).Flatten()}, + {RawTransaction: CreatePaymentTx(&user2Wallet, &receiverWallet, txnTypes.XRPCurrencyAmount(5000000)).Flatten()}, + }, + BatchSigners: []txnTypes.BatchSigner{ + { + BatchSigner: txnTypes.BatchSignerData{ + Account: txnTypes.Address(user2Wallet.ClassicAddress), + SigningPubKey: user2Wallet.PublicKey, + }, + }, + }, + } + multiBatchTx.SetAllOrNothingFlag() - flattenedMultiBatchTx := multiBatchTx.Flatten() - fmt.Println("⏳ Autofilling flattened multi batch transaction...") - if err := client.AutofillMultisigned(&flattenedMultiBatchTx, 1); err != nil { - fmt.Println("Autofill error:", err) - return - } + flattenedMultiBatchTx := multiBatchTx.Flatten() + 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...") - if err := wallet.SignMultiBatch(user2Wallet, &flattenedMultiBatchTx, nil); err != nil { - fmt.Println("Signing error:", err) - return - } + fmt.Println("⏳ Signing multi batch transaction...") + if err := wallet.SignMultiBatch(user2Wallet, &flattenedMultiBatchTx, nil); err != nil { + fmt.Println("Signing error:", err) + return + } - response, err = client.SubmitTxAndWait(flattenedMultiBatchTx, &types.SubmitOptions{ - Autofill: false, - Wallet: &userWallet, - }) - if err != nil { - fmt.Println(err) - return - } + response, err = client.SubmitTxAndWait(flattenedMultiBatchTx, &types.SubmitOptions{ + Autofill: false, + Wallet: &userWallet, + }) + if err != nil { + fmt.Println(err) + return + } - fmt.Println("✅ Multisig Batch transaction submitted") - fmt.Printf("🌐 Hash: %s\n", response.Hash.String()) - fmt.Printf("🌐 Validated: %t\n", response.Validated) - fmt.Println() + 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 - finalUser2Balance, err := client.GetXrpBalance(user2Wallet.ClassicAddress) - if err != nil { - finalUser2Balance = "0" - } - finalUserBalance, err = client.GetXrpBalance(userWallet.ClassicAddress) - if err != nil { - finalUserBalance = "0" - } - finalReceiverBalance, err = client.GetXrpBalance(receiverWallet.ClassicAddress) - 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) + // Check final balances + finalUser2Balance, err := client.GetXrpBalance(user2Wallet.ClassicAddress) + if err != nil { + finalUser2Balance = "0" + } + finalUserBalance, err = client.GetXrpBalance(userWallet.ClassicAddress) + if err != nil { + finalUserBalance = "0" + } + finalReceiverBalance, err = client.GetXrpBalance(receiverWallet.ClassicAddress) + 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) } diff --git a/_code-samples/checks/go/rpc/main.go b/_code-samples/checks/go/rpc/main.go index fb9d51a372..cfa65a2b1f 100644 --- a/_code-samples/checks/go/rpc/main.go +++ b/_code-samples/checks/go/rpc/main.go @@ -1,162 +1,162 @@ 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() { - cfg, err := rpc.NewClientConfig( - "https://s.altnet.rippletest.net:51234/", - rpc.WithFaucetProvider(faucet.NewTestnetFaucetProvider()), - ) - if err != nil { - panic(err) - } + cfg, err := rpc.NewClientConfig( + "https://s.altnet.rippletest.net:51234/", + rpc.WithFaucetProvider(faucet.NewTestnetFaucetProvider()), + ) + if err != nil { + panic(err) + } - client := rpc.NewClient(cfg) + client := rpc.NewClient(cfg) - w, err := wallet.New(crypto.ED25519()) - if err != nil { - fmt.Println(err) - return - } + w, err := wallet.New(crypto.ED25519()) + if err != nil { + fmt.Println(err) + return + } - receiverWallet, err := wallet.New(crypto.ED25519()) - if err != nil { - fmt.Println(err) - return - } + receiverWallet, err := wallet.New(crypto.ED25519()) + if err != nil { + fmt.Println(err) + return + } - fmt.Println("⏳ Setting up wallets...") - if err := client.FundWallet(&w); err != nil { - fmt.Println(err) - return - } - fmt.Println("💸 Sender wallet funded!") + fmt.Println("⏳ Setting up wallets...") + if err := client.FundWallet(&w); err != nil { + fmt.Println(err) + return + } + fmt.Println("💸 Sender wallet funded!") - if err := client.FundWallet(&receiverWallet); err != nil { - fmt.Println(err) - return - } + if err := client.FundWallet(&receiverWallet); err != nil { + fmt.Println(err) + return + } - fmt.Println("💸 Receiver wallet funded!") - fmt.Println() + 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() + fmt.Println("✅ Wallets setup complete!") + fmt.Println("💳 Sender wallet:", w.ClassicAddress) + fmt.Println("💳 Receiver wallet:", receiverWallet.ClassicAddress) + fmt.Println() - fmt.Println("⏳ Creating check...") - cc := &transaction.CheckCreate{ - BaseTx: transaction.BaseTx{ - Account: w.GetAddress(), - }, - Destination: receiverWallet.GetAddress(), - SendMax: types.XRPCurrencyAmount(1000000), - InvoiceID: "46060241FABCF692D4D934BA2A6C4427CD4279083E38C77CBE642243E43BE291", - } + fmt.Println("⏳ Creating check...") + cc := &transaction.CheckCreate{ + BaseTx: transaction.BaseTx{ + Account: w.GetAddress(), + }, + Destination: receiverWallet.GetAddress(), + SendMax: types.XRPCurrencyAmount(1000000), + InvoiceID: "46060241FABCF692D4D934BA2A6C4427CD4279083E38C77CBE642243E43BE291", + } - flatCc := cc.Flatten() + flatCc := cc.Flatten() - if err := client.Autofill(&flatCc); err != nil { - fmt.Println(err) - return - } + if err := client.Autofill(&flatCc); err != nil { + fmt.Println(err) + return + } - blob, _, err := w.Sign(flatCc) - if err != nil { - fmt.Println(err) - return - } + blob, _, err := w.Sign(flatCc) + if err != nil { + fmt.Println(err) + return + } - res, err := client.SubmitTxBlobAndWait(blob, false) - if err != nil { - fmt.Println(err) - return - } + res, err := client.SubmitTxBlobAndWait(blob, false) + if err != nil { + fmt.Println(err) + return + } - if !res.Validated { - fmt.Println("❌ Check creation failed!") - fmt.Println("Try again!") - fmt.Println() - return - } + if !res.Validated { + 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() + 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") - return - } + meta, ok := res.Meta.(map[string]interface{}) + if !ok { + fmt.Println("❌ Meta is not of type TxObjMeta") + return + } - var checkID string + var checkID string - affectedNodes := meta["AffectedNodes"].([]interface{}) + affectedNodes := meta["AffectedNodes"].([]interface{}) - for _, node := range affectedNodes { - affectedNode, ok := node.(map[string]interface{}) - if !ok { - fmt.Println("❌ Node is not of type map[string]interface{}") - return - } + for _, node := range affectedNodes { + affectedNode, ok := node.(map[string]interface{}) + if !ok { + fmt.Println("❌ Node is not of type map[string]interface{}") + return + } - createdNode, ok := affectedNode["CreatedNode"].(map[string]interface{}) - if !ok { - continue - } + createdNode, ok := affectedNode["CreatedNode"].(map[string]interface{}) + if !ok { + continue + } - if createdNode["LedgerEntryType"] == string(ledger.CheckEntry) { + if createdNode["LedgerEntryType"] == string(ledger.CheckEntry) { - checkID = createdNode["LedgerIndex"].(string) - } - } + checkID = createdNode["LedgerIndex"].(string) + } + } - if checkID == "" { - fmt.Println("Check not found") - return - } + if checkID == "" { + fmt.Println("Check not found") + return + } - fmt.Println("⏳ Cashing out check...") - checkCash := &transaction.CheckCash{ - BaseTx: transaction.BaseTx{ - Account: receiverWallet.GetAddress(), - }, - CheckID: types.Hash256(checkID), - Amount: types.XRPCurrencyAmount(1000000), - } + fmt.Println("⏳ Cashing out check...") + checkCash := &transaction.CheckCash{ + BaseTx: transaction.BaseTx{ + Account: receiverWallet.GetAddress(), + }, + CheckID: types.Hash256(checkID), + Amount: types.XRPCurrencyAmount(1000000), + } - flatCheckCash := checkCash.Flatten() + flatCheckCash := checkCash.Flatten() - if err := client.Autofill(&flatCheckCash); err != nil { - fmt.Println(err) - return - } + if err := client.Autofill(&flatCheckCash); err != nil { + fmt.Println(err) + return + } - blob, _, err = receiverWallet.Sign(flatCheckCash) - if err != nil { - fmt.Println(err) - return - } + blob, _, err = receiverWallet.Sign(flatCheckCash) + if err != nil { + fmt.Println(err) + return + } - res, err = client.SubmitTxBlobAndWait(blob, false) - if err != nil { - fmt.Println(err) - return - } + res, err = client.SubmitTxBlobAndWait(blob, false) + if err != nil { + fmt.Println(err) + return + } - fmt.Println("✅ Check cashed out!") - fmt.Printf("🌐 Hash: %s\n", res.Hash.String()) - fmt.Println() + fmt.Println("✅ Check cashed out!") + fmt.Printf("🌐 Hash: %s\n", res.Hash.String()) + fmt.Println() } diff --git a/_code-samples/checks/go/ws/main.go b/_code-samples/checks/go/ws/main.go index a3e38cd72b..323be583d5 100644 --- a/_code-samples/checks/go/ws/main.go +++ b/_code-samples/checks/go/ws/main.go @@ -1,173 +1,173 @@ 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...") - client := websocket.NewClient( - websocket.NewClientConfig(). - WithHost("wss://s.altnet.rippletest.net:51233"). - WithFaucetProvider(faucet.NewTestnetFaucetProvider()), - ) - defer client.Disconnect() + fmt.Println("⏳ Connecting to testnet...") + client := websocket.NewClient( + websocket.NewClientConfig(). + WithHost("wss://s.altnet.rippletest.net:51233"). + WithFaucetProvider(faucet.NewTestnetFaucetProvider()), + ) + defer client.Disconnect() - if err := client.Connect(); err != nil { - fmt.Println(err) - return - } + if err := client.Connect(); err != nil { + fmt.Println(err) + return + } - if !client.IsConnected() { - fmt.Println("❌ Failed to connect to testnet") - return - } + if !client.IsConnected() { + fmt.Println("❌ Failed to connect to testnet") + return + } - fmt.Println("✅ Connected to testnet") - fmt.Println() + fmt.Println("✅ Connected to testnet") + fmt.Println() - w, err := wallet.New(crypto.ED25519()) - if err != nil { - fmt.Println(err) - return - } + w, err := wallet.New(crypto.ED25519()) + if err != nil { + fmt.Println(err) + return + } - receiverWallet, err := wallet.New(crypto.ED25519()) - if err != nil { - fmt.Println(err) - return - } + receiverWallet, err := wallet.New(crypto.ED25519()) + if err != nil { + fmt.Println(err) + return + } - fmt.Println("⏳ Setting up wallets...") - if err := client.FundWallet(&w); err != nil { - fmt.Println(err) - return - } - fmt.Println("💸 Sender wallet funded!") + fmt.Println("⏳ Setting up wallets...") + if err := client.FundWallet(&w); err != nil { + fmt.Println(err) + return + } + fmt.Println("💸 Sender wallet funded!") - if err := client.FundWallet(&receiverWallet); err != nil { - fmt.Println(err) - return - } + if err := client.FundWallet(&receiverWallet); err != nil { + fmt.Println(err) + return + } - fmt.Println("💸 Receiver wallet funded!") - fmt.Println() + 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() + fmt.Println("✅ Wallets setup complete!") + fmt.Println("💳 Sender wallet:", w.ClassicAddress) + fmt.Println("💳 Receiver wallet:", receiverWallet.ClassicAddress) + fmt.Println() - fmt.Println("⏳ Creating check...") - cc := &transaction.CheckCreate{ - BaseTx: transaction.BaseTx{ - Account: w.GetAddress(), - }, - Destination: receiverWallet.GetAddress(), - SendMax: types.XRPCurrencyAmount(1000000), - InvoiceID: "46060241FABCF692D4D934BA2A6C4427CD4279083E38C77CBE642243E43BE291", - } + fmt.Println("⏳ Creating check...") + cc := &transaction.CheckCreate{ + BaseTx: transaction.BaseTx{ + Account: w.GetAddress(), + }, + Destination: receiverWallet.GetAddress(), + SendMax: types.XRPCurrencyAmount(1000000), + InvoiceID: "46060241FABCF692D4D934BA2A6C4427CD4279083E38C77CBE642243E43BE291", + } - flatCc := cc.Flatten() + flatCc := cc.Flatten() - if err := client.Autofill(&flatCc); err != nil { - fmt.Println(err) - return - } + if err := client.Autofill(&flatCc); err != nil { + fmt.Println(err) + return + } - blob, _, err := w.Sign(flatCc) - if err != nil { - fmt.Println(err) - return - } + blob, _, err := w.Sign(flatCc) + if err != nil { + fmt.Println(err) + return + } - res, err := client.SubmitTxBlobAndWait(blob, false) - if err != nil { - fmt.Println(err) - return - } + res, err := client.SubmitTxBlobAndWait(blob, false) + if err != nil { + fmt.Println(err) + return + } - if !res.Validated { - fmt.Println("❌ Check creation failed!") - fmt.Println("Try again!") - fmt.Println() - return - } + if !res.Validated { + 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() + 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") - return - } + meta, ok := res.Meta.(map[string]interface{}) + if !ok { + fmt.Println("❌ Meta is not of type TxObjMeta") + return + } - var checkID string + var checkID string - affectedNodes := meta["AffectedNodes"].([]interface{}) + affectedNodes := meta["AffectedNodes"].([]interface{}) - for _, node := range affectedNodes { - affectedNode, ok := node.(map[string]interface{}) - if !ok { - fmt.Println("❌ Node is not of type map[string]interface{}") - return - } + for _, node := range affectedNodes { + affectedNode, ok := node.(map[string]interface{}) + if !ok { + fmt.Println("❌ Node is not of type map[string]interface{}") + return + } - createdNode, ok := affectedNode["CreatedNode"].(map[string]interface{}) - if !ok { - continue - } + createdNode, ok := affectedNode["CreatedNode"].(map[string]interface{}) + if !ok { + continue + } - if createdNode["LedgerEntryType"] == string(ledger.CheckEntry) { + if createdNode["LedgerEntryType"] == string(ledger.CheckEntry) { - checkID = createdNode["LedgerIndex"].(string) - } - } + checkID = createdNode["LedgerIndex"].(string) + } + } - if checkID == "" { - fmt.Println("Check not found") - return - } + if checkID == "" { + fmt.Println("Check not found") + return + } - fmt.Println("⏳ Cashing out check...") - checkCash := &transaction.CheckCash{ - BaseTx: transaction.BaseTx{ - Account: receiverWallet.GetAddress(), - }, - CheckID: types.Hash256(checkID), - Amount: types.XRPCurrencyAmount(1000000), - } + fmt.Println("⏳ Cashing out check...") + checkCash := &transaction.CheckCash{ + BaseTx: transaction.BaseTx{ + Account: receiverWallet.GetAddress(), + }, + CheckID: types.Hash256(checkID), + Amount: types.XRPCurrencyAmount(1000000), + } - flatCheckCash := checkCash.Flatten() + flatCheckCash := checkCash.Flatten() - if err := client.Autofill(&flatCheckCash); err != nil { - fmt.Println(err) - return - } + if err := client.Autofill(&flatCheckCash); err != nil { + fmt.Println(err) + return + } - blob, _, err = receiverWallet.Sign(flatCheckCash) - if err != nil { - fmt.Println(err) - return - } + blob, _, err = receiverWallet.Sign(flatCheckCash) + if err != nil { + fmt.Println(err) + return + } - res, err = client.SubmitTxBlobAndWait(blob, false) - if err != nil { - fmt.Println(err) - return - } + res, err = client.SubmitTxBlobAndWait(blob, false) + if err != nil { + fmt.Println(err) + return + } - fmt.Println("✅ Check cashed out!") - fmt.Printf("🌐 Hash: %s\n", res.Hash.String()) - fmt.Println() + fmt.Println("✅ Check cashed out!") + fmt.Printf("🌐 Hash: %s\n", res.Hash.String()) + fmt.Println() } diff --git a/_code-samples/clawback/go/rpc/main.go b/_code-samples/clawback/go/rpc/main.go index ead2e28eb6..c54c1a186d 100644 --- a/_code-samples/clawback/go/rpc/main.go +++ b/_code-samples/clawback/go/rpc/main.go @@ -1,251 +1,251 @@ 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 ( - currencyCode = "FOO" + currencyCode = "FOO" ) func main() { - // - // Configure client - // - cfg, err := rpc.NewClientConfig( - "https://s.altnet.rippletest.net:51234/", - rpc.WithFaucetProvider(faucet.NewTestnetFaucetProvider()), - ) - if err != nil { - panic(err) - } + // + // Configure client + // + cfg, err := rpc.NewClientConfig( + "https://s.altnet.rippletest.net:51234/", + rpc.WithFaucetProvider(faucet.NewTestnetFaucetProvider()), + ) + if err != nil { + panic(err) + } - client := rpc.NewClient(cfg) + client := rpc.NewClient(cfg) - // - // Configure wallets - // - fmt.Println("⏳ Setting up wallets...") - coldWallet, err := wallet.New(crypto.ED25519()) - if err != nil { - 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) - return - } - fmt.Println("💸 Cold wallet funded!") + // + // Configure wallets + // + fmt.Println("⏳ Setting up wallets...") + coldWallet, err := wallet.New(crypto.ED25519()) + if err != nil { + 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) + return + } + fmt.Println("💸 Cold wallet funded!") - hotWallet, err := wallet.New(crypto.ED25519()) - if err != nil { - 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) - return - } - fmt.Println("💸 Hot wallet funded!") - fmt.Println() + hotWallet, err := wallet.New(crypto.ED25519()) + if err != nil { + 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) + return + } + 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() + 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...") - coldWalletAccountSet := &transactions.AccountSet{ - BaseTx: transactions.BaseTx{ - Account: types.Address(coldWallet.ClassicAddress), - }, - TickSize: types.TickSize(5), - TransferRate: types.TransferRate(0), - Domain: types.Domain("6578616D706C652E636F6D"), // example.com - } + // + // Configure cold address settings + // + fmt.Println("⏳ Configuring cold address settings...") + coldWalletAccountSet := &transactions.AccountSet{ + BaseTx: transactions.BaseTx{ + Account: types.Address(coldWallet.ClassicAddress), + }, + TickSize: types.TickSize(5), + TransferRate: types.TransferRate(0), + Domain: types.Domain("6578616D706C652E636F6D"), // example.com + } - coldWalletAccountSet.SetAsfAllowTrustLineClawback() - coldWalletAccountSet.SetDisallowXRP() + coldWalletAccountSet.SetAsfAllowTrustLineClawback() + coldWalletAccountSet.SetDisallowXRP() - coldWalletAccountSet.SetRequireDestTag() + coldWalletAccountSet.SetRequireDestTag() - flattenedTx := coldWalletAccountSet.Flatten() + flattenedTx := coldWalletAccountSet.Flatten() - err = client.Autofill(&flattenedTx) - if err != nil { - fmt.Printf("❌ Error autofilling transaction: %s\n", err) - return - } + err = client.Autofill(&flattenedTx) + if err != nil { + 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) - return - } + txBlob, _, err := coldWallet.Sign(flattenedTx) + if err != nil { + 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) - return - } + response, err := client.SubmitTxBlobAndWait(txBlob, false) + if err != nil { + fmt.Printf("❌ Error submitting transaction: %s\n", err) + return + } - if !response.Validated { - fmt.Println("❌ Cold wallet unfreezing failed!") - fmt.Println("Try again!") - fmt.Println() - return - } + if !response.Validated { + 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() + 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...") - hotColdTrustSet := &transactions.TrustSet{ - BaseTx: transactions.BaseTx{ - Account: types.Address(hotWallet.ClassicAddress), - }, - LimitAmount: types.IssuedCurrencyAmount{ - Currency: currencyCode, - Issuer: types.Address(coldWallet.ClassicAddress), - Value: "100000000000000", - }, - } + // + // Create 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), + }, + LimitAmount: types.IssuedCurrencyAmount{ + Currency: currencyCode, + Issuer: types.Address(coldWallet.ClassicAddress), + Value: "100000000000000", + }, + } - flattenedTx = hotColdTrustSet.Flatten() - err = client.Autofill(&flattenedTx) - if err != nil { - fmt.Printf("❌ Error autofilling transaction: %s\n", err) - return - } + flattenedTx = hotColdTrustSet.Flatten() + err = client.Autofill(&flattenedTx) + if err != nil { + 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) - return - } + txBlob, _, err = hotWallet.Sign(flattenedTx) + if err != nil { + 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) - return - } + response, err = client.SubmitTxBlobAndWait(txBlob, false) + if err != nil { + 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("Try again!") - fmt.Println() - return - } + if !response.Validated { + 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() + 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...") - coldToHotPayment := &transactions.Payment{ - BaseTx: transactions.BaseTx{ - Account: types.Address(coldWallet.ClassicAddress), - }, - Amount: types.IssuedCurrencyAmount{ - Currency: currencyCode, - Issuer: types.Address(coldWallet.ClassicAddress), - Value: "3800", - }, - Destination: types.Address(hotWallet.ClassicAddress), - DestinationTag: types.DestinationTag(1), - } + // + // Send 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), + }, + Amount: types.IssuedCurrencyAmount{ + Currency: currencyCode, + Issuer: types.Address(coldWallet.ClassicAddress), + Value: "3800", + }, + Destination: types.Address(hotWallet.ClassicAddress), + DestinationTag: types.DestinationTag(1), + } - flattenedTx = coldToHotPayment.Flatten() - err = client.Autofill(&flattenedTx) - if err != nil { - fmt.Printf("❌ Error autofilling transaction: %s\n", err) - return - } + flattenedTx = coldToHotPayment.Flatten() + err = client.Autofill(&flattenedTx) + if err != nil { + 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) - return - } + txBlob, _, err = coldWallet.Sign(flattenedTx) + if err != nil { + 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) - return - } + response, err = client.SubmitTxBlobAndWait(txBlob, false) + if err != nil { + 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("Try again!") - fmt.Println() - return - } + if !response.Validated { + 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() + 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...") + // + // Claw back tokens from customer one + // + fmt.Println("⏳ Clawing back tokens from hot wallet...") - coldWalletClawback := &transactions.Clawback{ - BaseTx: transactions.BaseTx{ - Account: types.Address(coldWallet.ClassicAddress), - }, - Amount: types.IssuedCurrencyAmount{ - Currency: currencyCode, - Issuer: types.Address(hotWallet.ClassicAddress), - Value: "50", - }, - } + coldWalletClawback := &transactions.Clawback{ + BaseTx: transactions.BaseTx{ + Account: types.Address(coldWallet.ClassicAddress), + }, + Amount: types.IssuedCurrencyAmount{ + Currency: currencyCode, + Issuer: types.Address(hotWallet.ClassicAddress), + Value: "50", + }, + } - flattenedTx = coldWalletClawback.Flatten() - err = client.Autofill(&flattenedTx) - if err != nil { - fmt.Printf("❌ Error autofilling transaction: %s\n", err) - return - } + flattenedTx = coldWalletClawback.Flatten() + err = client.Autofill(&flattenedTx) + if err != nil { + 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) - return - } + txBlob, _, err = coldWallet.Sign(flattenedTx) + if err != nil { + 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) - return - } + response, err = client.SubmitTxBlobAndWait(txBlob, false) + if err != nil { + fmt.Printf("❌ Error submitting transaction: %s\n", err) + return + } - if !response.Validated { - fmt.Println("❌ Tokens not clawed back from customer one!") - fmt.Println("Try again!") - return - } + if !response.Validated { + 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() + fmt.Println("✅ Tokens clawed back from customer one!") + fmt.Printf("🌐 Hash: %s\n", response.Hash.String()) + fmt.Println() } diff --git a/_code-samples/clawback/go/ws/main.go b/_code-samples/clawback/go/ws/main.go index 6a689ccde4..9f1950def9 100644 --- a/_code-samples/clawback/go/ws/main.go +++ b/_code-samples/clawback/go/ws/main.go @@ -1,258 +1,258 @@ 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 ( - currencyCode = "FOO" + currencyCode = "FOO" ) func main() { - // - // Configure 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() + // + // Configure 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() - fmt.Println("Connecting to server...") - if err := client.Connect(); err != nil { - fmt.Println(err) - return - } + fmt.Println("Connecting to server...") + if err := client.Connect(); err != nil { + fmt.Println(err) + return + } - fmt.Println("Connection: ", client.IsConnected()) + fmt.Println("Connection: ", client.IsConnected()) - // - // Configure wallets - // - fmt.Println("⏳ Setting up wallets...") - coldWallet, err := wallet.New(crypto.ED25519()) - if err != nil { - 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) - return - } - fmt.Println("💸 Cold wallet funded!") + // + // Configure wallets + // + fmt.Println("⏳ Setting up wallets...") + coldWallet, err := wallet.New(crypto.ED25519()) + if err != nil { + 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) + return + } + fmt.Println("💸 Cold wallet funded!") - hotWallet, err := wallet.New(crypto.ED25519()) - if err != nil { - 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) - return - } - fmt.Println("💸 Hot wallet funded!") - fmt.Println() + hotWallet, err := wallet.New(crypto.ED25519()) + if err != nil { + 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) + return + } + 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() + 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...") - coldWalletAccountSet := &transactions.AccountSet{ - BaseTx: transactions.BaseTx{ - Account: types.Address(coldWallet.ClassicAddress), - }, - TickSize: types.TickSize(5), - TransferRate: types.TransferRate(0), - Domain: types.Domain("6578616D706C652E636F6D"), // example.com - } + // + // Configure cold address settings + // + fmt.Println("⏳ Configuring cold address settings...") + coldWalletAccountSet := &transactions.AccountSet{ + BaseTx: transactions.BaseTx{ + Account: types.Address(coldWallet.ClassicAddress), + }, + TickSize: types.TickSize(5), + TransferRate: types.TransferRate(0), + Domain: types.Domain("6578616D706C652E636F6D"), // example.com + } - coldWalletAccountSet.SetAsfAllowTrustLineClawback() - coldWalletAccountSet.SetDisallowXRP() + coldWalletAccountSet.SetAsfAllowTrustLineClawback() + coldWalletAccountSet.SetDisallowXRP() - coldWalletAccountSet.SetRequireDestTag() + coldWalletAccountSet.SetRequireDestTag() - flattenedTx := coldWalletAccountSet.Flatten() + flattenedTx := coldWalletAccountSet.Flatten() - err = client.Autofill(&flattenedTx) - if err != nil { - fmt.Printf("❌ Error autofilling transaction: %s\n", err) - return - } + err = client.Autofill(&flattenedTx) + if err != nil { + 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) - return - } + txBlob, _, err := coldWallet.Sign(flattenedTx) + if err != nil { + 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) - return - } + response, err := client.SubmitTxBlobAndWait(txBlob, false) + if err != nil { + fmt.Printf("❌ Error submitting transaction: %s\n", err) + return + } - if !response.Validated { - fmt.Println("❌ Cold wallet unfreezing failed!") - fmt.Println("Try again!") - fmt.Println() - return - } + if !response.Validated { + 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() + 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...") - hotColdTrustSet := &transactions.TrustSet{ - BaseTx: transactions.BaseTx{ - Account: types.Address(hotWallet.ClassicAddress), - }, - LimitAmount: types.IssuedCurrencyAmount{ - Currency: currencyCode, - Issuer: types.Address(coldWallet.ClassicAddress), - Value: "100000000000000", - }, - } + // + // Create 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), + }, + LimitAmount: types.IssuedCurrencyAmount{ + Currency: currencyCode, + Issuer: types.Address(coldWallet.ClassicAddress), + Value: "100000000000000", + }, + } - flattenedTx = hotColdTrustSet.Flatten() - err = client.Autofill(&flattenedTx) - if err != nil { - fmt.Printf("❌ Error autofilling transaction: %s\n", err) - return - } + flattenedTx = hotColdTrustSet.Flatten() + err = client.Autofill(&flattenedTx) + if err != nil { + 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) - return - } + txBlob, _, err = hotWallet.Sign(flattenedTx) + if err != nil { + 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) - return - } + response, err = client.SubmitTxBlobAndWait(txBlob, false) + if err != nil { + 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("Try again!") - fmt.Println() - return - } + if !response.Validated { + 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() + 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...") - coldToHotPayment := &transactions.Payment{ - BaseTx: transactions.BaseTx{ - Account: types.Address(coldWallet.ClassicAddress), - }, - Amount: types.IssuedCurrencyAmount{ - Currency: currencyCode, - Issuer: types.Address(coldWallet.ClassicAddress), - Value: "3800", - }, - Destination: types.Address(hotWallet.ClassicAddress), - DestinationTag: types.DestinationTag(1), - } + // + // Send 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), + }, + Amount: types.IssuedCurrencyAmount{ + Currency: currencyCode, + Issuer: types.Address(coldWallet.ClassicAddress), + Value: "3800", + }, + Destination: types.Address(hotWallet.ClassicAddress), + DestinationTag: types.DestinationTag(1), + } - flattenedTx = coldToHotPayment.Flatten() - err = client.Autofill(&flattenedTx) - if err != nil { - fmt.Printf("❌ Error autofilling transaction: %s\n", err) - return - } + flattenedTx = coldToHotPayment.Flatten() + err = client.Autofill(&flattenedTx) + if err != nil { + 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) - return - } + txBlob, _, err = coldWallet.Sign(flattenedTx) + if err != nil { + 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) - return - } + response, err = client.SubmitTxBlobAndWait(txBlob, false) + if err != nil { + 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("Try again!") - fmt.Println() - return - } + if !response.Validated { + 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() + 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...") + // + // Claw back tokens from customer one + // + fmt.Println("⏳ Clawing back tokens from hot wallet...") - coldWalletClawback := &transactions.Clawback{ - BaseTx: transactions.BaseTx{ - Account: types.Address(coldWallet.ClassicAddress), - }, - Amount: types.IssuedCurrencyAmount{ - Currency: currencyCode, - Issuer: types.Address(hotWallet.ClassicAddress), - Value: "50", - }, - } + coldWalletClawback := &transactions.Clawback{ + BaseTx: transactions.BaseTx{ + Account: types.Address(coldWallet.ClassicAddress), + }, + Amount: types.IssuedCurrencyAmount{ + Currency: currencyCode, + Issuer: types.Address(hotWallet.ClassicAddress), + Value: "50", + }, + } - flattenedTx = coldWalletClawback.Flatten() - err = client.Autofill(&flattenedTx) - if err != nil { - fmt.Printf("❌ Error autofilling transaction: %s\n", err) - return - } + flattenedTx = coldWalletClawback.Flatten() + err = client.Autofill(&flattenedTx) + if err != nil { + 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) - return - } + txBlob, _, err = coldWallet.Sign(flattenedTx) + if err != nil { + 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) - return - } + response, err = client.SubmitTxBlobAndWait(txBlob, false) + if err != nil { + fmt.Printf("❌ Error submitting transaction: %s\n", err) + return + } - if !response.Validated { - fmt.Println("❌ Tokens not clawed back from customer one!") - fmt.Println("Try again!") - return - } + if !response.Validated { + 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() + fmt.Println("✅ Tokens clawed back from customer one!") + fmt.Printf("🌐 Hash: %s\n", response.Hash.String()) + fmt.Println() } diff --git a/_code-samples/credential/go/rpc/main.go b/_code-samples/credential/go/rpc/main.go index ab3bf1a1d0..55834d6fee 100644 --- a/_code-samples/credential/go/rpc/main.go +++ b/_code-samples/credential/go/rpc/main.go @@ -1,109 +1,109 @@ 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() { - // As of February 2025, Credential is only available on Devnet. - client := clients.GetDevnetRpcClient() + // As of February 2025, Credential is only available on Devnet. + client := clients.GetDevnetRpcClient() - // Configure wallets + // Configure wallets - // Issuer - 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) - return - } + // Issuer + 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) + return + } - err = client.FundWallet(&issuer) - if err != nil { - fmt.Printf("❌ Error funding issuer wallet: %s\n", err) - return - } - fmt.Printf("✅ Issuer wallet funded: %s\n", issuer.ClassicAddress) + err = client.FundWallet(&issuer) + if err != nil { + fmt.Printf("❌ Error funding issuer wallet: %s\n", err) + return + } + fmt.Printf("✅ Issuer wallet funded: %s\n", issuer.ClassicAddress) - // ----------------------------------------------------- + // ----------------------------------------------------- - // Subject (destination) - fmt.Println("⏳ Setting up Subject wallet...") - subjectWallet, err := wallet.New(crypto.ED25519()) - if err != nil { - fmt.Printf("❌ Error creating subject wallet: %s\n", err) - return - } + // Subject (destination) + fmt.Println("⏳ Setting up Subject wallet...") + subjectWallet, err := wallet.New(crypto.ED25519()) + if err != nil { + 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) - return - } - fmt.Printf("✅ Subject wallet funded: %s\n", subjectWallet.ClassicAddress) + err = client.FundWallet(&subjectWallet) + if err != nil { + fmt.Printf("❌ Error funding subject wallet: %s\n", err) + return + } + fmt.Printf("✅ Subject wallet funded: %s\n", subjectWallet.ClassicAddress) - // ----------------------------------------------------- + // ----------------------------------------------------- - // Creating the CredentialCreate transaction - fmt.Println("⏳ Creating CredentialCreate transaction...") + // Creating the CredentialCreate transaction + fmt.Println("⏳ Creating CredentialCreate transaction...") - expiration, err := rippleTime.IsoTimeToRippleTime(time.Now().Add(time.Hour * 24).Format(time.RFC3339)) - credentialType := types.CredentialType("6D795F63726564656E7469616C") + 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) - return - } + if err != nil { + fmt.Printf("❌ Error converting expiration to ripple time: %s\n", err) + return + } - txn := &transaction.CredentialCreate{ - BaseTx: transaction.BaseTx{ - Account: types.Address(issuer.ClassicAddress), - }, - CredentialType: credentialType, - Subject: types.Address(subjectWallet.ClassicAddress), - Expiration: uint32(expiration), - URI: hex.EncodeToString([]byte("https://example.com")), - } + txn := &transaction.CredentialCreate{ + BaseTx: transaction.BaseTx{ + Account: types.Address(issuer.ClassicAddress), + }, + CredentialType: credentialType, + Subject: types.Address(subjectWallet.ClassicAddress), + Expiration: uint32(expiration), + URI: hex.EncodeToString([]byte("https://example.com")), + } - clients.SubmitTxBlobAndWait(client, txn, issuer) + clients.SubmitTxBlobAndWait(client, txn, issuer) - // ----------------------------------------------------- + // ----------------------------------------------------- - // Creating the CredentialAccept transaction - fmt.Println("⏳ Creating CredentialAccept transaction...") + // Creating the CredentialAccept transaction + fmt.Println("⏳ Creating CredentialAccept transaction...") - acceptTxn := &transaction.CredentialAccept{ - BaseTx: transaction.BaseTx{ - Account: types.Address(subjectWallet.ClassicAddress), - }, - CredentialType: credentialType, - Issuer: types.Address(issuer.ClassicAddress), - } + acceptTxn := &transaction.CredentialAccept{ + BaseTx: transaction.BaseTx{ + Account: types.Address(subjectWallet.ClassicAddress), + }, + CredentialType: credentialType, + Issuer: types.Address(issuer.ClassicAddress), + } - clients.SubmitTxBlobAndWait(client, acceptTxn, subjectWallet) + clients.SubmitTxBlobAndWait(client, acceptTxn, subjectWallet) - // ----------------------------------------------------- + // ----------------------------------------------------- - // Creating the CredentialDelete transaction - fmt.Println("⏳ Creating CredentialDelete transaction...") + // Creating the CredentialDelete transaction + fmt.Println("⏳ Creating CredentialDelete transaction...") - deleteTxn := &transaction.CredentialDelete{ - BaseTx: transaction.BaseTx{ - Account: types.Address(issuer.ClassicAddress), - }, - CredentialType: credentialType, - Issuer: types.Address(issuer.ClassicAddress), - Subject: types.Address(subjectWallet.ClassicAddress), - } + deleteTxn := &transaction.CredentialDelete{ + BaseTx: transaction.BaseTx{ + Account: types.Address(issuer.ClassicAddress), + }, + CredentialType: credentialType, + Issuer: types.Address(issuer.ClassicAddress), + Subject: types.Address(subjectWallet.ClassicAddress), + } - clients.SubmitTxBlobAndWait(client, deleteTxn, issuer) + clients.SubmitTxBlobAndWait(client, deleteTxn, issuer) } diff --git a/_code-samples/credential/go/ws/main.go b/_code-samples/credential/go/ws/main.go index 3fd7eabce9..3f2153e27b 100644 --- a/_code-samples/credential/go/ws/main.go +++ b/_code-samples/credential/go/ws/main.go @@ -1,122 +1,122 @@ 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...") - if err := client.Connect(); err != nil { - fmt.Println(err) - return - } + client := clients.GetDevnetWebsocketClient() + fmt.Println("Connecting to server...") + if err := client.Connect(); err != nil { + fmt.Println(err) + return + } - fmt.Println("✅ Client configured!") - fmt.Println() + fmt.Println("✅ Client configured!") + fmt.Println() - fmt.Printf("Connection: %t", client.IsConnected()) - fmt.Println() + fmt.Printf("Connection: %t", client.IsConnected()) + fmt.Println() - // Configure wallets + // Configure wallets - // Issuer - 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) - return - } + // Issuer + 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) + return + } - err = client.FundWallet(&issuer) - if err != nil { - fmt.Printf("❌ Error funding issuer wallet: %s\n", err) - return - } - fmt.Printf("✅ Issuer wallet funded: %s\n", issuer.ClassicAddress) + err = client.FundWallet(&issuer) + if err != nil { + fmt.Printf("❌ Error funding issuer wallet: %s\n", err) + return + } + fmt.Printf("✅ Issuer wallet funded: %s\n", issuer.ClassicAddress) - // ----------------------------------------------------- + // ----------------------------------------------------- - // Subject (destination) - fmt.Println("⏳ Setting up Subject wallet...") - subjectWallet, err := wallet.New(crypto.ED25519()) - if err != nil { - fmt.Printf("❌ Error creating subject wallet: %s\n", err) - return - } + // Subject (destination) + fmt.Println("⏳ Setting up Subject wallet...") + subjectWallet, err := wallet.New(crypto.ED25519()) + if err != nil { + 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) - return - } - fmt.Printf("✅ Subject wallet funded: %s\n", subjectWallet.ClassicAddress) + err = client.FundWallet(&subjectWallet) + if err != nil { + fmt.Printf("❌ Error funding subject wallet: %s\n", err) + return + } + fmt.Printf("✅ Subject wallet funded: %s\n", subjectWallet.ClassicAddress) - // ----------------------------------------------------- + // ----------------------------------------------------- - // Creating the CredentialCreate transaction - fmt.Println("⏳ Creating CredentialCreate transaction...") + // Creating the CredentialCreate transaction + fmt.Println("⏳ Creating CredentialCreate transaction...") - expiration, err := rippleTime.IsoTimeToRippleTime(time.Now().Add(time.Hour * 24).Format(time.RFC3339)) - credentialType := types.CredentialType("6D795F63726564656E7469616C") + 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) - return - } + if err != nil { + fmt.Printf("❌ Error converting expiration to ripple time: %s\n", err) + return + } - txn := &transaction.CredentialCreate{ - BaseTx: transaction.BaseTx{ - Account: types.Address(issuer.ClassicAddress), - }, - CredentialType: credentialType, - Subject: types.Address(subjectWallet.ClassicAddress), - Expiration: uint32(expiration), - URI: hex.EncodeToString([]byte("https://example.com")), - } + txn := &transaction.CredentialCreate{ + BaseTx: transaction.BaseTx{ + Account: types.Address(issuer.ClassicAddress), + }, + CredentialType: credentialType, + Subject: types.Address(subjectWallet.ClassicAddress), + Expiration: uint32(expiration), + URI: hex.EncodeToString([]byte("https://example.com")), + } - clients.SubmitTxBlobAndWait(client, txn, issuer) + clients.SubmitTxBlobAndWait(client, txn, issuer) - // ----------------------------------------------------- + // ----------------------------------------------------- - // Creating the CredentialAccept transaction - fmt.Println("⏳ Creating CredentialAccept transaction...") + // Creating the CredentialAccept transaction + fmt.Println("⏳ Creating CredentialAccept transaction...") - acceptTxn := &transaction.CredentialAccept{ - BaseTx: transaction.BaseTx{ - Account: types.Address(subjectWallet.ClassicAddress), - }, - CredentialType: credentialType, - Issuer: types.Address(issuer.ClassicAddress), - } + acceptTxn := &transaction.CredentialAccept{ + BaseTx: transaction.BaseTx{ + Account: types.Address(subjectWallet.ClassicAddress), + }, + CredentialType: credentialType, + Issuer: types.Address(issuer.ClassicAddress), + } - clients.SubmitTxBlobAndWait(client, acceptTxn, subjectWallet) + clients.SubmitTxBlobAndWait(client, acceptTxn, subjectWallet) - // ----------------------------------------------------- + // ----------------------------------------------------- - // Creating the CredentialDelete transaction - fmt.Println("⏳ Creating CredentialDelete transaction...") + // Creating the CredentialDelete transaction + fmt.Println("⏳ Creating CredentialDelete transaction...") - deleteTxn := &transaction.CredentialDelete{ - BaseTx: transaction.BaseTx{ - Account: types.Address(issuer.ClassicAddress), - }, - CredentialType: credentialType, - Issuer: types.Address(issuer.ClassicAddress), - Subject: types.Address(subjectWallet.ClassicAddress), - } + deleteTxn := &transaction.CredentialDelete{ + BaseTx: transaction.BaseTx{ + Account: types.Address(issuer.ClassicAddress), + }, + CredentialType: credentialType, + Issuer: types.Address(issuer.ClassicAddress), + Subject: types.Address(subjectWallet.ClassicAddress), + } - clients.SubmitTxBlobAndWait(client, deleteTxn, issuer) + clients.SubmitTxBlobAndWait(client, deleteTxn, issuer) } diff --git a/_code-samples/delegate-set/go/rpc/main.go b/_code-samples/delegate-set/go/rpc/main.go index 4bc070f0bc..fa8ccea8a0 100644 --- a/_code-samples/delegate-set/go/rpc/main.go +++ b/_code-samples/delegate-set/go/rpc/main.go @@ -1,131 +1,131 @@ 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() { - // Configure the client - cfg, err := rpc.NewClientConfig( - "https://s.devnet.rippletest.net:51234/", - rpc.WithFaucetProvider(faucet.NewDevnetFaucetProvider()), - ) - if err != nil { - panic(err) - } - client := rpc.NewClient(cfg) + // Configure the client + cfg, err := rpc.NewClientConfig( + "https://s.devnet.rippletest.net:51234/", + rpc.WithFaucetProvider(faucet.NewDevnetFaucetProvider()), + ) + if err != nil { + panic(err) + } + client := rpc.NewClient(cfg) - // Create and fund wallets - delegatorWallet, err := wallet.New(crypto.ED25519()) - if err != nil { - fmt.Println(err) - return - } + // Create and fund wallets + delegatorWallet, err := wallet.New(crypto.ED25519()) + if err != nil { + fmt.Println(err) + return + } - delegateeWallet, err := wallet.New(crypto.ED25519()) - if err != nil { - fmt.Println(err) - return - } + delegateeWallet, err := wallet.New(crypto.ED25519()) + if err != nil { + fmt.Println(err) + return + } - fmt.Println("⏳ Funding wallets...") - if err := client.FundWallet(&delegatorWallet); err != nil { - fmt.Println(err) - return - } - if err := client.FundWallet(&delegateeWallet); err != nil { - fmt.Println(err) - return - } - fmt.Println("💸 Wallets funded") + fmt.Println("⏳ Funding wallets...") + if err := client.FundWallet(&delegatorWallet); err != nil { + fmt.Println(err) + return + } + if err := client.FundWallet(&delegateeWallet); err != nil { + fmt.Println(err) + return + } + fmt.Println("💸 Wallets funded") - // Check initial balances - delegatorBalance, err := client.GetXrpBalance(delegatorWallet.ClassicAddress) - if err != nil { - delegatorBalance = "0" - } - delegateeBalance, err := client.GetXrpBalance(delegateeWallet.ClassicAddress) - if err != nil { - delegateeBalance = "0" - } + // Check initial balances + delegatorBalance, err := client.GetXrpBalance(delegatorWallet.ClassicAddress) + if err != nil { + delegatorBalance = "0" + } + delegateeBalance, err := client.GetXrpBalance(delegateeWallet.ClassicAddress) + if err != nil { + delegateeBalance = "0" + } - fmt.Printf("💳 Delegator initial balance: %s XRP\n", delegatorBalance) - fmt.Printf("💳 Delegatee initial balance: %s XRP\n", delegateeBalance) - fmt.Println() + fmt.Printf("💳 Delegator initial balance: %s XRP\n", delegatorBalance) + fmt.Printf("💳 Delegatee initial balance: %s XRP\n", delegateeBalance) + fmt.Println() - // Create DelegateSet transaction - delegateSetTx := &transactions.DelegateSet{ - BaseTx: transactions.BaseTx{ - Account: txnTypes.Address(delegatorWallet.ClassicAddress), - }, - Authorize: txnTypes.Address(delegateeWallet.ClassicAddress), - Permissions: []txnTypes.Permission{ - { - Permission: txnTypes.PermissionValue{ - PermissionValue: "Payment", - }, - }, - }, - } + // Create DelegateSet transaction + delegateSetTx := &transactions.DelegateSet{ + BaseTx: transactions.BaseTx{ + Account: txnTypes.Address(delegatorWallet.ClassicAddress), + }, + Authorize: txnTypes.Address(delegateeWallet.ClassicAddress), + Permissions: []txnTypes.Permission{ + { + Permission: txnTypes.PermissionValue{ + PermissionValue: "Payment", + }, + }, + }, + } - // Submit DelegateSet transaction - response, err := client.SubmitTxAndWait(delegateSetTx.Flatten(), &types.SubmitOptions{ - Autofill: true, - Wallet: &delegatorWallet, - }) - if err != nil { - fmt.Println(err) - return - } + // Submit DelegateSet transaction + response, err := client.SubmitTxAndWait(delegateSetTx.Flatten(), &types.SubmitOptions{ + Autofill: true, + Wallet: &delegatorWallet, + }) + if err != nil { + fmt.Println(err) + return + } - fmt.Println("✅ DelegateSet transaction submitted") - fmt.Printf("🌐 Hash: %s\n", response.Hash) - fmt.Printf("🌐 Validated: %t\n", response.Validated) - fmt.Println() + 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 - delegatedPaymentTx := &transactions.Payment{ - BaseTx: transactions.BaseTx{ - Account: txnTypes.Address(delegatorWallet.ClassicAddress), - Delegate: txnTypes.Address(delegateeWallet.ClassicAddress), - }, - Destination: txnTypes.Address(delegateeWallet.ClassicAddress), - Amount: txnTypes.XRPCurrencyAmount(1000000), // 1 XRP - } + // Create delegated payment transaction + delegatedPaymentTx := &transactions.Payment{ + BaseTx: transactions.BaseTx{ + Account: txnTypes.Address(delegatorWallet.ClassicAddress), + Delegate: txnTypes.Address(delegateeWallet.ClassicAddress), + }, + Destination: txnTypes.Address(delegateeWallet.ClassicAddress), + Amount: txnTypes.XRPCurrencyAmount(1000000), // 1 XRP + } - // Submit delegated payment - response2, err := client.SubmitTxAndWait(delegatedPaymentTx.Flatten(), &types.SubmitOptions{ - Autofill: true, - Wallet: &delegateeWallet, - }) - if err != nil { - fmt.Println(err) - return - } + // Submit delegated payment + response2, err := client.SubmitTxAndWait(delegatedPaymentTx.Flatten(), &types.SubmitOptions{ + Autofill: true, + Wallet: &delegateeWallet, + }) + if err != nil { + fmt.Println(err) + return + } - fmt.Println("✅ Delegated payment submitted") - fmt.Printf("🌐 Hash: %s\n", response2.Hash) - fmt.Printf("🌐 Validated: %t\n", response2.Validated) - fmt.Println() + fmt.Println("✅ Delegated payment submitted") + fmt.Printf("🌐 Hash: %s\n", response2.Hash) + fmt.Printf("🌐 Validated: %t\n", response2.Validated) + fmt.Println() - // Check final balances - finalDelegatorBalance, err := client.GetXrpBalance(delegatorWallet.ClassicAddress) - if err != nil { - finalDelegatorBalance = "0" - } - finalDelegateeBalance, err := client.GetXrpBalance(delegateeWallet.ClassicAddress) - if err != nil { - finalDelegateeBalance = "0" - } + // Check final balances + finalDelegatorBalance, err := client.GetXrpBalance(delegatorWallet.ClassicAddress) + if err != nil { + finalDelegatorBalance = "0" + } + finalDelegateeBalance, err := client.GetXrpBalance(delegateeWallet.ClassicAddress) + if err != nil { + 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) } diff --git a/_code-samples/delegate-set/go/ws/main.go b/_code-samples/delegate-set/go/ws/main.go index 7aac89cc56..b0a8e88b14 100644 --- a/_code-samples/delegate-set/go/ws/main.go +++ b/_code-samples/delegate-set/go/ws/main.go @@ -1,151 +1,151 @@ 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() { - // Connect to testnet - client := websocket.NewClient( - websocket.NewClientConfig(). - WithHost("wss://s.devnet.rippletest.net:51233"). - WithFaucetProvider(faucet.NewDevnetFaucetProvider()), - ) - defer client.Disconnect() + // Connect to testnet + client := websocket.NewClient( + websocket.NewClientConfig(). + WithHost("wss://s.devnet.rippletest.net:51233"). + WithFaucetProvider(faucet.NewDevnetFaucetProvider()), + ) + defer client.Disconnect() - if err := client.Connect(); err != nil { - fmt.Println(err) - return - } + if err := client.Connect(); err != nil { + fmt.Println(err) + return + } - // Create and fund wallets - delegatorWallet, err := wallet.New(crypto.ED25519()) - if err != nil { - fmt.Println(err) - return - } + // Create and fund wallets + delegatorWallet, err := wallet.New(crypto.ED25519()) + if err != nil { + fmt.Println(err) + return + } - delegateeWallet, err := wallet.New(crypto.ED25519()) - if err != nil { - fmt.Println(err) - return - } + delegateeWallet, err := wallet.New(crypto.ED25519()) + if err != nil { + fmt.Println(err) + return + } - fmt.Println("⏳ Funding wallets...") - if err := client.FundWallet(&delegatorWallet); err != nil { - fmt.Println(err) - return - } - if err := client.FundWallet(&delegateeWallet); err != nil { - fmt.Println(err) - return - } - fmt.Println("💸 Wallets funded") + fmt.Println("⏳ Funding wallets...") + if err := client.FundWallet(&delegatorWallet); err != nil { + fmt.Println(err) + return + } + if err := client.FundWallet(&delegateeWallet); err != nil { + fmt.Println(err) + return + } + fmt.Println("💸 Wallets funded") - // Check initial balances - delegatorBalance, err := client.GetXrpBalance(delegatorWallet.ClassicAddress) - if err != nil { - delegatorBalance = "0" - } - delegateeBalance, err := client.GetXrpBalance(delegateeWallet.ClassicAddress) - if err != nil { - delegateeBalance = "0" - } + // Check initial balances + delegatorBalance, err := client.GetXrpBalance(delegatorWallet.ClassicAddress) + if err != nil { + delegatorBalance = "0" + } + delegateeBalance, err := client.GetXrpBalance(delegateeWallet.ClassicAddress) + if err != nil { + delegateeBalance = "0" + } - fmt.Printf("💳 Delegator initial balance: %s XRP\n", delegatorBalance) - fmt.Printf("💳 Delegatee initial balance: %s XRP\n", delegateeBalance) - fmt.Println() + fmt.Printf("💳 Delegator initial balance: %s XRP\n", delegatorBalance) + fmt.Printf("💳 Delegatee initial balance: %s XRP\n", delegateeBalance) + fmt.Println() - // Create DelegateSet transaction - delegateSetTx := &transactions.DelegateSet{ - BaseTx: transactions.BaseTx{ - Account: types.Address(delegatorWallet.ClassicAddress), - }, - Authorize: types.Address(delegateeWallet.ClassicAddress), - Permissions: []types.Permission{ - { - Permission: types.PermissionValue{ - PermissionValue: "Payment", - }, - }, - }, - } + // Create DelegateSet transaction + delegateSetTx := &transactions.DelegateSet{ + BaseTx: transactions.BaseTx{ + Account: types.Address(delegatorWallet.ClassicAddress), + }, + Authorize: types.Address(delegateeWallet.ClassicAddress), + Permissions: []types.Permission{ + { + Permission: types.PermissionValue{ + PermissionValue: "Payment", + }, + }, + }, + } - // Submit DelegateSet transaction - flattenedTx := delegateSetTx.Flatten() - if err := client.Autofill(&flattenedTx); err != nil { - fmt.Println(err) - return - } + // Submit DelegateSet transaction + flattenedTx := delegateSetTx.Flatten() + if err := client.Autofill(&flattenedTx); err != nil { + fmt.Println(err) + return + } - txBlob, _, err := delegatorWallet.Sign(flattenedTx) - if err != nil { - fmt.Println(err) - return - } + txBlob, _, err := delegatorWallet.Sign(flattenedTx) + if err != nil { + fmt.Println(err) + return + } - response, err := client.SubmitTxBlobAndWait(txBlob, false) - if err != nil { - fmt.Println(err) - return - } + response, err := client.SubmitTxBlobAndWait(txBlob, false) + if err != nil { + fmt.Println(err) + return + } - fmt.Println("✅ DelegateSet transaction submitted") - fmt.Printf("🌐 Hash: %s\n", response.Hash) - fmt.Printf("🌐 Validated: %t\n", response.Validated) - fmt.Println() + 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 - delegatedPaymentTx := &transactions.Payment{ - BaseTx: transactions.BaseTx{ - Account: types.Address(delegatorWallet.ClassicAddress), - Delegate: types.Address(delegateeWallet.ClassicAddress), - }, - Destination: types.Address(delegateeWallet.ClassicAddress), - Amount: types.XRPCurrencyAmount(1000000), // 1 XRP - } + // Create delegated payment transaction + delegatedPaymentTx := &transactions.Payment{ + BaseTx: transactions.BaseTx{ + Account: types.Address(delegatorWallet.ClassicAddress), + Delegate: types.Address(delegateeWallet.ClassicAddress), + }, + Destination: types.Address(delegateeWallet.ClassicAddress), + Amount: types.XRPCurrencyAmount(1000000), // 1 XRP + } - // Submit delegated payment - flatDelegatedPayment := delegatedPaymentTx.Flatten() - if err := client.Autofill(&flatDelegatedPayment); err != nil { - fmt.Println(err) - return - } + // Submit delegated payment + flatDelegatedPayment := delegatedPaymentTx.Flatten() + if err := client.Autofill(&flatDelegatedPayment); err != nil { + fmt.Println(err) + return + } - txBlob2, _, err := delegateeWallet.Sign(flatDelegatedPayment) - if err != nil { - fmt.Println(err) - return - } + txBlob2, _, err := delegateeWallet.Sign(flatDelegatedPayment) + if err != nil { + fmt.Println(err) + return + } - response2, err := client.SubmitTxBlobAndWait(txBlob2, false) - if err != nil { - fmt.Println(err) - return - } + response2, err := client.SubmitTxBlobAndWait(txBlob2, false) + if err != nil { + fmt.Println(err) + return + } - fmt.Println("✅ Delegated payment submitted") - fmt.Printf("🌐 Hash: %s\n", response2.Hash) - fmt.Printf("🌐 Validated: %t\n", response2.Validated) - fmt.Println() + fmt.Println("✅ Delegated payment submitted") + fmt.Printf("🌐 Hash: %s\n", response2.Hash) + fmt.Printf("🌐 Validated: %t\n", response2.Validated) + fmt.Println() - // Check final balances - finalDelegatorBalance, err := client.GetXrpBalance(delegatorWallet.ClassicAddress) - if err != nil { - finalDelegatorBalance = "0" - } - finalDelegateeBalance, err := client.GetXrpBalance(delegateeWallet.ClassicAddress) - if err != nil { - finalDelegateeBalance = "0" - } + // Check final balances + finalDelegatorBalance, err := client.GetXrpBalance(delegatorWallet.ClassicAddress) + if err != nil { + finalDelegatorBalance = "0" + } + finalDelegateeBalance, err := client.GetXrpBalance(delegateeWallet.ClassicAddress) + if err != nil { + 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) } diff --git a/_code-samples/deposit-preauth/go/rpc/main.go b/_code-samples/deposit-preauth/go/rpc/main.go index 1280390928..e6e38c3640 100644 --- a/_code-samples/deposit-preauth/go/rpc/main.go +++ b/_code-samples/deposit-preauth/go/rpc/main.go @@ -1,220 +1,220 @@ 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() { - client := clients.GetDevnetRpcClient() + client := clients.GetDevnetRpcClient() - // Configure wallets + // Configure wallets - // Issuer - 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) - return - } + // Issuer + 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) + return + } - err = client.FundWallet(&issuer) - if err != nil { - fmt.Printf("❌ Error funding credential issuer wallet: %s\n", err) - return - } - fmt.Printf("✅ Credential issuer wallet funded: %s\n", issuer.ClassicAddress) + err = client.FundWallet(&issuer) + if err != nil { + fmt.Printf("❌ Error funding credential issuer wallet: %s\n", err) + return + } + fmt.Printf("✅ Credential issuer wallet funded: %s\n", issuer.ClassicAddress) - // ----------------------------------------------------- + // ----------------------------------------------------- - // Holder 1 - 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) - return - } + // Holder 1 + 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) + return + } - err = client.FundWallet(&holderWallet1) - if err != nil { - fmt.Printf("❌ Error funding holder 1 wallet: %s\n", err) - return - } - fmt.Printf("✅ Holder 1 wallet funded: %s\n", holderWallet1.ClassicAddress) + err = client.FundWallet(&holderWallet1) + if err != nil { + fmt.Printf("❌ Error funding holder 1 wallet: %s\n", err) + return + } + 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...") - accountSetTx := &transaction.AccountSet{ - BaseTx: transaction.BaseTx{ - Account: issuer.ClassicAddress, - TransactionType: transaction.AccountSetTx, - }, - } - accountSetTx.SetAsfDepositAuth() + // Enabling DepositAuth on the issuer account with an AccountSet transaction + fmt.Println("⏳ Enabling DepositAuth on the issuer account...") + accountSetTx := &transaction.AccountSet{ + BaseTx: transaction.BaseTx{ + Account: issuer.ClassicAddress, + TransactionType: transaction.AccountSetTx, + }, + } + accountSetTx.SetAsfDepositAuth() - clients.SubmitTxBlobAndWait(client, accountSetTx, issuer) + clients.SubmitTxBlobAndWait(client, accountSetTx, issuer) - // ----------------------------------------------------- + // ----------------------------------------------------- - // Creating the CredentialCreate transaction - fmt.Println("⏳ Creating the CredentialCreate transaction...") + // 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) - return - } - credentialType := types.CredentialType("6D795F63726564656E7469616C") // my_credential + 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) + return + } + credentialType := types.CredentialType("6D795F63726564656E7469616C") // my_credential - credentialCreateTx := &transaction.CredentialCreate{ - BaseTx: transaction.BaseTx{ - Account: issuer.ClassicAddress, - TransactionType: transaction.CredentialCreateTx, - }, - Expiration: uint32(expiration), - CredentialType: credentialType, - Subject: types.Address(holderWallet1.ClassicAddress), - URI: hex.EncodeToString([]byte("https://example.com")), - } + credentialCreateTx := &transaction.CredentialCreate{ + BaseTx: transaction.BaseTx{ + Account: issuer.ClassicAddress, + TransactionType: transaction.CredentialCreateTx, + }, + Expiration: uint32(expiration), + CredentialType: credentialType, + Subject: types.Address(holderWallet1.ClassicAddress), + URI: hex.EncodeToString([]byte("https://example.com")), + } - clients.SubmitTxBlobAndWait(client, credentialCreateTx, issuer) + clients.SubmitTxBlobAndWait(client, credentialCreateTx, issuer) - // ----------------------------------------------------- + // ----------------------------------------------------- - // Creating the CredentialAccept transaction - fmt.Println("⏳ Creating the CredentialAccept transaction...") + // Creating the CredentialAccept transaction + fmt.Println("⏳ Creating the CredentialAccept transaction...") - credentialAcceptTx := &transaction.CredentialAccept{ - BaseTx: transaction.BaseTx{ - Account: holderWallet1.ClassicAddress, - TransactionType: transaction.CredentialAcceptTx, - }, - CredentialType: credentialType, - Issuer: types.Address(issuer.ClassicAddress), - } + credentialAcceptTx := &transaction.CredentialAccept{ + BaseTx: transaction.BaseTx{ + Account: holderWallet1.ClassicAddress, + TransactionType: transaction.CredentialAcceptTx, + }, + CredentialType: credentialType, + Issuer: types.Address(issuer.ClassicAddress), + } - clients.SubmitTxBlobAndWait(client, credentialAcceptTx, holderWallet1) + clients.SubmitTxBlobAndWait(client, credentialAcceptTx, holderWallet1) - // ----------------------------------------------------- + // ----------------------------------------------------- - // Creating the DepositPreauth transaction - fmt.Println("⏳ Creating the DepositPreauth transaction using AuthorizeCredentials...") + // Creating the DepositPreauth transaction + fmt.Println("⏳ Creating the DepositPreauth transaction using AuthorizeCredentials...") - depositPreauthTx := &transaction.DepositPreauth{ - BaseTx: transaction.BaseTx{ - Account: issuer.ClassicAddress, - TransactionType: transaction.DepositPreauthTx, - }, - AuthorizeCredentials: []types.AuthorizeCredentialsWrapper{ - { - Credential: types.AuthorizeCredentials{ - Issuer: issuer.ClassicAddress, - CredentialType: credentialType, - }, - }, - }, - } + depositPreauthTx := &transaction.DepositPreauth{ + BaseTx: transaction.BaseTx{ + Account: issuer.ClassicAddress, + TransactionType: transaction.DepositPreauthTx, + }, + AuthorizeCredentials: []types.AuthorizeCredentialsWrapper{ + { + Credential: types.AuthorizeCredentials{ + Issuer: issuer.ClassicAddress, + CredentialType: credentialType, + }, + }, + }, + } - clients.SubmitTxBlobAndWait(client, depositPreauthTx, issuer) + clients.SubmitTxBlobAndWait(client, depositPreauthTx, issuer) - // ----------------------------------------------------- + // ----------------------------------------------------- - // Get the credential ID - fmt.Println("⏳ Getting the credential ID from the holder 1 account...") + // Get the credential ID + fmt.Println("⏳ Getting the credential ID from the holder 1 account...") - objectsRequest := &account.ObjectsRequest{ - Account: holderWallet1.ClassicAddress, - Type: account.CredentialObject, - LedgerIndex: common.Validated, - } + objectsRequest := &account.ObjectsRequest{ + Account: holderWallet1.ClassicAddress, + Type: account.CredentialObject, + LedgerIndex: common.Validated, + } - objectsResponse, err := client.GetAccountObjects(objectsRequest) - if err != nil { - fmt.Printf("❌ Error getting the credential ID: %s\n", err) - return - } + objectsResponse, err := client.GetAccountObjects(objectsRequest) + if err != nil { + 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") - return - } + // Check if we have any credential objects + if len(objectsResponse.AccountObjects) == 0 { + 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") - return - } + // Extract the credential ID + credentialID, ok := objectsResponse.AccountObjects[0]["index"].(string) + if !ok { + fmt.Println("❌ Could not extract credential ID from response") + return + } - fmt.Printf("✅ Credential ID: %s\n", credentialID) - fmt.Println() + 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...") + // Sending XRP to the holder 1 account + fmt.Println("⏳ Sending XRP to the issuer account, should succeed...") - sendTx := &transaction.Payment{ - BaseTx: transaction.BaseTx{ - Account: holderWallet1.ClassicAddress, - TransactionType: transaction.PaymentTx, - }, - Amount: types.XRPCurrencyAmount(1000000), - Destination: issuer.ClassicAddress, - CredentialIDs: types.CredentialIDs{credentialID}, - } + sendTx := &transaction.Payment{ + BaseTx: transaction.BaseTx{ + Account: holderWallet1.ClassicAddress, + TransactionType: transaction.PaymentTx, + }, + Amount: types.XRPCurrencyAmount(1000000), + Destination: issuer.ClassicAddress, + CredentialIDs: types.CredentialIDs{credentialID}, + } - clients.SubmitTxBlobAndWait(client, sendTx, holderWallet1) + clients.SubmitTxBlobAndWait(client, sendTx, holderWallet1) - // ----------------------------------------------------- + // ----------------------------------------------------- - // Unauthorizing the holder 1 account - fmt.Println("⏳ Unauthorizing the holder 1 account with the DepositPreauth transaction and the UnauthorizeCredentials field...") + // Unauthorizing the holder 1 account + fmt.Println("⏳ Unauthorizing the holder 1 account with the DepositPreauth transaction and the UnauthorizeCredentials field...") - unauthorizeTx := &transaction.DepositPreauth{ - BaseTx: transaction.BaseTx{ - Account: issuer.ClassicAddress, - TransactionType: transaction.DepositPreauthTx, - }, - UnauthorizeCredentials: []types.AuthorizeCredentialsWrapper{ - { - Credential: types.AuthorizeCredentials{ - Issuer: issuer.ClassicAddress, - CredentialType: credentialType, - }, - }, - }, - } + unauthorizeTx := &transaction.DepositPreauth{ + BaseTx: transaction.BaseTx{ + Account: issuer.ClassicAddress, + TransactionType: transaction.DepositPreauthTx, + }, + UnauthorizeCredentials: []types.AuthorizeCredentialsWrapper{ + { + Credential: types.AuthorizeCredentials{ + Issuer: issuer.ClassicAddress, + CredentialType: credentialType, + }, + }, + }, + } - clients.SubmitTxBlobAndWait(client, unauthorizeTx, issuer) + clients.SubmitTxBlobAndWait(client, unauthorizeTx, issuer) - // ----------------------------------------------------- + // ----------------------------------------------------- - // Sending XRP to the holder 1 account again (which should fail) - fmt.Println("⏳ Sending XRP to the issuer account again (which should fail)...") + // Sending XRP to the holder 1 account again (which should fail) + fmt.Println("⏳ Sending XRP to the issuer account again (which should fail)...") - sendTx2 := &transaction.Payment{ - BaseTx: transaction.BaseTx{ - Account: holderWallet1.ClassicAddress, - TransactionType: transaction.PaymentTx, - }, - Amount: types.XRPCurrencyAmount(1000000), - Destination: issuer.ClassicAddress, - CredentialIDs: types.CredentialIDs{credentialID}, - } + sendTx2 := &transaction.Payment{ + BaseTx: transaction.BaseTx{ + Account: holderWallet1.ClassicAddress, + TransactionType: transaction.PaymentTx, + }, + Amount: types.XRPCurrencyAmount(1000000), + Destination: issuer.ClassicAddress, + CredentialIDs: types.CredentialIDs{credentialID}, + } - clients.SubmitTxBlobAndWait(client, sendTx2, holderWallet1) + clients.SubmitTxBlobAndWait(client, sendTx2, holderWallet1) } diff --git a/_code-samples/deposit-preauth/go/ws/main.go b/_code-samples/deposit-preauth/go/ws/main.go index 2d0a304ec3..89fb2f42f3 100644 --- a/_code-samples/deposit-preauth/go/ws/main.go +++ b/_code-samples/deposit-preauth/go/ws/main.go @@ -1,234 +1,234 @@ 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...") - if err := client.Connect(); err != nil { - fmt.Println(err) - return - } + client := clients.GetDevnetWebsocketClient() + fmt.Println("Connecting to server...") + if err := client.Connect(); err != nil { + fmt.Println(err) + return + } - fmt.Println("✅ Client configured!") - fmt.Println() + fmt.Println("✅ Client configured!") + fmt.Println() - fmt.Printf("Connection: %t", client.IsConnected()) - fmt.Println() + fmt.Printf("Connection: %t", client.IsConnected()) + fmt.Println() - // Configure wallets + // Configure wallets - // Issuer - 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) - return - } + // Issuer + 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) + return + } - err = client.FundWallet(&issuer) - if err != nil { - fmt.Printf("❌ Error funding credential issuer wallet: %s\n", err) - return - } - fmt.Printf("✅ Credential issuer wallet funded: %s\n", issuer.ClassicAddress) + err = client.FundWallet(&issuer) + if err != nil { + fmt.Printf("❌ Error funding credential issuer wallet: %s\n", err) + return + } + fmt.Printf("✅ Credential issuer wallet funded: %s\n", issuer.ClassicAddress) - // ----------------------------------------------------- + // ----------------------------------------------------- - // Holder 1 - 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) - return - } + // Holder 1 + 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) + return + } - err = client.FundWallet(&holderWallet1) - if err != nil { - fmt.Printf("❌ Error funding holder 1 wallet: %s\n", err) - return - } - fmt.Printf("✅ Holder 1 wallet funded: %s\n", holderWallet1.ClassicAddress) + err = client.FundWallet(&holderWallet1) + if err != nil { + fmt.Printf("❌ Error funding holder 1 wallet: %s\n", err) + return + } + 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...") - accountSetTx := &transaction.AccountSet{ - BaseTx: transaction.BaseTx{ - Account: issuer.ClassicAddress, - TransactionType: transaction.AccountSetTx, - }, - } - accountSetTx.SetAsfDepositAuth() + // Enabling DepositAuth on the issuer account with an AccountSet transaction + fmt.Println("⏳ Enabling DepositAuth on the issuer account...") + accountSetTx := &transaction.AccountSet{ + BaseTx: transaction.BaseTx{ + Account: issuer.ClassicAddress, + TransactionType: transaction.AccountSetTx, + }, + } + accountSetTx.SetAsfDepositAuth() - clients.SubmitTxBlobAndWait(client, accountSetTx, issuer) + clients.SubmitTxBlobAndWait(client, accountSetTx, issuer) - // ----------------------------------------------------- + // ----------------------------------------------------- - // Creating the CredentialCreate transaction - fmt.Println("⏳ Creating the CredentialCreate transaction...") + // 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) - return - } - credentialType := types.CredentialType("6D795F63726564656E7469616C") // my_credential + 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) + return + } + credentialType := types.CredentialType("6D795F63726564656E7469616C") // my_credential - credentialCreateTx := &transaction.CredentialCreate{ - BaseTx: transaction.BaseTx{ - Account: issuer.ClassicAddress, - TransactionType: transaction.CredentialCreateTx, - }, - Expiration: uint32(expiration), - CredentialType: credentialType, - Subject: types.Address(holderWallet1.ClassicAddress), - URI: hex.EncodeToString([]byte("https://example.com")), - } + credentialCreateTx := &transaction.CredentialCreate{ + BaseTx: transaction.BaseTx{ + Account: issuer.ClassicAddress, + TransactionType: transaction.CredentialCreateTx, + }, + Expiration: uint32(expiration), + CredentialType: credentialType, + Subject: types.Address(holderWallet1.ClassicAddress), + URI: hex.EncodeToString([]byte("https://example.com")), + } - clients.SubmitTxBlobAndWait(client, credentialCreateTx, issuer) + clients.SubmitTxBlobAndWait(client, credentialCreateTx, issuer) - // ----------------------------------------------------- + // ----------------------------------------------------- - // Creating the CredentialAccept transaction - fmt.Println("⏳ Creating the CredentialAccept transaction...") + // Creating the CredentialAccept transaction + fmt.Println("⏳ Creating the CredentialAccept transaction...") - credentialAcceptTx := &transaction.CredentialAccept{ - BaseTx: transaction.BaseTx{ - Account: holderWallet1.ClassicAddress, - TransactionType: transaction.CredentialAcceptTx, - }, - CredentialType: credentialType, - Issuer: types.Address(issuer.ClassicAddress), - } + credentialAcceptTx := &transaction.CredentialAccept{ + BaseTx: transaction.BaseTx{ + Account: holderWallet1.ClassicAddress, + TransactionType: transaction.CredentialAcceptTx, + }, + CredentialType: credentialType, + Issuer: types.Address(issuer.ClassicAddress), + } - clients.SubmitTxBlobAndWait(client, credentialAcceptTx, holderWallet1) + clients.SubmitTxBlobAndWait(client, credentialAcceptTx, holderWallet1) - // ----------------------------------------------------- + // ----------------------------------------------------- - // Creating the DepositPreauth transaction - fmt.Println("⏳ Creating the DepositPreauth transaction using AuthorizeCredentials...") + // Creating the DepositPreauth transaction + fmt.Println("⏳ Creating the DepositPreauth transaction using AuthorizeCredentials...") - depositPreauthTx := &transaction.DepositPreauth{ - BaseTx: transaction.BaseTx{ - Account: issuer.ClassicAddress, - TransactionType: transaction.DepositPreauthTx, - }, - AuthorizeCredentials: []types.AuthorizeCredentialsWrapper{ - { - Credential: types.AuthorizeCredentials{ - Issuer: issuer.ClassicAddress, - CredentialType: credentialType, - }, - }, - }, - } + depositPreauthTx := &transaction.DepositPreauth{ + BaseTx: transaction.BaseTx{ + Account: issuer.ClassicAddress, + TransactionType: transaction.DepositPreauthTx, + }, + AuthorizeCredentials: []types.AuthorizeCredentialsWrapper{ + { + Credential: types.AuthorizeCredentials{ + Issuer: issuer.ClassicAddress, + CredentialType: credentialType, + }, + }, + }, + } - clients.SubmitTxBlobAndWait(client, depositPreauthTx, issuer) + clients.SubmitTxBlobAndWait(client, depositPreauthTx, issuer) - // ----------------------------------------------------- + // ----------------------------------------------------- - // Get the credential ID - fmt.Println("⏳ Getting the credential ID from the holder 1 account...") + // Get the credential ID + fmt.Println("⏳ Getting the credential ID from the holder 1 account...") - objectsRequest := &account.ObjectsRequest{ - Account: holderWallet1.ClassicAddress, - Type: account.CredentialObject, - LedgerIndex: common.Validated, - } + objectsRequest := &account.ObjectsRequest{ + Account: holderWallet1.ClassicAddress, + Type: account.CredentialObject, + LedgerIndex: common.Validated, + } - objectsResponse, err := client.GetAccountObjects(objectsRequest) - if err != nil { - fmt.Printf("❌ Error getting the credential ID: %s\n", err) - return - } + objectsResponse, err := client.GetAccountObjects(objectsRequest) + if err != nil { + 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") - return - } + // Check if we have any credential objects + if len(objectsResponse.AccountObjects) == 0 { + 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") - return - } + // Extract the credential ID + credentialID, ok := objectsResponse.AccountObjects[0]["index"].(string) + if !ok { + fmt.Println("❌ Could not extract credential ID from response") + return + } - fmt.Printf("✅ Credential ID: %s\n", credentialID) - fmt.Println() + 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...") + // Sending XRP to the holder 1 account + fmt.Println("⏳ Sending XRP to the issuer account, should succeed...") - sendTx := &transaction.Payment{ - BaseTx: transaction.BaseTx{ - Account: holderWallet1.ClassicAddress, - TransactionType: transaction.PaymentTx, - }, - Amount: types.XRPCurrencyAmount(1000000), - Destination: issuer.ClassicAddress, - CredentialIDs: types.CredentialIDs{credentialID}, - } + sendTx := &transaction.Payment{ + BaseTx: transaction.BaseTx{ + Account: holderWallet1.ClassicAddress, + TransactionType: transaction.PaymentTx, + }, + Amount: types.XRPCurrencyAmount(1000000), + Destination: issuer.ClassicAddress, + CredentialIDs: types.CredentialIDs{credentialID}, + } - clients.SubmitTxBlobAndWait(client, sendTx, holderWallet1) + clients.SubmitTxBlobAndWait(client, sendTx, holderWallet1) - // ----------------------------------------------------- + // ----------------------------------------------------- - // Unauthorize the holder 1 account - fmt.Println("⏳ Unauthorize the holder 1 account with the DepositPreauth transaction and the UnauthorizeCredentials field...") + // Unauthorize the holder 1 account + fmt.Println("⏳ Unauthorize the holder 1 account with the DepositPreauth transaction and the UnauthorizeCredentials field...") - unauthorizeTx := &transaction.DepositPreauth{ - BaseTx: transaction.BaseTx{ - Account: issuer.ClassicAddress, - TransactionType: transaction.DepositPreauthTx, - }, - UnauthorizeCredentials: []types.AuthorizeCredentialsWrapper{ - { - Credential: types.AuthorizeCredentials{ - Issuer: issuer.ClassicAddress, - CredentialType: credentialType, - }, - }, - }, - } + unauthorizeTx := &transaction.DepositPreauth{ + BaseTx: transaction.BaseTx{ + Account: issuer.ClassicAddress, + TransactionType: transaction.DepositPreauthTx, + }, + UnauthorizeCredentials: []types.AuthorizeCredentialsWrapper{ + { + Credential: types.AuthorizeCredentials{ + Issuer: issuer.ClassicAddress, + CredentialType: credentialType, + }, + }, + }, + } - clients.SubmitTxBlobAndWait(client, unauthorizeTx, issuer) + clients.SubmitTxBlobAndWait(client, unauthorizeTx, issuer) - // ----------------------------------------------------- + // ----------------------------------------------------- - // Sending XRP to the holder 1 account again (which should fail) - fmt.Println("⏳ Sending XRP to the issuer account again (which should fail)...") + // Sending XRP to the holder 1 account again (which should fail) + fmt.Println("⏳ Sending XRP to the issuer account again (which should fail)...") - sendTx2 := &transaction.Payment{ - BaseTx: transaction.BaseTx{ - Account: holderWallet1.ClassicAddress, - TransactionType: transaction.PaymentTx, - }, - Amount: types.XRPCurrencyAmount(1000000), - Destination: issuer.ClassicAddress, - CredentialIDs: types.CredentialIDs{credentialID}, - } + sendTx2 := &transaction.Payment{ + BaseTx: transaction.BaseTx{ + Account: holderWallet1.ClassicAddress, + TransactionType: transaction.PaymentTx, + }, + Amount: types.XRPCurrencyAmount(1000000), + Destination: issuer.ClassicAddress, + CredentialIDs: types.CredentialIDs{credentialID}, + } - clients.SubmitTxBlobAndWait(client, sendTx2, holderWallet1) + clients.SubmitTxBlobAndWait(client, sendTx2, holderWallet1) } diff --git a/_code-samples/freeze/go/rpc/main.go b/_code-samples/freeze/go/rpc/main.go index e5a874cd75..9848e1d29f 100644 --- a/_code-samples/freeze/go/rpc/main.go +++ b/_code-samples/freeze/go/rpc/main.go @@ -1,347 +1,347 @@ 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 ( - currencyCode = "USDA" + currencyCode = "USDA" ) type SubmittableTransaction interface { - TxType() transactions.TxType - Flatten() transactions.FlatTransaction // Ensures all transactions can be flattened + TxType() transactions.TxType + Flatten() transactions.FlatTransaction // Ensures all transactions can be flattened } func main() { - client := getRpcClient() + client := getRpcClient() - // Configure wallets + // Configure wallets - // Issuer - fmt.Println("⏳ Setting up issuer wallet...") - issuer, err := wallet.New(crypto.ED25519()) - if err != nil { - fmt.Printf("❌ Error creating issuer wallet: %s\n", err) - return - } + // Issuer + fmt.Println("⏳ Setting up issuer wallet...") + issuer, err := wallet.New(crypto.ED25519()) + if err != nil { + 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) - return - } - fmt.Printf("✅ Issuer wallet funded: %s\n", issuer.ClassicAddress) + err = client.FundWallet(&issuer) + if err != nil { + fmt.Printf("❌ Error funding issuer wallet: %s\n", err) + return + } + fmt.Printf("✅ Issuer wallet funded: %s\n", issuer.ClassicAddress) - // ----------------------------------------------------- + // ----------------------------------------------------- - // Holder 1 - 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) - return - } + // Holder 1 + 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) + return + } - err = client.FundWallet(&holderWallet1) - if err != nil { - fmt.Printf("❌ Error funding holder wallet 1: %s\n", err) - return - } - fmt.Printf("✅ Holder wallet 1 funded: %s\n", holderWallet1.ClassicAddress) + err = client.FundWallet(&holderWallet1) + if err != nil { + fmt.Printf("❌ Error funding holder wallet 1: %s\n", err) + return + } + fmt.Printf("✅ Holder wallet 1 funded: %s\n", holderWallet1.ClassicAddress) - // ----------------------------------------------------- + // ----------------------------------------------------- - // Holder 2 - 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) - return - } + // Holder 2 + 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) + return + } - err = client.FundWallet(&holderWallet2) - if err != nil { - fmt.Printf("❌ Error funding holder wallet 2: %s\n", err) - return - } - fmt.Printf("✅ Holder wallet 2 funded: %s\n", holderWallet2.ClassicAddress) - fmt.Println() + err = client.FundWallet(&holderWallet2) + if err != nil { + fmt.Printf("❌ Error funding holder wallet 2: %s\n", err) + return + } + fmt.Printf("✅ Holder wallet 2 funded: %s\n", holderWallet2.ClassicAddress) + fmt.Println() - fmt.Println("✅ Wallets setup complete!") - fmt.Println() + fmt.Println("✅ Wallets setup complete!") + fmt.Println() - // ----------------------------------------------------- + // ----------------------------------------------------- - // Configuring Issuing account - fmt.Println("⏳ Configuring issuer address settings...") - accountSet := &transactions.AccountSet{ - BaseTx: transactions.BaseTx{ - Account: types.Address(issuer.ClassicAddress), - }, - Domain: types.Domain("697373756572"), // issuer - } + // Configuring Issuing account + fmt.Println("⏳ Configuring issuer address settings...") + accountSet := &transactions.AccountSet{ + BaseTx: transactions.BaseTx{ + Account: types.Address(issuer.ClassicAddress), + }, + Domain: types.Domain("697373756572"), // issuer + } - accountSet.SetAsfDefaultRipple() - submitAndWait(client, accountSet, issuer) + accountSet.SetAsfDefaultRipple() + submitAndWait(client, accountSet, issuer) - // ----------------------------------------------------- + // ----------------------------------------------------- - // Trustline from the 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), - }, - LimitAmount: types.IssuedCurrencyAmount{ - Currency: currency.ConvertStringToHex(currencyCode), - Issuer: types.Address(issuer.ClassicAddress), - Value: "1000000000", - }} - trustSet.SetSetNoRippleFlag() - submitAndWait(client, trustSet, holderWallet1) + // Trustline from the 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), + }, + LimitAmount: types.IssuedCurrencyAmount{ + Currency: currency.ConvertStringToHex(currencyCode), + Issuer: types.Address(issuer.ClassicAddress), + Value: "1000000000", + }} + trustSet.SetSetNoRippleFlag() + submitAndWait(client, trustSet, holderWallet1) - // ----------------------------------------------------- + // ----------------------------------------------------- - // Trustline from the 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), - }, - LimitAmount: types.IssuedCurrencyAmount{ - Currency: currency.ConvertStringToHex(currencyCode), - Issuer: types.Address(issuer.ClassicAddress), - Value: "1000000000", - }, - } - trustSet.SetSetNoRippleFlag() - submitAndWait(client, trustSet, holderWallet2) + // Trustline from the 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), + }, + LimitAmount: types.IssuedCurrencyAmount{ + Currency: currency.ConvertStringToHex(currencyCode), + Issuer: types.Address(issuer.ClassicAddress), + Value: "1000000000", + }, + } + trustSet.SetSetNoRippleFlag() + submitAndWait(client, trustSet, holderWallet2) - // ----------------------------------------------------- + // ----------------------------------------------------- - // Minting to Holder 1 - fmt.Println("⏳ Minting to Holder 1...") - payment := &transactions.Payment{ - BaseTx: transactions.BaseTx{ - Account: types.Address(issuer.ClassicAddress), - }, - Destination: types.Address(holderWallet1.ClassicAddress), - Amount: types.IssuedCurrencyAmount{ - Currency: currency.ConvertStringToHex(currencyCode), - Issuer: types.Address(issuer.ClassicAddress), - Value: "50000", - }, - } - submitAndWait(client, payment, issuer) + // Minting to Holder 1 + fmt.Println("⏳ Minting to Holder 1...") + payment := &transactions.Payment{ + BaseTx: transactions.BaseTx{ + Account: types.Address(issuer.ClassicAddress), + }, + Destination: types.Address(holderWallet1.ClassicAddress), + Amount: types.IssuedCurrencyAmount{ + Currency: currency.ConvertStringToHex(currencyCode), + Issuer: types.Address(issuer.ClassicAddress), + Value: "50000", + }, + } + submitAndWait(client, payment, issuer) - // ----------------------------------------------------- + // ----------------------------------------------------- - // Minting to Holder 2 - fmt.Println("⏳ Minting to Holder 2...") - payment = &transactions.Payment{ - BaseTx: transactions.BaseTx{ - Account: types.Address(issuer.ClassicAddress), - }, - Destination: types.Address(holderWallet2.ClassicAddress), - Amount: types.IssuedCurrencyAmount{ - Currency: currency.ConvertStringToHex(currencyCode), - Issuer: types.Address(issuer.ClassicAddress), - Value: "40000", - }, - } - submitAndWait(client, payment, issuer) + // Minting to Holder 2 + fmt.Println("⏳ Minting to Holder 2...") + payment = &transactions.Payment{ + BaseTx: transactions.BaseTx{ + Account: types.Address(issuer.ClassicAddress), + }, + Destination: types.Address(holderWallet2.ClassicAddress), + Amount: types.IssuedCurrencyAmount{ + Currency: currency.ConvertStringToHex(currencyCode), + Issuer: types.Address(issuer.ClassicAddress), + Value: "40000", + }, + } + submitAndWait(client, payment, issuer) - // ----------------------------------------------------- + // ----------------------------------------------------- - // 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), - }, - Destination: types.Address(holderWallet2.ClassicAddress), - Amount: types.IssuedCurrencyAmount{ - Currency: currency.ConvertStringToHex(currencyCode), - Issuer: types.Address(issuer.ClassicAddress), - Value: "20", - }, - } - submitAndWait(client, payment, holderWallet1) + // 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), + }, + Destination: types.Address(holderWallet2.ClassicAddress), + Amount: types.IssuedCurrencyAmount{ + Currency: currency.ConvertStringToHex(currencyCode), + Issuer: types.Address(issuer.ClassicAddress), + Value: "20", + }, + } + submitAndWait(client, payment, holderWallet1) - // ----------------------------------------------------- + // ----------------------------------------------------- - // Freezing and Deep Freezing holder1 - fmt.Println("⏳ Freezing and Deep Freezing holder 1 trustline...") - trustSet = &transactions.TrustSet{ - BaseTx: transactions.BaseTx{ - Account: types.Address(issuer.ClassicAddress), - }, - LimitAmount: types.IssuedCurrencyAmount{ - Currency: currency.ConvertStringToHex(currencyCode), - Issuer: types.Address(holderWallet1.ClassicAddress), - Value: "0", - }, - } - trustSet.SetSetFreezeFlag() - trustSet.SetSetDeepFreezeFlag() + // Freezing and Deep Freezing holder1 + fmt.Println("⏳ Freezing and Deep Freezing holder 1 trustline...") + trustSet = &transactions.TrustSet{ + BaseTx: transactions.BaseTx{ + Account: types.Address(issuer.ClassicAddress), + }, + LimitAmount: types.IssuedCurrencyAmount{ + Currency: currency.ConvertStringToHex(currencyCode), + Issuer: types.Address(holderWallet1.ClassicAddress), + Value: "0", + }, + } + trustSet.SetSetFreezeFlag() + trustSet.SetSetDeepFreezeFlag() - submitAndWait(client, trustSet, issuer) + 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...") - payment = &transactions.Payment{ - BaseTx: transactions.BaseTx{ - Account: types.Address(holderWallet1.ClassicAddress), - }, - Destination: types.Address(holderWallet2.ClassicAddress), - Amount: types.IssuedCurrencyAmount{ - Currency: currency.ConvertStringToHex(currencyCode), - Issuer: types.Address(issuer.ClassicAddress), - Value: "10", - }, - } - submitAndWait(client, payment, holderWallet1) + // 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), + }, + Destination: types.Address(holderWallet2.ClassicAddress), + Amount: types.IssuedCurrencyAmount{ + Currency: currency.ConvertStringToHex(currencyCode), + Issuer: types.Address(issuer.ClassicAddress), + Value: "10", + }, + } + 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...") - payment = &transactions.Payment{ - BaseTx: transactions.BaseTx{ - Account: types.Address(holderWallet2.ClassicAddress), - }, - Destination: types.Address(holderWallet1.ClassicAddress), - Amount: types.IssuedCurrencyAmount{ - Currency: currency.ConvertStringToHex(currencyCode), - Issuer: types.Address(issuer.ClassicAddress), - Value: "10", - }, - } - submitAndWait(client, payment, holderWallet2) + // 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), + }, + Destination: types.Address(holderWallet1.ClassicAddress), + Amount: types.IssuedCurrencyAmount{ + Currency: currency.ConvertStringToHex(currencyCode), + Issuer: types.Address(issuer.ClassicAddress), + Value: "10", + }, + } + 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...") - offerCreate := &transactions.OfferCreate{ - BaseTx: transactions.BaseTx{ - Account: types.Address(holderWallet1.ClassicAddress), - }, - TakerPays: types.IssuedCurrencyAmount{ - Currency: currency.ConvertStringToHex(currencyCode), - Issuer: types.Address(issuer.ClassicAddress), - Value: "10", - }, - TakerGets: types.XRPCurrencyAmount(10), - } - submitAndWait(client, offerCreate, holderWallet1) + // 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), + }, + TakerPays: types.IssuedCurrencyAmount{ + Currency: currency.ConvertStringToHex(currencyCode), + Issuer: types.Address(issuer.ClassicAddress), + Value: "10", + }, + TakerGets: types.XRPCurrencyAmount(10), + } + submitAndWait(client, offerCreate, holderWallet1) - // ----------------------------------------------------- + // ----------------------------------------------------- - // Unfreezing and Deep Unfreezing holder 1 - fmt.Println("⏳ Unfreezing and Deep Unfreezing holder 1 trustline...") - trustSet = &transactions.TrustSet{ - BaseTx: transactions.BaseTx{ - Account: types.Address(issuer.ClassicAddress), - }, - LimitAmount: types.IssuedCurrencyAmount{ - Currency: currency.ConvertStringToHex(currencyCode), - Issuer: types.Address(holderWallet1.ClassicAddress), - Value: "0", - }, - } - trustSet.SetClearFreezeFlag() - trustSet.SetClearDeepFreezeFlag() - submitAndWait(client, trustSet, issuer) + // Unfreezing and Deep Unfreezing holder 1 + fmt.Println("⏳ Unfreezing and Deep Unfreezing holder 1 trustline...") + trustSet = &transactions.TrustSet{ + BaseTx: transactions.BaseTx{ + Account: types.Address(issuer.ClassicAddress), + }, + LimitAmount: types.IssuedCurrencyAmount{ + Currency: currency.ConvertStringToHex(currencyCode), + Issuer: types.Address(holderWallet1.ClassicAddress), + Value: "0", + }, + } + trustSet.SetClearFreezeFlag() + trustSet.SetClearDeepFreezeFlag() + submitAndWait(client, trustSet, issuer) - // ----------------------------------------------------- + // ----------------------------------------------------- - // 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), - }, - Destination: types.Address(holderWallet2.ClassicAddress), - Amount: types.IssuedCurrencyAmount{ - Currency: currency.ConvertStringToHex(currencyCode), - Issuer: types.Address(issuer.ClassicAddress), - Value: "10", - }, - } - submitAndWait(client, payment, holderWallet1) + // 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), + }, + Destination: types.Address(holderWallet2.ClassicAddress), + Amount: types.IssuedCurrencyAmount{ + Currency: currency.ConvertStringToHex(currencyCode), + Issuer: types.Address(issuer.ClassicAddress), + Value: "10", + }, + } + submitAndWait(client, payment, holderWallet1) - // ----------------------------------------------------- + // ----------------------------------------------------- - // 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), - }, - Destination: types.Address(holderWallet1.ClassicAddress), - Amount: types.IssuedCurrencyAmount{ - Currency: currency.ConvertStringToHex(currencyCode), - Issuer: types.Address(issuer.ClassicAddress), - Value: "10", - }, - } - submitAndWait(client, payment, holderWallet2) + // 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), + }, + Destination: types.Address(holderWallet1.ClassicAddress), + Amount: types.IssuedCurrencyAmount{ + Currency: currency.ConvertStringToHex(currencyCode), + Issuer: types.Address(issuer.ClassicAddress), + Value: "10", + }, + } + submitAndWait(client, payment, holderWallet2) } // getRpcClient returns a new rpc client func getRpcClient() *rpc.Client { - cfg, err := rpc.NewClientConfig( - // DeepFreeze only available on Devnet as of February 2025, change to testnet/mainnet once the amendment passes. - "https://s.devnet.rippletest.net:51234", - rpc.WithFaucetProvider(faucet.NewDevnetFaucetProvider()), - ) - if err != nil { - panic(err) - } + cfg, err := rpc.NewClientConfig( + // DeepFreeze only available on Devnet as of February 2025, change to testnet/mainnet once the amendment passes. + "https://s.devnet.rippletest.net:51234", + rpc.WithFaucetProvider(faucet.NewDevnetFaucetProvider()), + ) + if err != nil { + panic(err) + } - return rpc.NewClient(cfg) + return rpc.NewClient(cfg) } // 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() + flattenedTx := txn.Flatten() - err := client.Autofill(&flattenedTx) - if err != nil { - fmt.Printf("❌ Error autofilling %s transaction: %s\n", txn.TxType(), err) - fmt.Println() - return - } + err := client.Autofill(&flattenedTx) + if err != nil { + 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.Println() - return - } + txBlob, _, err := wallet.Sign(flattenedTx) + if err != nil { + 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.Println() - return - } + response, err := client.SubmitTxBlobAndWait(txBlob, false) + if err != nil { + 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.Println() + fmt.Printf("✅ %s transaction submitted\n", txn.TxType()) + fmt.Printf("🌐 Hash: %s\n", response.Hash.String()) + fmt.Println() } diff --git a/_code-samples/freeze/go/ws/main.go b/_code-samples/freeze/go/ws/main.go index 47e2323178..1702ca939e 100644 --- a/_code-samples/freeze/go/ws/main.go +++ b/_code-samples/freeze/go/ws/main.go @@ -1,357 +1,357 @@ 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 ( - currencyCode = "USDA" + currencyCode = "USDA" ) type SubmittableTransaction interface { - TxType() transactions.TxType - Flatten() transactions.FlatTransaction // Ensures all transactions can be flattened + TxType() transactions.TxType + Flatten() transactions.FlatTransaction // Ensures all transactions can be flattened } func main() { - fmt.Println("⏳ Setting up client...") + fmt.Println("⏳ Setting up client...") - client := getClient() - fmt.Println("Connecting to server...") - if err := client.Connect(); err != nil { - fmt.Println(err) - return - } + client := getClient() + fmt.Println("Connecting to server...") + if err := client.Connect(); err != nil { + fmt.Println(err) + return + } - fmt.Println("✅ Client configured!") - fmt.Println() + fmt.Println("✅ Client configured!") + fmt.Println() - fmt.Printf("Connection: %t", client.IsConnected()) - fmt.Println() + fmt.Printf("Connection: %t", client.IsConnected()) + fmt.Println() - // Configure wallets + // Configure wallets - // Issuer - fmt.Println("⏳ Setting up issuer wallet...") - issuer, err := wallet.New(crypto.ED25519()) - if err != nil { - fmt.Printf("❌ Error creating issuer wallet: %s\n", err) - return - } + // Issuer + fmt.Println("⏳ Setting up issuer wallet...") + issuer, err := wallet.New(crypto.ED25519()) + if err != nil { + 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) - return - } - fmt.Printf("✅ Issuer wallet funded: %s\n", issuer.ClassicAddress) + err = client.FundWallet(&issuer) + if err != nil { + fmt.Printf("❌ Error funding issuer wallet: %s\n", err) + return + } + fmt.Printf("✅ Issuer wallet funded: %s\n", issuer.ClassicAddress) - // ----------------------------------------------------- + // ----------------------------------------------------- - // Holder 1 - 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) - return - } + // Holder 1 + 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) + return + } - err = client.FundWallet(&holderWallet1) - if err != nil { - fmt.Printf("❌ Error funding holder wallet 1: %s\n", err) - return - } - fmt.Printf("✅ Holder wallet 1 funded: %s\n", holderWallet1.ClassicAddress) + err = client.FundWallet(&holderWallet1) + if err != nil { + fmt.Printf("❌ Error funding holder wallet 1: %s\n", err) + return + } + fmt.Printf("✅ Holder wallet 1 funded: %s\n", holderWallet1.ClassicAddress) - // ----------------------------------------------------- + // ----------------------------------------------------- - // Holder 2 - 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) - return - } + // Holder 2 + 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) + return + } - err = client.FundWallet(&holderWallet2) - if err != nil { - fmt.Printf("❌ Error funding holder wallet 2: %s\n", err) - return - } - fmt.Printf("✅ Holder wallet 2 funded: %s\n", holderWallet2.ClassicAddress) - fmt.Println() + err = client.FundWallet(&holderWallet2) + if err != nil { + fmt.Printf("❌ Error funding holder wallet 2: %s\n", err) + return + } + fmt.Printf("✅ Holder wallet 2 funded: %s\n", holderWallet2.ClassicAddress) + fmt.Println() - fmt.Println("✅ Wallets setup complete!") - fmt.Println() + fmt.Println("✅ Wallets setup complete!") + fmt.Println() - // ----------------------------------------------------- + // ----------------------------------------------------- - // Configuring Issuing account - fmt.Println("⏳ Configuring issuer address settings...") - accountSet := &transactions.AccountSet{ - BaseTx: transactions.BaseTx{ - Account: types.Address(issuer.ClassicAddress), - }, - Domain: types.Domain("697373756572"), // issuer - } + // Configuring Issuing account + fmt.Println("⏳ Configuring issuer address settings...") + accountSet := &transactions.AccountSet{ + BaseTx: transactions.BaseTx{ + Account: types.Address(issuer.ClassicAddress), + }, + Domain: types.Domain("697373756572"), // issuer + } - accountSet.SetAsfDefaultRipple() - submitAndWait(client, accountSet, issuer) + accountSet.SetAsfDefaultRipple() + submitAndWait(client, accountSet, issuer) - // ----------------------------------------------------- + // ----------------------------------------------------- - // Trustline from the 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), - }, - LimitAmount: types.IssuedCurrencyAmount{ - Currency: currency.ConvertStringToHex(currencyCode), - Issuer: types.Address(issuer.ClassicAddress), - Value: "1000000000", - }} - trustSet.SetSetNoRippleFlag() - submitAndWait(client, trustSet, holderWallet1) + // Trustline from the 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), + }, + LimitAmount: types.IssuedCurrencyAmount{ + Currency: currency.ConvertStringToHex(currencyCode), + Issuer: types.Address(issuer.ClassicAddress), + Value: "1000000000", + }} + trustSet.SetSetNoRippleFlag() + submitAndWait(client, trustSet, holderWallet1) - // ----------------------------------------------------- + // ----------------------------------------------------- - // Trustline from the 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), - }, - LimitAmount: types.IssuedCurrencyAmount{ - Currency: currency.ConvertStringToHex(currencyCode), - Issuer: types.Address(issuer.ClassicAddress), - Value: "1000000000", - }, - } - trustSet.SetSetNoRippleFlag() - submitAndWait(client, trustSet, holderWallet2) + // Trustline from the 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), + }, + LimitAmount: types.IssuedCurrencyAmount{ + Currency: currency.ConvertStringToHex(currencyCode), + Issuer: types.Address(issuer.ClassicAddress), + Value: "1000000000", + }, + } + trustSet.SetSetNoRippleFlag() + submitAndWait(client, trustSet, holderWallet2) - // ----------------------------------------------------- + // ----------------------------------------------------- - // Minting to Holder 1 - fmt.Println("⏳ Minting to Holder 1...") - payment := &transactions.Payment{ - BaseTx: transactions.BaseTx{ - Account: types.Address(issuer.ClassicAddress), - }, - Destination: types.Address(holderWallet1.ClassicAddress), - Amount: types.IssuedCurrencyAmount{ - Currency: currency.ConvertStringToHex(currencyCode), - Issuer: types.Address(issuer.ClassicAddress), - Value: "50000", - }, - } - submitAndWait(client, payment, issuer) + // Minting to Holder 1 + fmt.Println("⏳ Minting to Holder 1...") + payment := &transactions.Payment{ + BaseTx: transactions.BaseTx{ + Account: types.Address(issuer.ClassicAddress), + }, + Destination: types.Address(holderWallet1.ClassicAddress), + Amount: types.IssuedCurrencyAmount{ + Currency: currency.ConvertStringToHex(currencyCode), + Issuer: types.Address(issuer.ClassicAddress), + Value: "50000", + }, + } + submitAndWait(client, payment, issuer) - // ----------------------------------------------------- + // ----------------------------------------------------- - // Minting to Holder 2 - fmt.Println("⏳ Minting to Holder 2...") - payment = &transactions.Payment{ - BaseTx: transactions.BaseTx{ - Account: types.Address(issuer.ClassicAddress), - }, - Destination: types.Address(holderWallet2.ClassicAddress), - Amount: types.IssuedCurrencyAmount{ - Currency: currency.ConvertStringToHex(currencyCode), - Issuer: types.Address(issuer.ClassicAddress), - Value: "40000", - }, - } - submitAndWait(client, payment, issuer) + // Minting to Holder 2 + fmt.Println("⏳ Minting to Holder 2...") + payment = &transactions.Payment{ + BaseTx: transactions.BaseTx{ + Account: types.Address(issuer.ClassicAddress), + }, + Destination: types.Address(holderWallet2.ClassicAddress), + Amount: types.IssuedCurrencyAmount{ + Currency: currency.ConvertStringToHex(currencyCode), + Issuer: types.Address(issuer.ClassicAddress), + Value: "40000", + }, + } + submitAndWait(client, payment, issuer) - // ----------------------------------------------------- + // ----------------------------------------------------- - // 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), - }, - Destination: types.Address(holderWallet2.ClassicAddress), - Amount: types.IssuedCurrencyAmount{ - Currency: currency.ConvertStringToHex(currencyCode), - Issuer: types.Address(issuer.ClassicAddress), - Value: "20", - }, - } - submitAndWait(client, payment, holderWallet1) + // 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), + }, + Destination: types.Address(holderWallet2.ClassicAddress), + Amount: types.IssuedCurrencyAmount{ + Currency: currency.ConvertStringToHex(currencyCode), + Issuer: types.Address(issuer.ClassicAddress), + Value: "20", + }, + } + submitAndWait(client, payment, holderWallet1) - // ----------------------------------------------------- + // ----------------------------------------------------- - // Freezing and Deep Freezing holder1 - fmt.Println("⏳ Freezing and Deep Freezing holder 1 trustline...") - trustSet = &transactions.TrustSet{ - BaseTx: transactions.BaseTx{ - Account: types.Address(issuer.ClassicAddress), - }, - LimitAmount: types.IssuedCurrencyAmount{ - Currency: currency.ConvertStringToHex(currencyCode), - Issuer: types.Address(holderWallet1.ClassicAddress), - Value: "0", - }, - } - trustSet.SetSetFreezeFlag() - trustSet.SetSetDeepFreezeFlag() + // Freezing and Deep Freezing holder1 + fmt.Println("⏳ Freezing and Deep Freezing holder 1 trustline...") + trustSet = &transactions.TrustSet{ + BaseTx: transactions.BaseTx{ + Account: types.Address(issuer.ClassicAddress), + }, + LimitAmount: types.IssuedCurrencyAmount{ + Currency: currency.ConvertStringToHex(currencyCode), + Issuer: types.Address(holderWallet1.ClassicAddress), + Value: "0", + }, + } + trustSet.SetSetFreezeFlag() + trustSet.SetSetDeepFreezeFlag() - submitAndWait(client, trustSet, issuer) + 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...") - payment = &transactions.Payment{ - BaseTx: transactions.BaseTx{ - Account: types.Address(holderWallet1.ClassicAddress), - }, - Destination: types.Address(holderWallet2.ClassicAddress), - Amount: types.IssuedCurrencyAmount{ - Currency: currency.ConvertStringToHex(currencyCode), - Issuer: types.Address(issuer.ClassicAddress), - Value: "10", - }, - } - submitAndWait(client, payment, holderWallet1) + // 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), + }, + Destination: types.Address(holderWallet2.ClassicAddress), + Amount: types.IssuedCurrencyAmount{ + Currency: currency.ConvertStringToHex(currencyCode), + Issuer: types.Address(issuer.ClassicAddress), + Value: "10", + }, + } + 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...") - payment = &transactions.Payment{ - BaseTx: transactions.BaseTx{ - Account: types.Address(holderWallet2.ClassicAddress), - }, - Destination: types.Address(holderWallet1.ClassicAddress), - Amount: types.IssuedCurrencyAmount{ - Currency: currency.ConvertStringToHex(currencyCode), - Issuer: types.Address(issuer.ClassicAddress), - Value: "10", - }, - } - submitAndWait(client, payment, holderWallet2) + // 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), + }, + Destination: types.Address(holderWallet1.ClassicAddress), + Amount: types.IssuedCurrencyAmount{ + Currency: currency.ConvertStringToHex(currencyCode), + Issuer: types.Address(issuer.ClassicAddress), + Value: "10", + }, + } + 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...") - offerCreate := &transactions.OfferCreate{ - BaseTx: transactions.BaseTx{ - Account: types.Address(holderWallet1.ClassicAddress), - }, - TakerPays: types.IssuedCurrencyAmount{ - Currency: currency.ConvertStringToHex(currencyCode), - Issuer: types.Address(issuer.ClassicAddress), - Value: "10", - }, - TakerGets: types.XRPCurrencyAmount(10), - } - submitAndWait(client, offerCreate, holderWallet1) + // 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), + }, + TakerPays: types.IssuedCurrencyAmount{ + Currency: currency.ConvertStringToHex(currencyCode), + Issuer: types.Address(issuer.ClassicAddress), + Value: "10", + }, + TakerGets: types.XRPCurrencyAmount(10), + } + submitAndWait(client, offerCreate, holderWallet1) - // ----------------------------------------------------- + // ----------------------------------------------------- - // Unfreezing and Deep Unfreezing holder 1 - fmt.Println("⏳ Unfreezing and Deep Unfreezing holder 1 trustline...") - trustSet = &transactions.TrustSet{ - BaseTx: transactions.BaseTx{ - Account: types.Address(issuer.ClassicAddress), - }, - LimitAmount: types.IssuedCurrencyAmount{ - Currency: currency.ConvertStringToHex(currencyCode), - Issuer: types.Address(holderWallet1.ClassicAddress), - Value: "0", - }, - } - trustSet.SetClearFreezeFlag() - trustSet.SetClearDeepFreezeFlag() - submitAndWait(client, trustSet, issuer) + // Unfreezing and Deep Unfreezing holder 1 + fmt.Println("⏳ Unfreezing and Deep Unfreezing holder 1 trustline...") + trustSet = &transactions.TrustSet{ + BaseTx: transactions.BaseTx{ + Account: types.Address(issuer.ClassicAddress), + }, + LimitAmount: types.IssuedCurrencyAmount{ + Currency: currency.ConvertStringToHex(currencyCode), + Issuer: types.Address(holderWallet1.ClassicAddress), + Value: "0", + }, + } + trustSet.SetClearFreezeFlag() + trustSet.SetClearDeepFreezeFlag() + submitAndWait(client, trustSet, issuer) - // ----------------------------------------------------- + // ----------------------------------------------------- - // 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), - }, - Destination: types.Address(holderWallet2.ClassicAddress), - Amount: types.IssuedCurrencyAmount{ - Currency: currency.ConvertStringToHex(currencyCode), - Issuer: types.Address(issuer.ClassicAddress), - Value: "10", - }, - } - submitAndWait(client, payment, holderWallet1) + // 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), + }, + Destination: types.Address(holderWallet2.ClassicAddress), + Amount: types.IssuedCurrencyAmount{ + Currency: currency.ConvertStringToHex(currencyCode), + Issuer: types.Address(issuer.ClassicAddress), + Value: "10", + }, + } + submitAndWait(client, payment, holderWallet1) - // ----------------------------------------------------- + // ----------------------------------------------------- - // 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), - }, - Destination: types.Address(holderWallet1.ClassicAddress), - Amount: types.IssuedCurrencyAmount{ - Currency: currency.ConvertStringToHex(currencyCode), - Issuer: types.Address(issuer.ClassicAddress), - Value: "10", - }, - } - submitAndWait(client, payment, holderWallet2) + // 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), + }, + Destination: types.Address(holderWallet1.ClassicAddress), + Amount: types.IssuedCurrencyAmount{ + Currency: currency.ConvertStringToHex(currencyCode), + Issuer: types.Address(issuer.ClassicAddress), + Value: "10", + }, + } + submitAndWait(client, payment, holderWallet2) } // getRpcClient returns a new rpc client func getClient() *websocket.Client { - client := websocket.NewClient( - websocket.NewClientConfig(). - WithHost("wss://s.devnet.rippletest.net:51233"). - WithFaucetProvider(faucet.NewDevnetFaucetProvider()), - ) + client := websocket.NewClient( + websocket.NewClientConfig(). + WithHost("wss://s.devnet.rippletest.net:51233"). + WithFaucetProvider(faucet.NewDevnetFaucetProvider()), + ) - return client + return 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() + flattenedTx := txn.Flatten() - err := client.Autofill(&flattenedTx) - if err != nil { - fmt.Printf("❌ Error autofilling %s transaction: %s\n", txn.TxType(), err) - fmt.Println() - return - } + err := client.Autofill(&flattenedTx) + if err != nil { + 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.Println() - return - } + txBlob, _, err := wallet.Sign(flattenedTx) + if err != nil { + 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.Println() - return - } + response, err := client.SubmitTxBlobAndWait(txBlob, false) + if err != nil { + 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.Println() + fmt.Printf("✅ %s transaction submitted\n", txn.TxType()) + fmt.Printf("🌐 Hash: %s\n", response.Hash.String()) + fmt.Println() } diff --git a/_code-samples/get-started/go/base/rpc/main.go b/_code-samples/get-started/go/base/rpc/main.go index e463386254..61ae21ebc6 100644 --- a/_code-samples/get-started/go/base/rpc/main.go +++ b/_code-samples/get-started/go/base/rpc/main.go @@ -1,26 +1,26 @@ package main import ( - "github.com/Peersyst/xrpl-go/xrpl/queries/utility" - "github.com/Peersyst/xrpl-go/xrpl/rpc" + "github.com/Peersyst/xrpl-go/xrpl/queries/utility" + "github.com/Peersyst/xrpl-go/xrpl/rpc" ) func main() { - // Define the network client configuration - cfg, err := rpc.NewClientConfig("https://s.altnet.rippletest.net:51234/") - if err != nil { - panic(err) - } + // Define the network client configuration + cfg, err := rpc.NewClientConfig("https://s.altnet.rippletest.net:51234/") + if err != nil { + panic(err) + } - // Initiate the network client - client := rpc.NewClient(cfg) + // Initiate the network client + client := rpc.NewClient(cfg) - // Ping the network (used to avoid Go unused variable error, but useful to check connectivity) - _, err = client.Ping(&utility.PingRequest{}) - if err != nil { - panic(err) - } + // Ping the network (used to avoid Go unused variable error, but useful to check connectivity) + _, err = client.Ping(&utility.PingRequest{}) + if err != nil { + panic(err) + } - // ... custom code goes here + // ... custom code goes here } diff --git a/_code-samples/get-started/go/base/ws/main.go b/_code-samples/get-started/go/base/ws/main.go index dad84126f1..2a921207ff 100644 --- a/_code-samples/get-started/go/base/ws/main.go +++ b/_code-samples/get-started/go/base/ws/main.go @@ -1,25 +1,25 @@ package main import ( - "fmt" + "fmt" - "github.com/Peersyst/xrpl-go/xrpl/websocket" + "github.com/Peersyst/xrpl-go/xrpl/websocket" ) func main() { - // Define the network client - client := websocket.NewClient(websocket.NewClientConfig(). - WithHost("wss://s.altnet.rippletest.net:51233")) + // Define the network client + client := websocket.NewClient(websocket.NewClientConfig(). + WithHost("wss://s.altnet.rippletest.net:51233")) - // Disconnect the client when done. (Defer executes at the end of the function) - defer client.Disconnect() + // Disconnect the client when done. (Defer executes at the end of the function) + defer client.Disconnect() - // Connect to the network - if err := client.Connect(); err != nil { - fmt.Println(err) - return - } + // Connect to the network + if err := client.Connect(); err != nil { + fmt.Println(err) + return + } - // ... custom code goes here + // ... custom code goes here } diff --git a/_code-samples/get-started/go/get-acc-info/rpc/main.go b/_code-samples/get-started/go/get-acc-info/rpc/main.go index 792e89a3ed..f933812a6a 100644 --- a/_code-samples/get-started/go/get-acc-info/rpc/main.go +++ b/_code-samples/get-started/go/get-acc-info/rpc/main.go @@ -1,59 +1,59 @@ 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/rpc" - "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/queries/common" + "github.com/Peersyst/xrpl-go/xrpl/queries/ledger" + "github.com/Peersyst/xrpl-go/xrpl/rpc" + "github.com/Peersyst/xrpl-go/xrpl/wallet" ) func main() { - // Define the network client with a faucet provider - cfg, err := rpc.NewClientConfig( - "https://s.altnet.rippletest.net:51234/", - rpc.WithFaucetProvider(faucet.NewTestnetFaucetProvider()), - ) - if err != nil { - panic(err) - } - client := rpc.NewClient(cfg) + // Define the network client with a faucet provider + cfg, err := rpc.NewClientConfig( + "https://s.altnet.rippletest.net:51234/", + rpc.WithFaucetProvider(faucet.NewTestnetFaucetProvider()), + ) + if err != nil { + panic(err) + } + client := rpc.NewClient(cfg) - // Create a new wallet - w, err := wallet.New(crypto.ED25519()) - if err != nil { - fmt.Println(err) - return - } - fmt.Println("New wallet created:") - fmt.Println("Address:", w.ClassicAddress) + // Create a new wallet + w, err := wallet.New(crypto.ED25519()) + if err != nil { + fmt.Println(err) + return + } + fmt.Println("New wallet created:") + fmt.Println("Address:", w.ClassicAddress) - // Fund the wallet with testnet XRP - if err := client.FundWallet(&w); err != nil { - fmt.Println(err) - return - } + // Fund the wallet with testnet XRP + if err := client.FundWallet(&w); err != nil { + fmt.Println(err) + return + } - // Get info from the ledger about the address we just funded - acc_info, err := client.GetAccountInfo(&account.InfoRequest{ - Account: w.GetAddress(), - }) - if err != nil { - fmt.Println(err) - return - } - fmt.Println("Account Balance:", acc_info.AccountData.Balance) - fmt.Println("Account Sequence:", acc_info.AccountData.Sequence) + // Get info from the ledger about the address we just funded + acc_info, err := client.GetAccountInfo(&account.InfoRequest{ + Account: w.GetAddress(), + }) + if err != nil { + fmt.Println(err) + return + } + fmt.Println("Account Balance:", acc_info.AccountData.Balance) + fmt.Println("Account Sequence:", acc_info.AccountData.Sequence) - // Get info about the ledger - ledger, err := client.GetLedger(&ledger.Request{LedgerIndex: common.Current}) - if err != nil { - fmt.Println(err) - return - } - fmt.Println("Ledger Index:", ledger.Ledger.LedgerIndex) + // Get info about the ledger + ledger, err := client.GetLedger(&ledger.Request{LedgerIndex: common.Current}) + if err != nil { + fmt.Println(err) + return + } + fmt.Println("Ledger Index:", ledger.Ledger.LedgerIndex) } diff --git a/_code-samples/get-started/go/get-acc-info/ws/main.go b/_code-samples/get-started/go/get-acc-info/ws/main.go index f4ef0ff129..025143f398 100644 --- a/_code-samples/get-started/go/get-acc-info/ws/main.go +++ b/_code-samples/get-started/go/get-acc-info/ws/main.go @@ -1,74 +1,74 @@ 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() { - // Define the network client with a faucet provider - client := websocket.NewClient( - websocket.NewClientConfig(). - WithHost("wss://s.altnet.rippletest.net:51233"). - WithFaucetProvider(faucet.NewTestnetFaucetProvider()), - ) + // Define the network client with a faucet provider + client := websocket.NewClient( + websocket.NewClientConfig(). + WithHost("wss://s.altnet.rippletest.net:51233"). + WithFaucetProvider(faucet.NewTestnetFaucetProvider()), + ) - // Disconnect the client when done. (Defer executes at the end of the function) - defer client.Disconnect() + // Disconnect the client when done. (Defer executes at the end of the function) + defer client.Disconnect() - // Connect to the network - if err := client.Connect(); err != nil { - fmt.Println(err) - return - } + // Connect to the network + if err := client.Connect(); err != nil { + fmt.Println(err) + return + } - if !client.IsConnected() { - fmt.Println("❌ Failed to connect to testnet") - return - } + if !client.IsConnected() { + fmt.Println("❌ Failed to connect to testnet") + return + } - fmt.Println("✅ Connected to testnet") - fmt.Println() + fmt.Println("✅ Connected to testnet") + fmt.Println() - // Create a new wallet - w, err := wallet.New(crypto.ED25519()) - if err != nil { - fmt.Println(err) - return - } - fmt.Println("New wallet created:") - fmt.Println("Address:", w.ClassicAddress) + // Create a new wallet + w, err := wallet.New(crypto.ED25519()) + if err != nil { + fmt.Println(err) + return + } + fmt.Println("New wallet created:") + fmt.Println("Address:", w.ClassicAddress) - // Fund the wallet with testnet XRP - if err := client.FundWallet(&w); err != nil { - fmt.Println(err) - return - } + // Fund the wallet with testnet XRP + if err := client.FundWallet(&w); err != nil { + fmt.Println(err) + return + } - // Get info from the ledger about the address we just funded - acc_info, err := client.GetAccountInfo(&account.InfoRequest{ - Account: w.GetAddress(), - }) - if err != nil { - fmt.Println(err) - return - } - fmt.Println("Account Balance:", acc_info.AccountData.Balance) - fmt.Println("Account Sequence:", acc_info.AccountData.Sequence) + // Get info from the ledger about the address we just funded + acc_info, err := client.GetAccountInfo(&account.InfoRequest{ + Account: w.GetAddress(), + }) + if err != nil { + fmt.Println(err) + return + } + fmt.Println("Account Balance:", acc_info.AccountData.Balance) + fmt.Println("Account Sequence:", acc_info.AccountData.Sequence) - // Get info about the ledger - ledger, err := client.GetLedger(&ledger.Request{LedgerIndex: common.Current}) - if err != nil { - fmt.Println(err) - return - } - fmt.Println("Ledger Index:", ledger.Ledger.LedgerIndex) + // Get info about the ledger + ledger, err := client.GetLedger(&ledger.Request{LedgerIndex: common.Current}) + if err != nil { + fmt.Println(err) + return + } + fmt.Println("Ledger Index:", ledger.Ledger.LedgerIndex) } diff --git a/_code-samples/get-tx/go/main.go b/_code-samples/get-tx/go/main.go index 32a433d90c..dfac0b27d0 100644 --- a/_code-samples/get-tx/go/main.go +++ b/_code-samples/get-tx/go/main.go @@ -1,46 +1,46 @@ package main import ( - "fmt" + "fmt" - "github.com/Peersyst/xrpl-go/xrpl/queries/common" - "github.com/Peersyst/xrpl-go/xrpl/queries/ledger" - "github.com/Peersyst/xrpl-go/xrpl/queries/transactions" - "github.com/Peersyst/xrpl-go/xrpl/rpc" + "github.com/Peersyst/xrpl-go/xrpl/queries/common" + "github.com/Peersyst/xrpl-go/xrpl/queries/ledger" + "github.com/Peersyst/xrpl-go/xrpl/queries/transactions" + "github.com/Peersyst/xrpl-go/xrpl/rpc" ) func main() { - cfg, err := rpc.NewClientConfig( - "https://s.altnet.rippletest.net:51234/", - ) - if err != nil { - panic(err) - } + cfg, err := rpc.NewClientConfig( + "https://s.altnet.rippletest.net:51234/", + ) + if err != nil { + panic(err) + } - client := rpc.NewClient(cfg) + client := rpc.NewClient(cfg) - // Get the latest validated ledger - led, err := client.GetLedger(&ledger.Request{ - Transactions: true, - LedgerIndex: common.Validated, - }) - if err != nil { - panic(err) - } - fmt.Println("Latest validated ledger:", led) + // Get the latest validated ledger + led, err := client.GetLedger(&ledger.Request{ + Transactions: true, + LedgerIndex: common.Validated, + }) + if err != nil { + panic(err) + } + fmt.Println("Latest validated ledger:", led) - // Get the first transaction hash from the ledger - if len(led.Ledger.Transactions) > 0 { - txHash := led.Ledger.Transactions[0].(string) // type assertion may be needed + // Get the first transaction hash from the ledger + if len(led.Ledger.Transactions) > 0 { + txHash := led.Ledger.Transactions[0].(string) // type assertion may be needed - // Query the transaction details - txResp, err := client.Request(&transactions.TxRequest{ - Transaction: txHash, - }) - if err != nil { - panic(err) - } - fmt.Println("First transaction in the ledger:") - fmt.Println(txResp) - } + // Query the transaction details + txResp, err := client.Request(&transactions.TxRequest{ + Transaction: txHash, + }) + if err != nil { + panic(err) + } + fmt.Println("First transaction in the ledger:") + fmt.Println(txResp) + } } diff --git a/_code-samples/issue-a-token/go/rpc/main.go b/_code-samples/issue-a-token/go/rpc/main.go index bbdec424c7..249d58d971 100644 --- a/_code-samples/issue-a-token/go/rpc/main.go +++ b/_code-samples/issue-a-token/go/rpc/main.go @@ -1,523 +1,523 @@ 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 ( - currencyCode = "FOO" + currencyCode = "FOO" ) func main() { - // - // Configure client - // - fmt.Println("⏳ Setting up client...") - cfg, err := rpc.NewClientConfig( - "https://s.altnet.rippletest.net:51234/", - rpc.WithFaucetProvider(faucet.NewTestnetFaucetProvider()), - ) - if err != nil { - panic(err) - } - - client := rpc.NewClient(cfg) - fmt.Println("✅ Client configured!") - fmt.Println() - - // - // Configure wallets - // - fmt.Println("⏳ Setting up wallets...") - coldWallet, err := wallet.New(crypto.ED25519()) - if err != nil { - 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) - return - } - fmt.Println("💸 Cold wallet funded!") - - hotWallet, err := wallet.New(crypto.ED25519()) - if err != nil { - 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) - return - } - fmt.Println("💸 Hot wallet funded!") - - customerOneWallet, err := wallet.New(crypto.ED25519()) - if err != nil { - 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) - return - } - 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() - - // - // Configure cold address settings - // - fmt.Println("⏳ Configuring cold address settings...") - coldWalletAccountSet := &transactions.AccountSet{ - BaseTx: transactions.BaseTx{ - Account: types.Address(coldWallet.ClassicAddress), - }, - TickSize: types.TickSize(5), - TransferRate: types.TransferRate(0), - Domain: types.Domain("6578616D706C652E636F6D"), // example.com - } - - coldWalletAccountSet.SetAsfDefaultRipple() - coldWalletAccountSet.SetDisallowXRP() - - coldWalletAccountSet.SetRequireDestTag() - - flattenedTx := coldWalletAccountSet.Flatten() - - err = client.Autofill(&flattenedTx) - if err != nil { - 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) - return - } - - response, err := client.SubmitTxBlobAndWait(txBlob, false) - if err != nil { - fmt.Printf("❌ Error submitting transaction: %s\n", err) - return - } - - if !response.Validated { - 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() - - // - // Configure hot address settings - // - fmt.Println("⏳ Configuring hot address settings...") - hotWalletAccountSet := &transactions.AccountSet{ - BaseTx: transactions.BaseTx{ - Account: types.Address(hotWallet.ClassicAddress), - }, - Domain: types.Domain("6578616D706C652E636F6D"), // example.com - } - - hotWalletAccountSet.SetAsfRequireAuth() - hotWalletAccountSet.SetDisallowXRP() - hotWalletAccountSet.SetRequireDestTag() - - flattenedTx = hotWalletAccountSet.Flatten() - err = client.Autofill(&flattenedTx) - if err != nil { - 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) - return - } - - response, err = client.SubmitTxBlobAndWait(txBlob, false) - if err != nil { - fmt.Printf("❌ Error submitting transaction: %s\n", err) - return - } - - if !response.Validated { - 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() - - // - // Create 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), - }, - LimitAmount: types.IssuedCurrencyAmount{ - Currency: currencyCode, - Issuer: types.Address(coldWallet.ClassicAddress), - Value: "100000000000000", - }, - } - - flattenedTx = hotColdTrustSet.Flatten() - err = client.Autofill(&flattenedTx) - if err != nil { - 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) - return - } - - response, err = client.SubmitTxBlobAndWait(txBlob, false) - if err != nil { - 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("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() - - // - // Create trust line from costumer 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), - }, - LimitAmount: types.IssuedCurrencyAmount{ - Currency: currencyCode, - Issuer: types.Address(coldWallet.ClassicAddress), - Value: "100000000000000", - }, - } - - flattenedTx = customerOneColdTrustSet.Flatten() - err = client.Autofill(&flattenedTx) - if err != nil { - 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) - return - } - - response, err = client.SubmitTxBlobAndWait(txBlob, false) - if err != nil { - 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("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() - - // - // Send 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), - }, - Amount: types.IssuedCurrencyAmount{ - Currency: currencyCode, - Issuer: types.Address(coldWallet.ClassicAddress), - Value: "3800", - }, - Destination: types.Address(hotWallet.ClassicAddress), - DestinationTag: types.DestinationTag(1), - } - - flattenedTx = coldToHotPayment.Flatten() - err = client.Autofill(&flattenedTx) - if err != nil { - 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) - return - } - - response, err = client.SubmitTxBlobAndWait(txBlob, false) - if err != nil { - 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("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() - - // - // Send tokens from hot 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), - }, - Amount: types.IssuedCurrencyAmount{ - Currency: currencyCode, - Issuer: types.Address(coldWallet.ClassicAddress), - Value: "100", - }, - Destination: types.Address(customerOneWallet.ClassicAddress), - } - - flattenedTx = coldToCustomerOnePayment.Flatten() - err = client.Autofill(&flattenedTx) - if err != nil { - 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) - return - } - - response, err = client.SubmitTxBlobAndWait(txBlob, false) - if err != nil { - 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() - return - } - - 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...") - freezeColdWallet := &transactions.AccountSet{ - BaseTx: transactions.BaseTx{ - Account: types.Address(coldWallet.ClassicAddress), - }, - } - - freezeColdWallet.SetAsfGlobalFreeze() - - flattenedTx = freezeColdWallet.Flatten() - err = client.Autofill(&flattenedTx) - if err != nil { - 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) - return - } - - response, err = client.SubmitTxBlobAndWait(txBlob, false) - if err != nil { - 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() - return - } - - 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...") - hotToCustomerOnePayment := &transactions.Payment{ - BaseTx: transactions.BaseTx{ - Account: types.Address(hotWallet.ClassicAddress), - }, - Amount: types.IssuedCurrencyAmount{ - Currency: currencyCode, - Issuer: types.Address(coldWallet.ClassicAddress), - Value: "100", - }, - Destination: types.Address(customerOneWallet.ClassicAddress), - } - - flattenedTx = hotToCustomerOnePayment.Flatten() - err = client.Autofill(&flattenedTx) - if err != nil { - 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) - return - } - - _, err = client.SubmitTxBlobAndWait(txBlob, false) - if err == nil { - return - } - - fmt.Println("❌ Tokens not sent from hot wallet to customer one!") - fmt.Println() - - // // - // // Unfreeze cold wallet - // // - fmt.Println("⏳ Unfreezing cold wallet...") - unfreezeColdWallet := &transactions.AccountSet{ - BaseTx: transactions.BaseTx{ - Account: types.Address(coldWallet.ClassicAddress), - }, - } - - unfreezeColdWallet.ClearAsfGlobalFreeze() - - flattenedTx = unfreezeColdWallet.Flatten() - err = client.Autofill(&flattenedTx) - if err != nil { - 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) - return - } - - response, err = client.SubmitTxBlobAndWait(txBlob, false) - if err != nil { - 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() - return - } - - 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...") - hotToCustomerOnePayment = &transactions.Payment{ - BaseTx: transactions.BaseTx{ - Account: types.Address(hotWallet.ClassicAddress), - }, - Amount: types.IssuedCurrencyAmount{ - Currency: currencyCode, - Issuer: types.Address(coldWallet.ClassicAddress), - Value: "100", - }, - Destination: types.Address(customerOneWallet.ClassicAddress), - } - - flattenedTx = hotToCustomerOnePayment.Flatten() - err = client.Autofill(&flattenedTx) - if err != nil { - 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) - return - } - - response, err = client.SubmitTxBlobAndWait(txBlob, false) - if err != nil { - 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("Try again!") - return - } - - fmt.Println("✅ Tokens sent from hot wallet to customer one!") - fmt.Printf("🌐 Hash: %s\n", response.Hash.String()) - fmt.Println() + // + // Configure client + // + fmt.Println("⏳ Setting up client...") + cfg, err := rpc.NewClientConfig( + "https://s.altnet.rippletest.net:51234/", + rpc.WithFaucetProvider(faucet.NewTestnetFaucetProvider()), + ) + if err != nil { + panic(err) + } + + client := rpc.NewClient(cfg) + fmt.Println("✅ Client configured!") + fmt.Println() + + // + // Configure wallets + // + fmt.Println("⏳ Setting up wallets...") + coldWallet, err := wallet.New(crypto.ED25519()) + if err != nil { + 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) + return + } + fmt.Println("💸 Cold wallet funded!") + + hotWallet, err := wallet.New(crypto.ED25519()) + if err != nil { + 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) + return + } + fmt.Println("💸 Hot wallet funded!") + + customerOneWallet, err := wallet.New(crypto.ED25519()) + if err != nil { + 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) + return + } + 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() + + // + // Configure cold address settings + // + fmt.Println("⏳ Configuring cold address settings...") + coldWalletAccountSet := &transactions.AccountSet{ + BaseTx: transactions.BaseTx{ + Account: types.Address(coldWallet.ClassicAddress), + }, + TickSize: types.TickSize(5), + TransferRate: types.TransferRate(0), + Domain: types.Domain("6578616D706C652E636F6D"), // example.com + } + + coldWalletAccountSet.SetAsfDefaultRipple() + coldWalletAccountSet.SetDisallowXRP() + + coldWalletAccountSet.SetRequireDestTag() + + flattenedTx := coldWalletAccountSet.Flatten() + + err = client.Autofill(&flattenedTx) + if err != nil { + 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) + return + } + + response, err := client.SubmitTxBlobAndWait(txBlob, false) + if err != nil { + fmt.Printf("❌ Error submitting transaction: %s\n", err) + return + } + + if !response.Validated { + 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() + + // + // Configure hot address settings + // + fmt.Println("⏳ Configuring hot address settings...") + hotWalletAccountSet := &transactions.AccountSet{ + BaseTx: transactions.BaseTx{ + Account: types.Address(hotWallet.ClassicAddress), + }, + Domain: types.Domain("6578616D706C652E636F6D"), // example.com + } + + hotWalletAccountSet.SetAsfRequireAuth() + hotWalletAccountSet.SetDisallowXRP() + hotWalletAccountSet.SetRequireDestTag() + + flattenedTx = hotWalletAccountSet.Flatten() + err = client.Autofill(&flattenedTx) + if err != nil { + 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) + return + } + + response, err = client.SubmitTxBlobAndWait(txBlob, false) + if err != nil { + fmt.Printf("❌ Error submitting transaction: %s\n", err) + return + } + + if !response.Validated { + 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() + + // + // Create 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), + }, + LimitAmount: types.IssuedCurrencyAmount{ + Currency: currencyCode, + Issuer: types.Address(coldWallet.ClassicAddress), + Value: "100000000000000", + }, + } + + flattenedTx = hotColdTrustSet.Flatten() + err = client.Autofill(&flattenedTx) + if err != nil { + 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) + return + } + + response, err = client.SubmitTxBlobAndWait(txBlob, false) + if err != nil { + 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("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() + + // + // Create trust line from costumer 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), + }, + LimitAmount: types.IssuedCurrencyAmount{ + Currency: currencyCode, + Issuer: types.Address(coldWallet.ClassicAddress), + Value: "100000000000000", + }, + } + + flattenedTx = customerOneColdTrustSet.Flatten() + err = client.Autofill(&flattenedTx) + if err != nil { + 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) + return + } + + response, err = client.SubmitTxBlobAndWait(txBlob, false) + if err != nil { + 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("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() + + // + // Send 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), + }, + Amount: types.IssuedCurrencyAmount{ + Currency: currencyCode, + Issuer: types.Address(coldWallet.ClassicAddress), + Value: "3800", + }, + Destination: types.Address(hotWallet.ClassicAddress), + DestinationTag: types.DestinationTag(1), + } + + flattenedTx = coldToHotPayment.Flatten() + err = client.Autofill(&flattenedTx) + if err != nil { + 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) + return + } + + response, err = client.SubmitTxBlobAndWait(txBlob, false) + if err != nil { + 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("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() + + // + // Send tokens from hot 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), + }, + Amount: types.IssuedCurrencyAmount{ + Currency: currencyCode, + Issuer: types.Address(coldWallet.ClassicAddress), + Value: "100", + }, + Destination: types.Address(customerOneWallet.ClassicAddress), + } + + flattenedTx = coldToCustomerOnePayment.Flatten() + err = client.Autofill(&flattenedTx) + if err != nil { + 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) + return + } + + response, err = client.SubmitTxBlobAndWait(txBlob, false) + if err != nil { + 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() + return + } + + 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...") + freezeColdWallet := &transactions.AccountSet{ + BaseTx: transactions.BaseTx{ + Account: types.Address(coldWallet.ClassicAddress), + }, + } + + freezeColdWallet.SetAsfGlobalFreeze() + + flattenedTx = freezeColdWallet.Flatten() + err = client.Autofill(&flattenedTx) + if err != nil { + 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) + return + } + + response, err = client.SubmitTxBlobAndWait(txBlob, false) + if err != nil { + 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() + return + } + + 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...") + hotToCustomerOnePayment := &transactions.Payment{ + BaseTx: transactions.BaseTx{ + Account: types.Address(hotWallet.ClassicAddress), + }, + Amount: types.IssuedCurrencyAmount{ + Currency: currencyCode, + Issuer: types.Address(coldWallet.ClassicAddress), + Value: "100", + }, + Destination: types.Address(customerOneWallet.ClassicAddress), + } + + flattenedTx = hotToCustomerOnePayment.Flatten() + err = client.Autofill(&flattenedTx) + if err != nil { + 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) + return + } + + _, err = client.SubmitTxBlobAndWait(txBlob, false) + if err == nil { + return + } + + fmt.Println("❌ Tokens not sent from hot wallet to customer one!") + fmt.Println() + + // // + // // Unfreeze cold wallet + // // + fmt.Println("⏳ Unfreezing cold wallet...") + unfreezeColdWallet := &transactions.AccountSet{ + BaseTx: transactions.BaseTx{ + Account: types.Address(coldWallet.ClassicAddress), + }, + } + + unfreezeColdWallet.ClearAsfGlobalFreeze() + + flattenedTx = unfreezeColdWallet.Flatten() + err = client.Autofill(&flattenedTx) + if err != nil { + 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) + return + } + + response, err = client.SubmitTxBlobAndWait(txBlob, false) + if err != nil { + 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() + return + } + + 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...") + hotToCustomerOnePayment = &transactions.Payment{ + BaseTx: transactions.BaseTx{ + Account: types.Address(hotWallet.ClassicAddress), + }, + Amount: types.IssuedCurrencyAmount{ + Currency: currencyCode, + Issuer: types.Address(coldWallet.ClassicAddress), + Value: "100", + }, + Destination: types.Address(customerOneWallet.ClassicAddress), + } + + flattenedTx = hotToCustomerOnePayment.Flatten() + err = client.Autofill(&flattenedTx) + if err != nil { + 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) + return + } + + response, err = client.SubmitTxBlobAndWait(txBlob, false) + if err != nil { + 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("Try again!") + return + } + + fmt.Println("✅ Tokens sent from hot wallet to customer one!") + fmt.Printf("🌐 Hash: %s\n", response.Hash.String()) + fmt.Println() } diff --git a/_code-samples/issue-a-token/go/ws/main.go b/_code-samples/issue-a-token/go/ws/main.go index 04a57383dd..6655fd952d 100644 --- a/_code-samples/issue-a-token/go/ws/main.go +++ b/_code-samples/issue-a-token/go/ws/main.go @@ -1,529 +1,529 @@ 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 ( - currencyCode = "FOO" + currencyCode = "FOO" ) func main() { - // - // Configure 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() - - fmt.Println("Connecting to server...") - if err := client.Connect(); err != nil { - fmt.Println(err) - return - } - - fmt.Println("Connection: ", client.IsConnected()) - fmt.Println() - - // - // Configure wallets - // - fmt.Println("⏳ Setting up wallets...") - coldWallet, err := wallet.New(crypto.ED25519()) - if err != nil { - 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) - return - } - fmt.Println("💸 Cold wallet funded!") - - hotWallet, err := wallet.New(crypto.ED25519()) - if err != nil { - 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) - return - } - fmt.Println("💸 Hot wallet funded!") - - customerOneWallet, err := wallet.New(crypto.ED25519()) - if err != nil { - 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) - return - } - 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() - - // - // Configure cold address settings - // - fmt.Println("⏳ Configuring cold address settings...") - coldWalletAccountSet := &transactions.AccountSet{ - BaseTx: transactions.BaseTx{ - Account: types.Address(coldWallet.ClassicAddress), - }, - TickSize: types.TickSize(5), - TransferRate: types.TransferRate(0), - Domain: types.Domain("6578616D706C652E636F6D"), // example.com - } - - coldWalletAccountSet.SetAsfDefaultRipple() - coldWalletAccountSet.SetDisallowXRP() - - coldWalletAccountSet.SetRequireDestTag() - - flattenedTx := coldWalletAccountSet.Flatten() - - err = client.Autofill(&flattenedTx) - if err != nil { - 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) - return - } - - response, err := client.SubmitTxBlobAndWait(txBlob, false) - if err != nil { - fmt.Printf("❌ Error submitting transaction: %s\n", err) - return - } - - if !response.Validated { - 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() - - // - // Configure hot address settings - // - fmt.Println("⏳ Configuring hot address settings...") - hotWalletAccountSet := &transactions.AccountSet{ - BaseTx: transactions.BaseTx{ - Account: types.Address(hotWallet.ClassicAddress), - }, - Domain: types.Domain("6578616D706C652E636F6D"), // example.com - } - - hotWalletAccountSet.SetAsfRequireAuth() - hotWalletAccountSet.SetDisallowXRP() - hotWalletAccountSet.SetRequireDestTag() - - flattenedTx = hotWalletAccountSet.Flatten() - err = client.Autofill(&flattenedTx) - if err != nil { - 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) - return - } - - response, err = client.SubmitTxBlobAndWait(txBlob, false) - if err != nil { - fmt.Printf("❌ Error submitting transaction: %s\n", err) - return - } - - if !response.Validated { - 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() - - // - // Create 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), - }, - LimitAmount: types.IssuedCurrencyAmount{ - Currency: currencyCode, - Issuer: types.Address(coldWallet.ClassicAddress), - Value: "100000000000000", - }, - } - - flattenedTx = hotColdTrustSet.Flatten() - err = client.Autofill(&flattenedTx) - if err != nil { - 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) - return - } - - response, err = client.SubmitTxBlobAndWait(txBlob, false) - if err != nil { - 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("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() - - // - // Create trust line from costumer 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), - }, - LimitAmount: types.IssuedCurrencyAmount{ - Currency: currencyCode, - Issuer: types.Address(coldWallet.ClassicAddress), - Value: "100000000000000", - }, - } - - flattenedTx = customerOneColdTrustSet.Flatten() - err = client.Autofill(&flattenedTx) - if err != nil { - 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) - return - } - - response, err = client.SubmitTxBlobAndWait(txBlob, false) - if err != nil { - 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("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() - - // - // Send 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), - }, - Amount: types.IssuedCurrencyAmount{ - Currency: currencyCode, - Issuer: types.Address(coldWallet.ClassicAddress), - Value: "3800", - }, - Destination: types.Address(hotWallet.ClassicAddress), - DestinationTag: types.DestinationTag(1), - } - - flattenedTx = coldToHotPayment.Flatten() - err = client.Autofill(&flattenedTx) - if err != nil { - 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) - return - } - - response, err = client.SubmitTxBlobAndWait(txBlob, false) - if err != nil { - 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("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() - - // - // Send tokens from hot 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), - }, - Amount: types.IssuedCurrencyAmount{ - Currency: currencyCode, - Issuer: types.Address(coldWallet.ClassicAddress), - Value: "100", - }, - Destination: types.Address(customerOneWallet.ClassicAddress), - } - - flattenedTx = coldToCustomerOnePayment.Flatten() - err = client.Autofill(&flattenedTx) - if err != nil { - 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) - return - } - - response, err = client.SubmitTxBlobAndWait(txBlob, false) - if err != nil { - 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() - return - } - - 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...") - freezeColdWallet := &transactions.AccountSet{ - BaseTx: transactions.BaseTx{ - Account: types.Address(coldWallet.ClassicAddress), - }, - } - - freezeColdWallet.SetAsfGlobalFreeze() - - flattenedTx = freezeColdWallet.Flatten() - err = client.Autofill(&flattenedTx) - if err != nil { - 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) - return - } - - response, err = client.SubmitTxBlobAndWait(txBlob, false) - if err != nil { - 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() - return - } - - 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...") - hotToCustomerOnePayment := &transactions.Payment{ - BaseTx: transactions.BaseTx{ - Account: types.Address(hotWallet.ClassicAddress), - }, - Amount: types.IssuedCurrencyAmount{ - Currency: currencyCode, - Issuer: types.Address(coldWallet.ClassicAddress), - Value: "100", - }, - Destination: types.Address(customerOneWallet.ClassicAddress), - } - - flattenedTx = hotToCustomerOnePayment.Flatten() - err = client.Autofill(&flattenedTx) - if err != nil { - 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) - return - } - - _, err = client.SubmitTxBlobAndWait(txBlob, false) - if err == nil { - return - } - - fmt.Println("❌ Tokens not sent from hot wallet to customer one!") - fmt.Println() - - // // - // // Unfreeze cold wallet - // // - fmt.Println("⏳ Unfreezing cold wallet...") - unfreezeColdWallet := &transactions.AccountSet{ - BaseTx: transactions.BaseTx{ - Account: types.Address(coldWallet.ClassicAddress), - }, - } - - unfreezeColdWallet.ClearAsfGlobalFreeze() - - flattenedTx = unfreezeColdWallet.Flatten() - err = client.Autofill(&flattenedTx) - if err != nil { - 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) - return - } - - response, err = client.SubmitTxBlobAndWait(txBlob, false) - if err != nil { - 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() - return - } - - 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...") - hotToCustomerOnePayment = &transactions.Payment{ - BaseTx: transactions.BaseTx{ - Account: types.Address(hotWallet.ClassicAddress), - }, - Amount: types.IssuedCurrencyAmount{ - Currency: currencyCode, - Issuer: types.Address(coldWallet.ClassicAddress), - Value: "100", - }, - Destination: types.Address(customerOneWallet.ClassicAddress), - } - - flattenedTx = hotToCustomerOnePayment.Flatten() - err = client.Autofill(&flattenedTx) - if err != nil { - 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) - return - } - - response, err = client.SubmitTxBlobAndWait(txBlob, false) - if err != nil { - 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("Try again!") - return - } - - fmt.Println("✅ Tokens sent from hot wallet to customer one!") - fmt.Printf("🌐 Hash: %s\n", response.Hash.String()) - fmt.Println() + // + // Configure 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() + + fmt.Println("Connecting to server...") + if err := client.Connect(); err != nil { + fmt.Println(err) + return + } + + fmt.Println("Connection: ", client.IsConnected()) + fmt.Println() + + // + // Configure wallets + // + fmt.Println("⏳ Setting up wallets...") + coldWallet, err := wallet.New(crypto.ED25519()) + if err != nil { + 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) + return + } + fmt.Println("💸 Cold wallet funded!") + + hotWallet, err := wallet.New(crypto.ED25519()) + if err != nil { + 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) + return + } + fmt.Println("💸 Hot wallet funded!") + + customerOneWallet, err := wallet.New(crypto.ED25519()) + if err != nil { + 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) + return + } + 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() + + // + // Configure cold address settings + // + fmt.Println("⏳ Configuring cold address settings...") + coldWalletAccountSet := &transactions.AccountSet{ + BaseTx: transactions.BaseTx{ + Account: types.Address(coldWallet.ClassicAddress), + }, + TickSize: types.TickSize(5), + TransferRate: types.TransferRate(0), + Domain: types.Domain("6578616D706C652E636F6D"), // example.com + } + + coldWalletAccountSet.SetAsfDefaultRipple() + coldWalletAccountSet.SetDisallowXRP() + + coldWalletAccountSet.SetRequireDestTag() + + flattenedTx := coldWalletAccountSet.Flatten() + + err = client.Autofill(&flattenedTx) + if err != nil { + 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) + return + } + + response, err := client.SubmitTxBlobAndWait(txBlob, false) + if err != nil { + fmt.Printf("❌ Error submitting transaction: %s\n", err) + return + } + + if !response.Validated { + 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() + + // + // Configure hot address settings + // + fmt.Println("⏳ Configuring hot address settings...") + hotWalletAccountSet := &transactions.AccountSet{ + BaseTx: transactions.BaseTx{ + Account: types.Address(hotWallet.ClassicAddress), + }, + Domain: types.Domain("6578616D706C652E636F6D"), // example.com + } + + hotWalletAccountSet.SetAsfRequireAuth() + hotWalletAccountSet.SetDisallowXRP() + hotWalletAccountSet.SetRequireDestTag() + + flattenedTx = hotWalletAccountSet.Flatten() + err = client.Autofill(&flattenedTx) + if err != nil { + 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) + return + } + + response, err = client.SubmitTxBlobAndWait(txBlob, false) + if err != nil { + fmt.Printf("❌ Error submitting transaction: %s\n", err) + return + } + + if !response.Validated { + 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() + + // + // Create 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), + }, + LimitAmount: types.IssuedCurrencyAmount{ + Currency: currencyCode, + Issuer: types.Address(coldWallet.ClassicAddress), + Value: "100000000000000", + }, + } + + flattenedTx = hotColdTrustSet.Flatten() + err = client.Autofill(&flattenedTx) + if err != nil { + 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) + return + } + + response, err = client.SubmitTxBlobAndWait(txBlob, false) + if err != nil { + 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("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() + + // + // Create trust line from costumer 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), + }, + LimitAmount: types.IssuedCurrencyAmount{ + Currency: currencyCode, + Issuer: types.Address(coldWallet.ClassicAddress), + Value: "100000000000000", + }, + } + + flattenedTx = customerOneColdTrustSet.Flatten() + err = client.Autofill(&flattenedTx) + if err != nil { + 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) + return + } + + response, err = client.SubmitTxBlobAndWait(txBlob, false) + if err != nil { + 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("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() + + // + // Send 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), + }, + Amount: types.IssuedCurrencyAmount{ + Currency: currencyCode, + Issuer: types.Address(coldWallet.ClassicAddress), + Value: "3800", + }, + Destination: types.Address(hotWallet.ClassicAddress), + DestinationTag: types.DestinationTag(1), + } + + flattenedTx = coldToHotPayment.Flatten() + err = client.Autofill(&flattenedTx) + if err != nil { + 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) + return + } + + response, err = client.SubmitTxBlobAndWait(txBlob, false) + if err != nil { + 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("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() + + // + // Send tokens from hot 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), + }, + Amount: types.IssuedCurrencyAmount{ + Currency: currencyCode, + Issuer: types.Address(coldWallet.ClassicAddress), + Value: "100", + }, + Destination: types.Address(customerOneWallet.ClassicAddress), + } + + flattenedTx = coldToCustomerOnePayment.Flatten() + err = client.Autofill(&flattenedTx) + if err != nil { + 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) + return + } + + response, err = client.SubmitTxBlobAndWait(txBlob, false) + if err != nil { + 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() + return + } + + 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...") + freezeColdWallet := &transactions.AccountSet{ + BaseTx: transactions.BaseTx{ + Account: types.Address(coldWallet.ClassicAddress), + }, + } + + freezeColdWallet.SetAsfGlobalFreeze() + + flattenedTx = freezeColdWallet.Flatten() + err = client.Autofill(&flattenedTx) + if err != nil { + 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) + return + } + + response, err = client.SubmitTxBlobAndWait(txBlob, false) + if err != nil { + 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() + return + } + + 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...") + hotToCustomerOnePayment := &transactions.Payment{ + BaseTx: transactions.BaseTx{ + Account: types.Address(hotWallet.ClassicAddress), + }, + Amount: types.IssuedCurrencyAmount{ + Currency: currencyCode, + Issuer: types.Address(coldWallet.ClassicAddress), + Value: "100", + }, + Destination: types.Address(customerOneWallet.ClassicAddress), + } + + flattenedTx = hotToCustomerOnePayment.Flatten() + err = client.Autofill(&flattenedTx) + if err != nil { + 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) + return + } + + _, err = client.SubmitTxBlobAndWait(txBlob, false) + if err == nil { + return + } + + fmt.Println("❌ Tokens not sent from hot wallet to customer one!") + fmt.Println() + + // // + // // Unfreeze cold wallet + // // + fmt.Println("⏳ Unfreezing cold wallet...") + unfreezeColdWallet := &transactions.AccountSet{ + BaseTx: transactions.BaseTx{ + Account: types.Address(coldWallet.ClassicAddress), + }, + } + + unfreezeColdWallet.ClearAsfGlobalFreeze() + + flattenedTx = unfreezeColdWallet.Flatten() + err = client.Autofill(&flattenedTx) + if err != nil { + 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) + return + } + + response, err = client.SubmitTxBlobAndWait(txBlob, false) + if err != nil { + 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() + return + } + + 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...") + hotToCustomerOnePayment = &transactions.Payment{ + BaseTx: transactions.BaseTx{ + Account: types.Address(hotWallet.ClassicAddress), + }, + Amount: types.IssuedCurrencyAmount{ + Currency: currencyCode, + Issuer: types.Address(coldWallet.ClassicAddress), + Value: "100", + }, + Destination: types.Address(customerOneWallet.ClassicAddress), + } + + flattenedTx = hotToCustomerOnePayment.Flatten() + err = client.Autofill(&flattenedTx) + if err != nil { + 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) + return + } + + response, err = client.SubmitTxBlobAndWait(txBlob, false) + if err != nil { + 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("Try again!") + return + } + + fmt.Println("✅ Tokens sent from hot wallet to customer one!") + fmt.Printf("🌐 Hash: %s\n", response.Hash.String()) + fmt.Println() } diff --git a/_code-samples/monitor-payments-websocket/go/monitor-incoming-payments.go b/_code-samples/monitor-payments-websocket/go/monitor-incoming-payments.go index 1096a6f576..ae704cd706 100644 --- a/_code-samples/monitor-payments-websocket/go/monitor-incoming-payments.go +++ b/_code-samples/monitor-payments-websocket/go/monitor-incoming-payments.go @@ -7,15 +7,15 @@ package main // install: go get github.com/gorilla/websocket import ( - "encoding/json" - "flag" - "log" - "net/url" - "os" - "os/signal" - "time" + "encoding/json" + "flag" + "log" + "net/url" + "os" + "os/signal" + "time" - "github.com/gorilla/websocket" + "github.com/gorilla/websocket" ) // websocket address @@ -23,75 +23,75 @@ var addr = flag.String("addr", "s.altnet.rippletest.net:51233", "http service ad // Payload object type message struct { - Command string `json:"command"` - Accounts []string `json:"accounts"` + Command string `json:"command"` + Accounts []string `json:"accounts"` } func main() { - flag.Parse() - log.SetFlags(0) + flag.Parse() + log.SetFlags(0) - var m message + var m message - // check for interrupts and cleanly close the connection - interrupt := make(chan os.Signal, 1) - signal.Notify(interrupt, os.Interrupt) + // check for interrupts and cleanly close the connection + interrupt := make(chan os.Signal, 1) + signal.Notify(interrupt, os.Interrupt) - u := url.URL{Scheme: "ws", Host: *addr, Path: "/"} - log.Printf("connecting to %s", u.String()) + u := url.URL{Scheme: "ws", Host: *addr, Path: "/"} + log.Printf("connecting to %s", u.String()) - // make the connection - c, _, err := websocket.DefaultDialer.Dial(u.String(), nil) - if err != nil { - log.Fatal("dial:", err) - } - // on exit close - defer c.Close() + // make the connection + c, _, err := websocket.DefaultDialer.Dial(u.String(), nil) + if err != nil { + log.Fatal("dial:", err) + } + // on exit close + defer c.Close() - done := make(chan struct{}) + done := make(chan struct{}) - // send a subscribe command and a target XRPL account - m.Command = "subscribe" - m.Accounts = append(m.Accounts, "rUCzEr6jrEyMpjhs4wSdQdz4g8Y382NxfM") + // send a subscribe command and a target XRPL account + m.Command = "subscribe" + m.Accounts = append(m.Accounts, "rUCzEr6jrEyMpjhs4wSdQdz4g8Y382NxfM") - // struct to JSON marshalling - msg, _ := json.Marshal(m) - // write to the websocket - err = c.WriteMessage(websocket.TextMessage, []byte(string(msg))) - if err != nil { - log.Println("write:", err) - return - } + // struct to JSON marshalling + msg, _ := json.Marshal(m) + // write to the websocket + err = c.WriteMessage(websocket.TextMessage, []byte(string(msg))) + if err != nil { + log.Println("write:", err) + return + } - // read from the websocket - _, message, err := c.ReadMessage() - if err != nil { - log.Println("read:", err) - return - } - // print the response from the XRP Ledger - log.Printf("recv: %s", message) + // read from the websocket + _, message, err := c.ReadMessage() + if err != nil { + log.Println("read:", err) + return + } + // print the response from the XRP Ledger + log.Printf("recv: %s", message) - // handle interrupt - for { - select { - case <-done: - return - case <-interrupt: - log.Println("interrupt") + // handle interrupt + for { + select { + case <-done: + return + case <-interrupt: + log.Println("interrupt") - // Cleanly close the connection by sending a close message and then - // waiting (with timeout) for the server to close the connection. - err := c.WriteMessage(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseNormalClosure, "")) - if err != nil { - log.Println("write close:", err) - return - } - select { - case <-done: - case <-time.After(time.Second): - } - return - } - } + // Cleanly close the connection by sending a close message and then + // waiting (with timeout) for the server to close the connection. + err := c.WriteMessage(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseNormalClosure, "")) + if err != nil { + log.Println("write close:", err) + return + } + select { + case <-done: + case <-time.After(time.Second): + } + return + } + } } diff --git a/_code-samples/multisigning/go/rpc/main.go b/_code-samples/multisigning/go/rpc/main.go index 447c8f8cf1..b281f86e30 100644 --- a/_code-samples/multisigning/go/rpc/main.go +++ b/_code-samples/multisigning/go/rpc/main.go @@ -1,166 +1,166 @@ 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() { - cfg, err := rpc.NewClientConfig( - "https://s.altnet.rippletest.net:51234/", - rpc.WithFaucetProvider(faucet.NewTestnetFaucetProvider()), - ) - if err != nil { - panic(err) - } + cfg, err := rpc.NewClientConfig( + "https://s.altnet.rippletest.net:51234/", + rpc.WithFaucetProvider(faucet.NewTestnetFaucetProvider()), + ) + if err != nil { + panic(err) + } - client := rpc.NewClient(cfg) + client := rpc.NewClient(cfg) - w1, err := wallet.FromSeed("sEdTtvLmJmrb7GaivhWoXRkvU4NDjVf", "") - if err != nil { - fmt.Println(err) - return - } + w1, err := wallet.FromSeed("sEdTtvLmJmrb7GaivhWoXRkvU4NDjVf", "") + if err != nil { + fmt.Println(err) + return + } - w2, err := wallet.FromSeed("sEdSFiKMQp7RvYLgH7t7FEpwNRWv2Gr", "") - if err != nil { - fmt.Println(err) - return - } + w2, err := wallet.FromSeed("sEdSFiKMQp7RvYLgH7t7FEpwNRWv2Gr", "") + if err != nil { + fmt.Println(err) + return + } - master, err := wallet.FromSeed("sEdTMm2yv8c8Rg8YHFHQA9TxVMFy1ze", "") - if err != nil { - fmt.Println(err) - return - } + master, err := wallet.FromSeed("sEdTMm2yv8c8Rg8YHFHQA9TxVMFy1ze", "") + if err != nil { + fmt.Println(err) + 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") + if err := client.FundWallet(&w1); err != nil { + fmt.Println(err) + return + } + fmt.Println("💸 Wallet 1 funded") - if err := client.FundWallet(&w2); err != nil { - fmt.Println(err) - return - } + 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() - fmt.Println("⏳ Setting up signer list...") + if err := client.FundWallet(&master); err != nil { + fmt.Println(err) + return + } + fmt.Println("💸 Master wallet funded") + fmt.Println() + fmt.Println("⏳ Setting up signer list...") - ss := &transaction.SignerListSet{ - BaseTx: transaction.BaseTx{ - Account: master.GetAddress(), - }, - SignerQuorum: uint32(2), - SignerEntries: []ledger.SignerEntryWrapper{ - { - SignerEntry: ledger.SignerEntry{ - Account: w1.GetAddress(), - SignerWeight: 1, - }, - }, - { - SignerEntry: ledger.SignerEntry{ - Account: w2.GetAddress(), - SignerWeight: 1, - }, - }, - { - SignerEntry: ledger.SignerEntry{ - Account: "XVYRdEocC28DRx94ZFGP3qNJ1D5Ln7ecXFMd3vREB5Pesju", - SignerWeight: 1, - }, - }, - }, - } + ss := &transaction.SignerListSet{ + BaseTx: transaction.BaseTx{ + Account: master.GetAddress(), + }, + SignerQuorum: uint32(2), + SignerEntries: []ledger.SignerEntryWrapper{ + { + SignerEntry: ledger.SignerEntry{ + Account: w1.GetAddress(), + SignerWeight: 1, + }, + }, + { + SignerEntry: ledger.SignerEntry{ + Account: w2.GetAddress(), + SignerWeight: 1, + }, + }, + { + SignerEntry: ledger.SignerEntry{ + Account: "XVYRdEocC28DRx94ZFGP3qNJ1D5Ln7ecXFMd3vREB5Pesju", + SignerWeight: 1, + }, + }, + }, + } - flatSs := ss.Flatten() + flatSs := ss.Flatten() - if err := client.Autofill(&flatSs); err != nil { - fmt.Println(err) - return - } + if err := client.Autofill(&flatSs); err != nil { + fmt.Println(err) + return + } - blob, _, err := master.Sign(flatSs) - if err != nil { - fmt.Println(err) - return - } + blob, _, err := master.Sign(flatSs) + if err != nil { + fmt.Println(err) + return + } - res, err := client.SubmitTxBlobAndWait(blob, false) - if err != nil { - fmt.Println(err) - return - } + 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() + 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{ - Account: master.GetAddress(), - }, - Domain: types.Domain(strings.ToUpper(hex.EncodeToString([]byte("example.com")))), - } + as := &transaction.AccountSet{ + BaseTx: transaction.BaseTx{ + Account: master.GetAddress(), + }, + Domain: types.Domain(strings.ToUpper(hex.EncodeToString([]byte("example.com")))), + } - flatAs := as.Flatten() + flatAs := as.Flatten() - if err := client.AutofillMultisigned(&flatAs, 2); err != nil { - fmt.Println(err) - return - } + if err := client.AutofillMultisigned(&flatAs, 2); err != nil { + fmt.Println(err) + return + } - w1As := maps.Clone(flatAs) + w1As := maps.Clone(flatAs) - blob1, _, err := w1.Multisign(w1As) - if err != nil { - fmt.Println(err) - return - } + blob1, _, err := w1.Multisign(w1As) + if err != nil { + fmt.Println(err) + return + } - w2As := maps.Clone(flatAs) + w2As := maps.Clone(flatAs) - blob2, _, err := w2.Multisign(w2As) - if err != nil { - fmt.Println(err) - return - } + blob2, _, err := w2.Multisign(w2As) + if err != nil { + fmt.Println(err) + return + } - blob, err = xrpl.Multisign(blob1, blob2) - if err != nil { - fmt.Println(err) - return - } + blob, err = xrpl.Multisign(blob1, blob2) + if err != nil { + fmt.Println(err) + return + } - mRes, err := client.SubmitMultisigned(blob, false) - if err != nil { - fmt.Println(err) - return - } + mRes, err := client.SubmitMultisigned(blob, false) + if err != nil { + fmt.Println(err) + 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) } diff --git a/_code-samples/multisigning/go/ws/main.go b/_code-samples/multisigning/go/ws/main.go index 88abba06a3..e5ae17d0a7 100644 --- a/_code-samples/multisigning/go/ws/main.go +++ b/_code-samples/multisigning/go/ws/main.go @@ -1,181 +1,181 @@ 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...") - client := websocket.NewClient( - websocket.NewClientConfig(). - WithHost("wss://s.altnet.rippletest.net:51233"). - WithFaucetProvider(faucet.NewTestnetFaucetProvider()), - ) - defer client.Disconnect() + fmt.Println("⏳ Connecting to testnet...") + client := websocket.NewClient( + websocket.NewClientConfig(). + WithHost("wss://s.altnet.rippletest.net:51233"). + WithFaucetProvider(faucet.NewTestnetFaucetProvider()), + ) + defer client.Disconnect() - if err := client.Connect(); err != nil { - fmt.Println(err) - return - } + if err := client.Connect(); err != nil { + fmt.Println(err) + return + } - if !client.IsConnected() { - fmt.Println("❌ Failed to connect to testnet") - return - } + if !client.IsConnected() { + fmt.Println("❌ Failed to connect to testnet") + return + } - fmt.Println("✅ Connected to testnet") - fmt.Println() + fmt.Println("✅ Connected to testnet") + fmt.Println() - w1, err := wallet.FromSeed("sEdTtvLmJmrb7GaivhWoXRkvU4NDjVf", "") - if err != nil { - fmt.Println(err) - return - } + w1, err := wallet.FromSeed("sEdTtvLmJmrb7GaivhWoXRkvU4NDjVf", "") + if err != nil { + fmt.Println(err) + return + } - w2, err := wallet.FromSeed("sEdSFiKMQp7RvYLgH7t7FEpwNRWv2Gr", "") - if err != nil { - fmt.Println(err) - return - } + w2, err := wallet.FromSeed("sEdSFiKMQp7RvYLgH7t7FEpwNRWv2Gr", "") + if err != nil { + fmt.Println(err) + return + } - master, err := wallet.FromSeed("sEdTMm2yv8c8Rg8YHFHQA9TxVMFy1ze", "") - if err != nil { - fmt.Println(err) - return - } + master, err := wallet.FromSeed("sEdTMm2yv8c8Rg8YHFHQA9TxVMFy1ze", "") + if err != nil { + fmt.Println(err) + 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") + if err := client.FundWallet(&w1); err != nil { + fmt.Println(err) + return + } + fmt.Println("💸 Wallet 1 funded") - if err := client.FundWallet(&w2); err != nil { - fmt.Println(err) - return - } + 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() - fmt.Println("⏳ Setting up signer list...") + if err := client.FundWallet(&master); err != nil { + fmt.Println(err) + return + } + fmt.Println("💸 Master wallet funded") + fmt.Println() + fmt.Println("⏳ Setting up signer list...") - ss := &transaction.SignerListSet{ - BaseTx: transaction.BaseTx{ - Account: master.GetAddress(), - }, - SignerQuorum: uint32(2), - SignerEntries: []ledger.SignerEntryWrapper{ - { - SignerEntry: ledger.SignerEntry{ - Account: w1.GetAddress(), - SignerWeight: 1, - }, - }, - { - SignerEntry: ledger.SignerEntry{ - Account: w2.GetAddress(), - SignerWeight: 1, - }, - }, - { - SignerEntry: ledger.SignerEntry{ - Account: "XVYRdEocC28DRx94ZFGP3qNJ1D5Ln7ecXFMd3vREB5Pesju", - SignerWeight: 1, - }, - }, - }, - } + ss := &transaction.SignerListSet{ + BaseTx: transaction.BaseTx{ + Account: master.GetAddress(), + }, + SignerQuorum: uint32(2), + SignerEntries: []ledger.SignerEntryWrapper{ + { + SignerEntry: ledger.SignerEntry{ + Account: w1.GetAddress(), + SignerWeight: 1, + }, + }, + { + SignerEntry: ledger.SignerEntry{ + Account: w2.GetAddress(), + SignerWeight: 1, + }, + }, + { + SignerEntry: ledger.SignerEntry{ + Account: "XVYRdEocC28DRx94ZFGP3qNJ1D5Ln7ecXFMd3vREB5Pesju", + SignerWeight: 1, + }, + }, + }, + } - fmt.Println("⏳ Flattening transaction...") - flatSs := ss.Flatten() + fmt.Println("⏳ Flattening transaction...") + flatSs := ss.Flatten() - fmt.Println("⏳ Autofilling transaction...") - if err := client.Autofill(&flatSs); err != nil { - fmt.Println(err) - return - } + fmt.Println("⏳ Autofilling transaction...") + if err := client.Autofill(&flatSs); err != nil { + fmt.Println(err) + return + } - fmt.Println("⏳ Signing transaction...") - blob, _, err := master.Sign(flatSs) - if err != nil { - fmt.Println(err) - return - } + fmt.Println("⏳ Signing transaction...") + blob, _, err := master.Sign(flatSs) + if err != nil { + fmt.Println(err) + return + } - fmt.Println("⏳ Submitting transaction...") - res, err := client.SubmitTxBlobAndWait(blob, false) - if err != nil { - fmt.Println(err) - return - } + 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() + 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{ - Account: master.GetAddress(), - }, - Domain: types.Domain(strings.ToUpper(hex.EncodeToString([]byte("example.com")))), - } + as := &transaction.AccountSet{ + BaseTx: transaction.BaseTx{ + Account: master.GetAddress(), + }, + Domain: types.Domain(strings.ToUpper(hex.EncodeToString([]byte("example.com")))), + } - flatAs := as.Flatten() + flatAs := as.Flatten() - if err := client.AutofillMultisigned(&flatAs, 2); err != nil { - fmt.Println(err) - return - } + if err := client.AutofillMultisigned(&flatAs, 2); err != nil { + fmt.Println(err) + return + } - w1As := maps.Clone(flatAs) + w1As := maps.Clone(flatAs) - blob1, _, err := w1.Multisign(w1As) - if err != nil { - fmt.Println(err) - return - } + blob1, _, err := w1.Multisign(w1As) + if err != nil { + fmt.Println(err) + return + } - w2As := maps.Clone(flatAs) + w2As := maps.Clone(flatAs) - blob2, _, err := w2.Multisign(w2As) - if err != nil { - fmt.Println(err) - return - } + blob2, _, err := w2.Multisign(w2As) + if err != nil { + fmt.Println(err) + return + } - blob, err = xrpl.Multisign(blob1, blob2) - if err != nil { - fmt.Println(err) - return - } + blob, err = xrpl.Multisign(blob1, blob2) + if err != nil { + fmt.Println(err) + return + } - mRes, err := client.SubmitMultisigned(blob, false) - if err != nil { - fmt.Println(err) - return - } + mRes, err := client.SubmitMultisigned(blob, false) + if err != nil { + fmt.Println(err) + 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) } diff --git a/_code-samples/non-fungible-token/go/nft-accept/rpc/main.go b/_code-samples/non-fungible-token/go/nft-accept/rpc/main.go index 72bbe964c7..9b2affc0c2 100644 --- a/_code-samples/non-fungible-token/go/nft-accept/rpc/main.go +++ b/_code-samples/non-fungible-token/go/nft-accept/rpc/main.go @@ -1,128 +1,128 @@ 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() { - // Initialize the RPC client configuration - cfg, err := rpc.NewClientConfig( - "https://s.devnet.rippletest.net:51234/", - rpc.WithFaucetProvider(faucet.NewDevnetFaucetProvider()), - ) - if err != nil { - panic(err) - } + // Initialize the RPC client configuration + cfg, err := rpc.NewClientConfig( + "https://s.devnet.rippletest.net:51234/", + rpc.WithFaucetProvider(faucet.NewDevnetFaucetProvider()), + ) + if err != nil { + panic(err) + } - // Create the RPC client - client := rpc.NewClient(cfg) + // Create the RPC client + client := rpc.NewClient(cfg) - // Step 1: Fund wallets - fmt.Println("⏳ Funding wallets...") + // Step 1: Fund 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) - return - } - if err := client.FundWallet(&nftMinter); err != nil { - fmt.Println("❌ Error funding NFT minter wallet:", err) - return - } - fmt.Println("💸 NFT minter wallet funded!") + // Create and fund the NFT minter wallet + nftMinter, err := wallet.New(crypto.ED25519()) + if err != nil { + fmt.Println("❌ Error creating NFT minter wallet:", err) + return + } + if err := client.FundWallet(&nftMinter); err != nil { + fmt.Println("❌ Error funding NFT minter wallet:", err) + return + } + 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) - return - } - if err := client.FundWallet(&nftBuyer); err != nil { - fmt.Println("❌ Error funding NFT buyer wallet:", err) - return - } - fmt.Println("💸 NFT buyer wallet funded!") - fmt.Println() + // Create and fund the NFT buyer wallet + nftBuyer, err := wallet.New(crypto.ED25519()) + if err != nil { + fmt.Println("❌ Error creating NFT buyer wallet:", err) + return + } + if err := client.FundWallet(&nftBuyer); err != nil { + fmt.Println("❌ Error funding NFT buyer wallet:", err) + return + } + fmt.Println("💸 NFT buyer wallet funded!") + fmt.Println() - // Step 2: Mint an NFT - fmt.Println("⏳ Minting NFT...") + // Step 2: Mint an NFT + fmt.Println("⏳ Minting NFT...") - nftMint := transaction.NFTokenMint{ - BaseTx: transaction.BaseTx{ - Account: nftMinter.ClassicAddress, - TransactionType: transaction.NFTokenMintTx, - }, - Destination: nftBuyer.ClassicAddress, - Amount: txnTypes.XRPCurrencyAmount(1000000), // 1 XRP - NFTokenTaxon: 0, - URI: txnTypes.NFTokenURI("68747470733A2F2F676F6F676C652E636F6D"), // https://google.com - } - nftMint.SetTransferableFlag() + nftMint := transaction.NFTokenMint{ + BaseTx: transaction.BaseTx{ + Account: nftMinter.ClassicAddress, + TransactionType: transaction.NFTokenMintTx, + }, + Destination: nftBuyer.ClassicAddress, + Amount: txnTypes.XRPCurrencyAmount(1000000), // 1 XRP + NFTokenTaxon: 0, + URI: txnTypes.NFTokenURI("68747470733A2F2F676F6F676C652E636F6D"), // https://google.com + } + nftMint.SetTransferableFlag() - responseMint, err := client.SubmitTxAndWait(nftMint.Flatten(), &types.SubmitOptions{ - Autofill: true, - Wallet: &nftMinter, - }) - if err != nil { - fmt.Println("❌ Error minting NFT:", err) - return - } - if !responseMint.Validated { - fmt.Println("❌ NFTokenMint txn is not in a validated ledger", responseMint) - return - } - fmt.Println("✅ NFT minted successfully! - 🌎 Hash: ", responseMint.Hash) - fmt.Println() + responseMint, err := client.SubmitTxAndWait(nftMint.Flatten(), &types.SubmitOptions{ + Autofill: true, + Wallet: &nftMinter, + }) + if err != nil { + fmt.Println("❌ Error minting NFT:", err) + return + } + if !responseMint.Validated { + fmt.Println("❌ NFTokenMint txn is not in a validated ledger", responseMint) + return + } + fmt.Println("✅ NFT minted successfully! - 🌎 Hash: ", responseMint.Hash) + fmt.Println() - // Step 3: Retrieve the NFT token offer ID - fmt.Println("⏳ Retrieving NFT offer ID...") + // Step 3: Retrieve the NFT token 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") - return - } + metaMap, ok := responseMint.Meta.(map[string]any) + if !ok { + 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") - return - } + offerID, ok := metaMap["offer_id"].(string) + if !ok { + fmt.Println("❌ offer_id not found or not a string") + return + } - fmt.Println("🌎 offer_id:", offerID) - fmt.Println() + fmt.Println("🌎 offer_id:", offerID) + fmt.Println() - // Step 4: Accept the NFT offer - fmt.Println("⏳ Accepting NFT offer...") + // Step 4: Accept the NFT offer + fmt.Println("⏳ Accepting NFT offer...") - nftAccept := transaction.NFTokenAcceptOffer{ - BaseTx: transaction.BaseTx{ - Account: nftBuyer.ClassicAddress, - TransactionType: transaction.NFTokenAcceptOfferTx, - }, - NFTokenSellOffer: txnTypes.Hash256(offerID), - } + nftAccept := transaction.NFTokenAcceptOffer{ + BaseTx: transaction.BaseTx{ + Account: nftBuyer.ClassicAddress, + TransactionType: transaction.NFTokenAcceptOfferTx, + }, + NFTokenSellOffer: txnTypes.Hash256(offerID), + } - response, err := client.SubmitTxAndWait(nftAccept.Flatten(), &types.SubmitOptions{ - Autofill: true, - Wallet: &nftBuyer, - }) - if err != nil { - fmt.Println("❌ Error accepting NFT offer:", err) - return - } - if !response.Validated { - fmt.Println("❌ NFTokenAcceptOffer txn is not in a validated ledger", response) - return - } - fmt.Println("✅ NFT offer accepted successfully! - 🌎 Hash: ", response.Hash) + response, err := client.SubmitTxAndWait(nftAccept.Flatten(), &types.SubmitOptions{ + Autofill: true, + Wallet: &nftBuyer, + }) + if err != nil { + fmt.Println("❌ Error accepting NFT offer:", err) + return + } + if !response.Validated { + fmt.Println("❌ NFTokenAcceptOffer txn is not in a validated ledger", response) + return + } + fmt.Println("✅ NFT offer accepted successfully! - 🌎 Hash: ", response.Hash) } diff --git a/_code-samples/non-fungible-token/go/nft-accept/ws/main.go b/_code-samples/non-fungible-token/go/nft-accept/ws/main.go index d25ac1e4d0..2d988e6b1e 100644 --- a/_code-samples/non-fungible-token/go/nft-accept/ws/main.go +++ b/_code-samples/non-fungible-token/go/nft-accept/ws/main.go @@ -1,133 +1,133 @@ 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...") - client := websocket.NewClient( - websocket.NewClientConfig(). - WithHost("wss://s.devnet.rippletest.net:51233"). - WithFaucetProvider(faucet.NewDevnetFaucetProvider()), - ) - defer client.Disconnect() + // Connect to the XRPL devnet + fmt.Println("⏳ Connecting to devnet...") + client := websocket.NewClient( + websocket.NewClientConfig(). + WithHost("wss://s.devnet.rippletest.net:51233"). + WithFaucetProvider(faucet.NewDevnetFaucetProvider()), + ) + defer client.Disconnect() - if err := client.Connect(); err != nil { - fmt.Println("❌ Error connecting to devnet:", err) - return - } + if err := client.Connect(); err != nil { + fmt.Println("❌ Error connecting to devnet:", err) + return + } - if !client.IsConnected() { - fmt.Println("❌ Failed to connect to devnet") - return - } - fmt.Println("✅ Connected to devnet") - fmt.Println() + if !client.IsConnected() { + fmt.Println("❌ Failed to connect to devnet") + return + } + fmt.Println("✅ Connected to devnet") + fmt.Println() - // Fund wallets - fmt.Println("⏳ Funding wallets...") + // Fund 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) - return - } - if err := client.FundWallet(&nftMinter); err != nil { - fmt.Println("❌ Error funding NFT minter wallet:", err) - return - } - fmt.Println("💸 NFT minter wallet funded!") + // Create and fund the NFT minter wallet + nftMinter, err := wallet.New(crypto.ED25519()) + if err != nil { + fmt.Println("❌ Error creating NFT minter wallet:", err) + return + } + if err := client.FundWallet(&nftMinter); err != nil { + fmt.Println("❌ Error funding NFT minter wallet:", err) + return + } + 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) - return - } - if err := client.FundWallet(&nftBuyer); err != nil { - fmt.Println("❌ Error funding NFT buyer wallet:", err) - return - } - fmt.Println("💸 NFT buyer wallet funded!") - fmt.Println() + // Create and fund the NFT buyer wallet + nftBuyer, err := wallet.New(crypto.ED25519()) + if err != nil { + fmt.Println("❌ Error creating NFT buyer wallet:", err) + return + } + if err := client.FundWallet(&nftBuyer); err != nil { + fmt.Println("❌ Error funding NFT buyer wallet:", err) + return + } + fmt.Println("💸 NFT buyer wallet funded!") + fmt.Println() - // Mint an NFT - fmt.Println("⏳ Minting NFT...") - nftMint := transaction.NFTokenMint{ - BaseTx: transaction.BaseTx{ - Account: nftMinter.ClassicAddress, - TransactionType: transaction.NFTokenMintTx, - }, - Destination: nftBuyer.ClassicAddress, - Amount: txnTypes.XRPCurrencyAmount(1000000), // 1 XRP - NFTokenTaxon: 0, - URI: txnTypes.NFTokenURI("68747470733A2F2F676F6F676C652E636F6D"), // https://google.com - } - nftMint.SetTransferableFlag() + // Mint an NFT + fmt.Println("⏳ Minting NFT...") + nftMint := transaction.NFTokenMint{ + BaseTx: transaction.BaseTx{ + Account: nftMinter.ClassicAddress, + TransactionType: transaction.NFTokenMintTx, + }, + Destination: nftBuyer.ClassicAddress, + Amount: txnTypes.XRPCurrencyAmount(1000000), // 1 XRP + NFTokenTaxon: 0, + URI: txnTypes.NFTokenURI("68747470733A2F2F676F6F676C652E636F6D"), // https://google.com + } + nftMint.SetTransferableFlag() - responseMint, err := client.SubmitTxAndWait(nftMint.Flatten(), &types.SubmitOptions{ - Autofill: true, - Wallet: &nftMinter, - }) - if err != nil { - fmt.Println("❌ Error minting NFT:", err) - return - } - if !responseMint.Validated { - fmt.Println("❌ NFTokenMint transaction is not in a validated ledger:", responseMint) - return - } - fmt.Println("✅ NFT minted successfully! - 🌎 Hash:", responseMint.Hash) - fmt.Println() + responseMint, err := client.SubmitTxAndWait(nftMint.Flatten(), &types.SubmitOptions{ + Autofill: true, + Wallet: &nftMinter, + }) + if err != nil { + fmt.Println("❌ Error minting NFT:", err) + return + } + if !responseMint.Validated { + fmt.Println("❌ NFTokenMint transaction is not in a validated ledger:", responseMint) + return + } + 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...") - metaMap, ok := responseMint.Meta.(map[string]any) - if !ok { - fmt.Println("❌ Meta is not a map[string]any") - return - } + // Extract the NFT token offer ID from the transaction metadata + fmt.Println("⏳ Extracting offer ID...") + metaMap, ok := responseMint.Meta.(map[string]any) + if !ok { + 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") - return - } - fmt.Println("🌎 offer_id:", offerID) - fmt.Println() + offerID, ok := metaMap["offer_id"].(string) + if !ok { + fmt.Println("❌ offer_id not found or not a string") + return + } + fmt.Println("🌎 offer_id:", offerID) + fmt.Println() - // Accept the NFT offer - fmt.Println("⏳ Accepting NFT offer...") - nftAccept := transaction.NFTokenAcceptOffer{ - BaseTx: transaction.BaseTx{ - Account: nftBuyer.ClassicAddress, - TransactionType: transaction.NFTokenAcceptOfferTx, - }, - NFTokenSellOffer: txnTypes.Hash256(offerID), - } + // Accept the NFT offer + fmt.Println("⏳ Accepting NFT offer...") + nftAccept := transaction.NFTokenAcceptOffer{ + BaseTx: transaction.BaseTx{ + Account: nftBuyer.ClassicAddress, + TransactionType: transaction.NFTokenAcceptOfferTx, + }, + NFTokenSellOffer: txnTypes.Hash256(offerID), + } - response, err := client.SubmitTxAndWait(nftAccept.Flatten(), &types.SubmitOptions{ - Autofill: true, - Wallet: &nftBuyer, - }) - if err != nil { - fmt.Println("❌ Error accepting NFT offer:", err) - return - } - if !response.Validated { - fmt.Println("❌ NFTokenAcceptOffer transaction is not in a validated ledger:", response) - return - } - fmt.Println("✅ NFT offer accepted successfully! - 🌎 Hash:", response.Hash) + response, err := client.SubmitTxAndWait(nftAccept.Flatten(), &types.SubmitOptions{ + Autofill: true, + Wallet: &nftBuyer, + }) + if err != nil { + fmt.Println("❌ Error accepting NFT offer:", err) + return + } + if !response.Validated { + fmt.Println("❌ NFTokenAcceptOffer transaction is not in a validated ledger:", response) + return + } + fmt.Println("✅ NFT offer accepted successfully! - 🌎 Hash:", response.Hash) } diff --git a/_code-samples/non-fungible-token/go/nft-burn/rpc/main.go b/_code-samples/non-fungible-token/go/nft-burn/rpc/main.go index 317fe6be7e..179e30d315 100644 --- a/_code-samples/non-fungible-token/go/nft-burn/rpc/main.go +++ b/_code-samples/non-fungible-token/go/nft-burn/rpc/main.go @@ -1,114 +1,114 @@ 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() { - // Initialize the RPC client configuration - cfg, err := rpc.NewClientConfig( - "https://s.devnet.rippletest.net:51234/", - rpc.WithFaucetProvider(faucet.NewDevnetFaucetProvider()), - ) - if err != nil { - panic(err) - } + // Initialize the RPC client configuration + cfg, err := rpc.NewClientConfig( + "https://s.devnet.rippletest.net:51234/", + rpc.WithFaucetProvider(faucet.NewDevnetFaucetProvider()), + ) + if err != nil { + panic(err) + } - // Create the RPC client - client := rpc.NewClient(cfg) + // Create the RPC client + client := rpc.NewClient(cfg) - // Step 1: Fund wallets - fmt.Println("⏳ Funding wallets...") + // Step 1: Fund 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) - return - } - if err := client.FundWallet(&nftMinter); err != nil { - fmt.Println("❌ Error funding NFT minter wallet:", err) - return - } - fmt.Println("💸 NFT minter wallet funded!") - fmt.Println() + // Create and fund the NFT minter wallet + nftMinter, err := wallet.New(crypto.ED25519()) + if err != nil { + fmt.Println("❌ Error creating NFT minter wallet:", err) + return + } + if err := client.FundWallet(&nftMinter); err != nil { + fmt.Println("❌ Error funding NFT minter wallet:", err) + return + } + fmt.Println("💸 NFT minter wallet funded!") + fmt.Println() - // Step 2: Mint an NFT - fmt.Println("⏳ Minting NFT...") + // Step 2: Mint an NFT + fmt.Println("⏳ Minting NFT...") - nftMint := transaction.NFTokenMint{ - BaseTx: transaction.BaseTx{ - Account: nftMinter.ClassicAddress, - TransactionType: transaction.NFTokenMintTx, - }, - NFTokenTaxon: 0, - URI: txnTypes.NFTokenURI("68747470733A2F2F676F6F676C652E636F6D"), // https://google.com - } - nftMint.SetTransferableFlag() + nftMint := transaction.NFTokenMint{ + BaseTx: transaction.BaseTx{ + Account: nftMinter.ClassicAddress, + TransactionType: transaction.NFTokenMintTx, + }, + NFTokenTaxon: 0, + URI: txnTypes.NFTokenURI("68747470733A2F2F676F6F676C652E636F6D"), // https://google.com + } + nftMint.SetTransferableFlag() - responseMint, err := client.SubmitTxAndWait(nftMint.Flatten(), &types.SubmitOptions{ - Autofill: true, - Wallet: &nftMinter, - }) - if err != nil { - fmt.Println("❌ Error minting NFT:", err) - return - } - if !responseMint.Validated { - fmt.Println("❌ NFTokenMint txn is not in a validated ledger", responseMint) - return - } - fmt.Println("✅ NFT minted successfully! - 🌎 Hash: ", responseMint.Hash) - fmt.Println() + responseMint, err := client.SubmitTxAndWait(nftMint.Flatten(), &types.SubmitOptions{ + Autofill: true, + Wallet: &nftMinter, + }) + if err != nil { + fmt.Println("❌ Error minting NFT:", err) + return + } + if !responseMint.Validated { + fmt.Println("❌ NFTokenMint txn is not in a validated ledger", responseMint) + return + } + fmt.Println("✅ NFT minted successfully! - 🌎 Hash: ", responseMint.Hash) + fmt.Println() - // Step 3: Retrieve the token ID - fmt.Println("⏳ Retrieving NFT ID...") + // Step 3: Retrieve the token ID + fmt.Println("⏳ Retrieving NFT ID...") - metaMap, ok := responseMint.Meta.(map[string]any) - if !ok { - fmt.Println("❌ Meta is not a map[string]any") - return - } + metaMap, ok := responseMint.Meta.(map[string]any) + if !ok { + 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") - return - } + nftokenID, ok := metaMap["nftoken_id"].(string) + if !ok { + fmt.Println("❌ nftoken_id not found or not a string") + return + } - fmt.Println("🌎 nftoken_id:", nftokenID) - fmt.Println() + fmt.Println("🌎 nftoken_id:", nftokenID) + fmt.Println() - // Step 4: Burn the NFT - fmt.Println("⏳ Burn the NFT...") + // Step 4: Burn the NFT + fmt.Println("⏳ Burn the NFT...") - nftBurn := transaction.NFTokenBurn{ - BaseTx: transaction.BaseTx{ - Account: nftMinter.ClassicAddress, - TransactionType: transaction.NFTokenAcceptOfferTx, - }, - NFTokenID: txnTypes.NFTokenID(nftokenID), - } + nftBurn := transaction.NFTokenBurn{ + BaseTx: transaction.BaseTx{ + Account: nftMinter.ClassicAddress, + TransactionType: transaction.NFTokenAcceptOfferTx, + }, + NFTokenID: txnTypes.NFTokenID(nftokenID), + } - responseBurn, err := client.SubmitTxAndWait(nftBurn.Flatten(), &types.SubmitOptions{ - Autofill: true, - Wallet: &nftMinter, - }) - if err != nil { - fmt.Println("❌ Error burning NFT:", err) - return - } - if !responseBurn.Validated { - fmt.Println("❌ NFTokenBurn transactiob is not in a validated ledger", responseBurn) - return - } - fmt.Println("✅ NFT burned successfully! - 🌎 Hash: ", responseBurn.Hash) + responseBurn, err := client.SubmitTxAndWait(nftBurn.Flatten(), &types.SubmitOptions{ + Autofill: true, + Wallet: &nftMinter, + }) + if err != nil { + fmt.Println("❌ Error burning NFT:", err) + return + } + if !responseBurn.Validated { + fmt.Println("❌ NFTokenBurn transactiob is not in a validated ledger", responseBurn) + return + } + fmt.Println("✅ NFT burned successfully! - 🌎 Hash: ", responseBurn.Hash) } diff --git a/_code-samples/non-fungible-token/go/nft-burn/ws/main.go b/_code-samples/non-fungible-token/go/nft-burn/ws/main.go index f8a834a563..fc6cab7ba5 100644 --- a/_code-samples/non-fungible-token/go/nft-burn/ws/main.go +++ b/_code-samples/non-fungible-token/go/nft-burn/ws/main.go @@ -1,123 +1,123 @@ 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...") - client := websocket.NewClient( - websocket.NewClientConfig(). - WithHost("wss://s.devnet.rippletest.net:51233"). - WithFaucetProvider(faucet.NewDevnetFaucetProvider()), - ) - defer client.Disconnect() + // Connect to the XRPL devnet + fmt.Println("⏳ Connecting to devnet...") + client := websocket.NewClient( + websocket.NewClientConfig(). + WithHost("wss://s.devnet.rippletest.net:51233"). + WithFaucetProvider(faucet.NewDevnetFaucetProvider()), + ) + defer client.Disconnect() - if err := client.Connect(); err != nil { - fmt.Println("❌ Error connecting to devnet:", err) - return - } + if err := client.Connect(); err != nil { + fmt.Println("❌ Error connecting to devnet:", err) + return + } - if !client.IsConnected() { - fmt.Println("❌ Failed to connect to devnet") - return - } - fmt.Println("✅ Connected to devnet") - fmt.Println() + if !client.IsConnected() { + fmt.Println("❌ Failed to connect to devnet") + return + } + fmt.Println("✅ Connected to devnet") + fmt.Println() - // Step 1: Fund wallets - fmt.Println("⏳ Funding wallets...") + // Step 1: Fund 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) - return - } - if err := client.FundWallet(&nftMinter); err != nil { - fmt.Println("❌ Error funding NFT minter wallet:", err) - return - } - fmt.Println("💸 NFT minter wallet funded!") - fmt.Println() + // Create and fund the NFT minter wallet + nftMinter, err := wallet.New(crypto.ED25519()) + if err != nil { + fmt.Println("❌ Error creating NFT minter wallet:", err) + return + } + if err := client.FundWallet(&nftMinter); err != nil { + fmt.Println("❌ Error funding NFT minter wallet:", err) + return + } + fmt.Println("💸 NFT minter wallet funded!") + fmt.Println() - // Step 2: Mint an NFT - fmt.Println("⏳ Minting NFT...") + // Step 2: Mint an NFT + fmt.Println("⏳ Minting NFT...") - nftMint := transaction.NFTokenMint{ - BaseTx: transaction.BaseTx{ - Account: nftMinter.ClassicAddress, - TransactionType: transaction.NFTokenMintTx, - }, - NFTokenTaxon: 0, - URI: txnTypes.NFTokenURI("68747470733A2F2F676F6F676C652E636F6D"), // https://google.com - } - nftMint.SetTransferableFlag() + nftMint := transaction.NFTokenMint{ + BaseTx: transaction.BaseTx{ + Account: nftMinter.ClassicAddress, + TransactionType: transaction.NFTokenMintTx, + }, + NFTokenTaxon: 0, + URI: txnTypes.NFTokenURI("68747470733A2F2F676F6F676C652E636F6D"), // https://google.com + } + nftMint.SetTransferableFlag() - responseMint, err := client.SubmitTxAndWait(nftMint.Flatten(), &types.SubmitOptions{ - Autofill: true, - Wallet: &nftMinter, - }) - if err != nil { - fmt.Println("❌ Error minting NFT:", err) - return - } - if !responseMint.Validated { - fmt.Println("❌ NFTokenMint txn is not in a validated ledger", responseMint) - return - } - fmt.Println("✅ NFT minted successfully! - 🌎 Hash: ", responseMint.Hash) - fmt.Println() + responseMint, err := client.SubmitTxAndWait(nftMint.Flatten(), &types.SubmitOptions{ + Autofill: true, + Wallet: &nftMinter, + }) + if err != nil { + fmt.Println("❌ Error minting NFT:", err) + return + } + if !responseMint.Validated { + fmt.Println("❌ NFTokenMint txn is not in a validated ledger", responseMint) + return + } + fmt.Println("✅ NFT minted successfully! - 🌎 Hash: ", responseMint.Hash) + fmt.Println() - // Step 3: Retrieve the token ID - fmt.Println("⏳ Retrieving NFT ID...") + // Step 3: Retrieve the token ID + fmt.Println("⏳ Retrieving NFT ID...") - metaMap, ok := responseMint.Meta.(map[string]any) - if !ok { - fmt.Println("❌ Meta is not a map[string]any") - return - } + metaMap, ok := responseMint.Meta.(map[string]any) + if !ok { + 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") - return - } + nftokenID, ok := metaMap["nftoken_id"].(string) + if !ok { + fmt.Println("❌ nftoken_id not found or not a string") + return + } - fmt.Println("🌎 nftoken_id:", nftokenID) - fmt.Println() + fmt.Println("🌎 nftoken_id:", nftokenID) + fmt.Println() - // Step 4: Burn the NFT - fmt.Println("⏳ Burn the NFT...") + // Step 4: Burn the NFT + fmt.Println("⏳ Burn the NFT...") - nftBurn := transaction.NFTokenBurn{ - BaseTx: transaction.BaseTx{ - Account: nftMinter.ClassicAddress, - TransactionType: transaction.NFTokenAcceptOfferTx, - }, - NFTokenID: txnTypes.NFTokenID(nftokenID), - } + nftBurn := transaction.NFTokenBurn{ + BaseTx: transaction.BaseTx{ + Account: nftMinter.ClassicAddress, + TransactionType: transaction.NFTokenAcceptOfferTx, + }, + NFTokenID: txnTypes.NFTokenID(nftokenID), + } - responseBurn, err := client.SubmitTxAndWait(nftBurn.Flatten(), &types.SubmitOptions{ - Autofill: true, - Wallet: &nftMinter, - }) - if err != nil { - fmt.Println("❌ Error burning NFT:", err) - return - } - if !responseBurn.Validated { - fmt.Println("❌ NFTokenBurn transactiob is not in a validated ledger", responseBurn) - return - } - fmt.Println("✅ NFT burned successfully! - 🌎 Hash: ", responseBurn.Hash) + responseBurn, err := client.SubmitTxAndWait(nftBurn.Flatten(), &types.SubmitOptions{ + Autofill: true, + Wallet: &nftMinter, + }) + if err != nil { + fmt.Println("❌ Error burning NFT:", err) + return + } + if !responseBurn.Validated { + fmt.Println("❌ NFTokenBurn transactiob is not in a validated ledger", responseBurn) + return + } + fmt.Println("✅ NFT burned successfully! - 🌎 Hash: ", responseBurn.Hash) } diff --git a/_code-samples/non-fungible-token/go/nft-cancel/rpc/main.go b/_code-samples/non-fungible-token/go/nft-cancel/rpc/main.go index 5d0b59dbbe..3cdb87f7d1 100644 --- a/_code-samples/non-fungible-token/go/nft-cancel/rpc/main.go +++ b/_code-samples/non-fungible-token/go/nft-cancel/rpc/main.go @@ -1,163 +1,163 @@ 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() { - // Initialize the RPC client configuration - cfg, err := rpc.NewClientConfig( - "https://s.devnet.rippletest.net:51234/", - rpc.WithFaucetProvider(faucet.NewDevnetFaucetProvider()), - ) - if err != nil { - panic(err) - } + // Initialize the RPC client configuration + cfg, err := rpc.NewClientConfig( + "https://s.devnet.rippletest.net:51234/", + rpc.WithFaucetProvider(faucet.NewDevnetFaucetProvider()), + ) + if err != nil { + panic(err) + } - // Create the RPC client - client := rpc.NewClient(cfg) + // Create the RPC client + client := rpc.NewClient(cfg) - // Step 1: Fund wallet - fmt.Println("⏳ Funding wallet...") + // Step 1: Fund 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) - return - } - if err := client.FundWallet(&nftMinter); err != nil { - fmt.Println("❌ Error funding NFT minter wallet:", err) - return - } - fmt.Println("💸 NFT minter wallet funded!") + // Create and fund the NFT minter wallet + nftMinter, err := wallet.New(crypto.ED25519()) + if err != nil { + fmt.Println("❌ Error creating NFT minter wallet:", err) + return + } + if err := client.FundWallet(&nftMinter); err != nil { + fmt.Println("❌ Error funding NFT minter wallet:", err) + return + } + fmt.Println("💸 NFT minter wallet funded!") - // Step 2: Mint two NFTs - fmt.Println("⏳ Minting first NFT...") + // Step 2: Mint two NFTs + fmt.Println("⏳ Minting first NFT...") - nftMint := transaction.NFTokenMint{ - BaseTx: transaction.BaseTx{ - Account: nftMinter.ClassicAddress, - TransactionType: transaction.NFTokenMintTx, - }, - NFTokenTaxon: 0, - URI: txnTypes.NFTokenURI("68747470733A2F2F676F6F676C652E636F6D"), // https://google.com - } - nftMint.SetTransferableFlag() + nftMint := transaction.NFTokenMint{ + BaseTx: transaction.BaseTx{ + Account: nftMinter.ClassicAddress, + TransactionType: transaction.NFTokenMintTx, + }, + NFTokenTaxon: 0, + URI: txnTypes.NFTokenURI("68747470733A2F2F676F6F676C652E636F6D"), // https://google.com + } + nftMint.SetTransferableFlag() - responseMint, err := client.SubmitTxAndWait(nftMint.Flatten(), &types.SubmitOptions{ - Autofill: true, - Wallet: &nftMinter, - }) - if err != nil { - fmt.Println("❌ Error minting first NFT:", err) - return - } - if !responseMint.Validated { - fmt.Println("❌ First NFTokenMint transaction is not in a validated ledger", responseMint) - return - } - fmt.Println("✅ First NFT minted successfully! - 🌎 Hash: ", responseMint.Hash) - fmt.Println() + responseMint, err := client.SubmitTxAndWait(nftMint.Flatten(), &types.SubmitOptions{ + Autofill: true, + Wallet: &nftMinter, + }) + if err != nil { + fmt.Println("❌ Error minting first NFT:", err) + return + } + if !responseMint.Validated { + fmt.Println("❌ First NFTokenMint transaction is not in a validated ledger", responseMint) + return + } + fmt.Println("✅ First NFT minted successfully! - 🌎 Hash: ", responseMint.Hash) + fmt.Println() - // Step 3: Retrieve the NFT token ID - fmt.Println("⏳ Retrieving NFT ID...") + // Step 3: Retrieve the NFT token ID + fmt.Println("⏳ Retrieving NFT ID...") - metaMap, ok := responseMint.Meta.(map[string]any) - if !ok { - fmt.Println("❌ Meta is not a map[string]any") - return - } + metaMap, ok := responseMint.Meta.(map[string]any) + if !ok { + 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") - return - } + nftokenID1, ok := metaMap["nftoken_id"].(string) + if !ok { + fmt.Println("❌ nftoken_id not found or not a string") + return + } - fmt.Println("🌎 nftoken_id:", nftokenID1) - fmt.Println() + fmt.Println("🌎 nftoken_id:", nftokenID1) + fmt.Println() - // ------ + // ------ - fmt.Println("⏳ Minting second NFT...") + fmt.Println("⏳ Minting second NFT...") - nftMint2 := transaction.NFTokenMint{ - BaseTx: transaction.BaseTx{ - Account: nftMinter.ClassicAddress, - TransactionType: transaction.NFTokenMintTx, - }, - NFTokenTaxon: 0, - URI: txnTypes.NFTokenURI("68747470733A2F2F676F6F676C652E636F6D"), // https://google.com - } - nftMint2.SetTransferableFlag() + nftMint2 := transaction.NFTokenMint{ + BaseTx: transaction.BaseTx{ + Account: nftMinter.ClassicAddress, + TransactionType: transaction.NFTokenMintTx, + }, + NFTokenTaxon: 0, + URI: txnTypes.NFTokenURI("68747470733A2F2F676F6F676C652E636F6D"), // https://google.com + } + nftMint2.SetTransferableFlag() - responseMint2, err := client.SubmitTxAndWait(nftMint2.Flatten(), &types.SubmitOptions{ - Autofill: true, - Wallet: &nftMinter, - }) - if err != nil { - fmt.Println("❌ Error minting second NFT:", err) - return - } - if !responseMint.Validated { - fmt.Println("❌ Second NFTokenMint transaction is not in a validated ledger", responseMint) - return - } - fmt.Println("✅ Second NFT minted successfully! - 🌎 Hash: ", responseMint.Hash) - fmt.Println() + responseMint2, err := client.SubmitTxAndWait(nftMint2.Flatten(), &types.SubmitOptions{ + Autofill: true, + Wallet: &nftMinter, + }) + if err != nil { + fmt.Println("❌ Error minting second NFT:", err) + return + } + if !responseMint.Validated { + fmt.Println("❌ Second NFTokenMint transaction is not in a validated ledger", responseMint) + return + } + 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...") + // Step 3: Retrieve the second NFT token 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") - return - } + metaMap2, ok := responseMint2.Meta.(map[string]any) + if !ok { + 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") - return - } + nftokenID2, ok := metaMap2["nftoken_id"].(string) + if !ok { + fmt.Println("❌ nftoken_id not found or not a string") + return + } - fmt.Println("🌎 nftoken_id:", nftokenID2) - fmt.Println() + fmt.Println("🌎 nftoken_id:", nftokenID2) + fmt.Println() - // Step 4: Cancel the NFT offers - fmt.Println("⏳ Canceling NFT offers...") + // Step 4: Cancel the NFT offers + fmt.Println("⏳ Canceling NFT offers...") - nftCancel := transaction.NFTokenCancelOffer{ - BaseTx: transaction.BaseTx{ - Account: nftMinter.ClassicAddress, - TransactionType: transaction.NFTokenAcceptOfferTx, - }, - NFTokenOffers: []txnTypes.NFTokenID{ - txnTypes.NFTokenID(nftokenID1), - txnTypes.NFTokenID(nftokenID2), - }, - } + nftCancel := transaction.NFTokenCancelOffer{ + BaseTx: transaction.BaseTx{ + Account: nftMinter.ClassicAddress, + TransactionType: transaction.NFTokenAcceptOfferTx, + }, + NFTokenOffers: []txnTypes.NFTokenID{ + txnTypes.NFTokenID(nftokenID1), + txnTypes.NFTokenID(nftokenID2), + }, + } - response, err := client.SubmitTxAndWait(nftCancel.Flatten(), &types.SubmitOptions{ - Autofill: true, - Wallet: &nftMinter, - }) - if err != nil { - fmt.Println("❌ Error canceling NFT offers:", err) - return - } - if !response.Validated { - fmt.Println("❌ NFTokenCancelOffer transaction is not in a validated ledger", response) - return - } - fmt.Println("✅ NFT offers canceled successfully! - 🌎 Hash: ", response.Hash) + response, err := client.SubmitTxAndWait(nftCancel.Flatten(), &types.SubmitOptions{ + Autofill: true, + Wallet: &nftMinter, + }) + if err != nil { + fmt.Println("❌ Error canceling NFT offers:", err) + return + } + if !response.Validated { + fmt.Println("❌ NFTokenCancelOffer transaction is not in a validated ledger", response) + return + } + fmt.Println("✅ NFT offers canceled successfully! - 🌎 Hash: ", response.Hash) } diff --git a/_code-samples/non-fungible-token/go/nft-cancel/ws/main.go b/_code-samples/non-fungible-token/go/nft-cancel/ws/main.go index be2fd94579..784d105ef3 100644 --- a/_code-samples/non-fungible-token/go/nft-cancel/ws/main.go +++ b/_code-samples/non-fungible-token/go/nft-cancel/ws/main.go @@ -1,172 +1,172 @@ 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...") - client := websocket.NewClient( - websocket.NewClientConfig(). - WithHost("wss://s.devnet.rippletest.net:51233"). - WithFaucetProvider(faucet.NewDevnetFaucetProvider()), - ) - defer client.Disconnect() + // Connect to the XRPL devnet + fmt.Println("⏳ Connecting to devnet...") + client := websocket.NewClient( + websocket.NewClientConfig(). + WithHost("wss://s.devnet.rippletest.net:51233"). + WithFaucetProvider(faucet.NewDevnetFaucetProvider()), + ) + defer client.Disconnect() - if err := client.Connect(); err != nil { - fmt.Println("❌ Error connecting to devnet:", err) - return - } + if err := client.Connect(); err != nil { + fmt.Println("❌ Error connecting to devnet:", err) + return + } - if !client.IsConnected() { - fmt.Println("❌ Failed to connect to devnet") - return - } - fmt.Println("✅ Connected to devnet") - fmt.Println() + if !client.IsConnected() { + fmt.Println("❌ Failed to connect to devnet") + return + } + fmt.Println("✅ Connected to devnet") + fmt.Println() - // Step 1: Fund wallet - fmt.Println("⏳ Funding wallet...") + // Step 1: Fund 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) - return - } - if err := client.FundWallet(&nftMinter); err != nil { - fmt.Println("❌ Error funding NFT minter wallet:", err) - return - } - fmt.Println("💸 NFT minter wallet funded!") + // Create and fund the NFT minter wallet + nftMinter, err := wallet.New(crypto.ED25519()) + if err != nil { + fmt.Println("❌ Error creating NFT minter wallet:", err) + return + } + if err := client.FundWallet(&nftMinter); err != nil { + fmt.Println("❌ Error funding NFT minter wallet:", err) + return + } + fmt.Println("💸 NFT minter wallet funded!") - // Step 2: Mint two NFTs - fmt.Println("⏳ Minting first NFT...") + // Step 2: Mint two NFTs + fmt.Println("⏳ Minting first NFT...") - nftMint := transaction.NFTokenMint{ - BaseTx: transaction.BaseTx{ - Account: nftMinter.ClassicAddress, - TransactionType: transaction.NFTokenMintTx, - }, - NFTokenTaxon: 0, - URI: txnTypes.NFTokenURI("68747470733A2F2F676F6F676C652E636F6D"), // https://google.com - } - nftMint.SetTransferableFlag() + nftMint := transaction.NFTokenMint{ + BaseTx: transaction.BaseTx{ + Account: nftMinter.ClassicAddress, + TransactionType: transaction.NFTokenMintTx, + }, + NFTokenTaxon: 0, + URI: txnTypes.NFTokenURI("68747470733A2F2F676F6F676C652E636F6D"), // https://google.com + } + nftMint.SetTransferableFlag() - responseMint, err := client.SubmitTxAndWait(nftMint.Flatten(), &types.SubmitOptions{ - Autofill: true, - Wallet: &nftMinter, - }) - if err != nil { - fmt.Println("❌ Error minting first NFT:", err) - return - } - if !responseMint.Validated { - fmt.Println("❌ First NFTokenMint transaction is not in a validated ledger", responseMint) - return - } - fmt.Println("✅ First NFT minted successfully! - 🌎 Hash: ", responseMint.Hash) - fmt.Println() + responseMint, err := client.SubmitTxAndWait(nftMint.Flatten(), &types.SubmitOptions{ + Autofill: true, + Wallet: &nftMinter, + }) + if err != nil { + fmt.Println("❌ Error minting first NFT:", err) + return + } + if !responseMint.Validated { + fmt.Println("❌ First NFTokenMint transaction is not in a validated ledger", responseMint) + return + } + fmt.Println("✅ First NFT minted successfully! - 🌎 Hash: ", responseMint.Hash) + fmt.Println() - // Step 3: Retrieve the NFT token ID - fmt.Println("⏳ Retrieving NFT ID...") + // Step 3: Retrieve the NFT token ID + fmt.Println("⏳ Retrieving NFT ID...") - metaMap, ok := responseMint.Meta.(map[string]any) - if !ok { - fmt.Println("❌ Meta is not a map[string]any") - return - } + metaMap, ok := responseMint.Meta.(map[string]any) + if !ok { + 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") - return - } + nftokenID1, ok := metaMap["nftoken_id"].(string) + if !ok { + fmt.Println("❌ nftoken_id not found or not a string") + return + } - fmt.Println("🌎 nftoken_id:", nftokenID1) - fmt.Println() + fmt.Println("🌎 nftoken_id:", nftokenID1) + fmt.Println() - // ------ + // ------ - fmt.Println("⏳ Minting second NFT...") + fmt.Println("⏳ Minting second NFT...") - nftMint2 := transaction.NFTokenMint{ - BaseTx: transaction.BaseTx{ - Account: nftMinter.ClassicAddress, - TransactionType: transaction.NFTokenMintTx, - }, - NFTokenTaxon: 0, - URI: txnTypes.NFTokenURI("68747470733A2F2F676F6F676C652E636F6D"), // https://google.com - } - nftMint2.SetTransferableFlag() + nftMint2 := transaction.NFTokenMint{ + BaseTx: transaction.BaseTx{ + Account: nftMinter.ClassicAddress, + TransactionType: transaction.NFTokenMintTx, + }, + NFTokenTaxon: 0, + URI: txnTypes.NFTokenURI("68747470733A2F2F676F6F676C652E636F6D"), // https://google.com + } + nftMint2.SetTransferableFlag() - responseMint2, err := client.SubmitTxAndWait(nftMint2.Flatten(), &types.SubmitOptions{ - Autofill: true, - Wallet: &nftMinter, - }) - if err != nil { - fmt.Println("❌ Error minting second NFT:", err) - return - } - if !responseMint.Validated { - fmt.Println("❌ Second NFTokenMint transaction is not in a validated ledger", responseMint) - return - } - fmt.Println("✅ Second NFT minted successfully! - 🌎 Hash: ", responseMint.Hash) - fmt.Println() + responseMint2, err := client.SubmitTxAndWait(nftMint2.Flatten(), &types.SubmitOptions{ + Autofill: true, + Wallet: &nftMinter, + }) + if err != nil { + fmt.Println("❌ Error minting second NFT:", err) + return + } + if !responseMint.Validated { + fmt.Println("❌ Second NFTokenMint transaction is not in a validated ledger", responseMint) + return + } + 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...") + // Step 3: Retrieve the second NFT token 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") - return - } + metaMap2, ok := responseMint2.Meta.(map[string]any) + if !ok { + 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") - return - } + nftokenID2, ok := metaMap2["nftoken_id"].(string) + if !ok { + fmt.Println("❌ nftoken_id not found or not a string") + return + } - fmt.Println("🌎 nftoken_id:", nftokenID2) - fmt.Println() + fmt.Println("🌎 nftoken_id:", nftokenID2) + fmt.Println() - // Step 4: Cancel the NFT offers - fmt.Println("⏳ Canceling NFT offers...") + // Step 4: Cancel the NFT offers + fmt.Println("⏳ Canceling NFT offers...") - nftCancel := transaction.NFTokenCancelOffer{ - BaseTx: transaction.BaseTx{ - Account: nftMinter.ClassicAddress, - TransactionType: transaction.NFTokenAcceptOfferTx, - }, - NFTokenOffers: []txnTypes.NFTokenID{ - txnTypes.NFTokenID(nftokenID1), - txnTypes.NFTokenID(nftokenID2), - }, - } + nftCancel := transaction.NFTokenCancelOffer{ + BaseTx: transaction.BaseTx{ + Account: nftMinter.ClassicAddress, + TransactionType: transaction.NFTokenAcceptOfferTx, + }, + NFTokenOffers: []txnTypes.NFTokenID{ + txnTypes.NFTokenID(nftokenID1), + txnTypes.NFTokenID(nftokenID2), + }, + } - response, err := client.SubmitTxAndWait(nftCancel.Flatten(), &types.SubmitOptions{ - Autofill: true, - Wallet: &nftMinter, - }) - if err != nil { - fmt.Println("❌ Error canceling NFT offers:", err) - return - } - if !response.Validated { - fmt.Println("❌ NFTokenCancelOffer transaction is not in a validated ledger", response) - return - } - fmt.Println("✅ NFT offers canceled successfully! - 🌎 Hash: ", response.Hash) + response, err := client.SubmitTxAndWait(nftCancel.Flatten(), &types.SubmitOptions{ + Autofill: true, + Wallet: &nftMinter, + }) + if err != nil { + fmt.Println("❌ Error canceling NFT offers:", err) + return + } + if !response.Validated { + fmt.Println("❌ NFTokenCancelOffer transaction is not in a validated ledger", response) + return + } + fmt.Println("✅ NFT offers canceled successfully! - 🌎 Hash: ", response.Hash) } diff --git a/_code-samples/non-fungible-token/go/nft-modify/rpc/main.go b/_code-samples/non-fungible-token/go/nft-modify/rpc/main.go index 286fb14771..d9161805b1 100644 --- a/_code-samples/non-fungible-token/go/nft-modify/rpc/main.go +++ b/_code-samples/non-fungible-token/go/nft-modify/rpc/main.go @@ -1,107 +1,107 @@ 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() { - cfg, err := rpc.NewClientConfig( - "https://s.devnet.rippletest.net:51234/", - rpc.WithFaucetProvider(faucet.NewDevnetFaucetProvider()), - ) - if err != nil { - panic(err) - } + cfg, err := rpc.NewClientConfig( + "https://s.devnet.rippletest.net:51234/", + rpc.WithFaucetProvider(faucet.NewDevnetFaucetProvider()), + ) + if err != nil { + panic(err) + } - client := rpc.NewClient(cfg) - fmt.Println() + 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) - return - } - if err := client.FundWallet(&nftWallet); err != nil { - fmt.Println("❌ Error funding nft wallet:", err) - return - } - fmt.Println("💸 NFT wallet funded! - #️⃣: ", nftWallet.ClassicAddress) - fmt.Println() + // Create and fund the nft wallet + nftWallet, err := wallet.New(crypto.ED25519()) + if err != nil { + fmt.Println("❌ Error creating nft wallet:", err) + return + } + if err := client.FundWallet(&nftWallet); err != nil { + fmt.Println("❌ Error funding nft wallet:", err) + return + } + fmt.Println("💸 NFT wallet funded! - #️⃣: ", nftWallet.ClassicAddress) + fmt.Println() - // Mint NFT - nftMint := transaction.NFTokenMint{ - BaseTx: transaction.BaseTx{ - Account: nftWallet.ClassicAddress, - TransactionType: transaction.NFTokenMintTx, - }, - NFTokenTaxon: 0, - URI: txnTypes.NFTokenURI("68747470733A2F2F676F6F676C652E636F6D"), // https://google.com - } - nftMint.SetMutableFlag() - nftMint.SetTransferableFlag() + // Mint NFT + nftMint := transaction.NFTokenMint{ + BaseTx: transaction.BaseTx{ + Account: nftWallet.ClassicAddress, + TransactionType: transaction.NFTokenMintTx, + }, + NFTokenTaxon: 0, + URI: txnTypes.NFTokenURI("68747470733A2F2F676F6F676C652E636F6D"), // https://google.com + } + nftMint.SetMutableFlag() + nftMint.SetTransferableFlag() - responseMint, err := client.SubmitTxAndWait(nftMint.Flatten(), &types.SubmitOptions{ - Autofill: true, - Wallet: &nftWallet, - }) - if err != nil { - fmt.Println("❌ Error minting NFT:", err) - return - } - if !responseMint.Validated { - fmt.Println("❌ NFTokenMint txn is not in a validated ledger", responseMint) - return - } - fmt.Println("✅ NFT minted successfully! - 🌎 Hash: ", responseMint.Hash) - fmt.Println() + responseMint, err := client.SubmitTxAndWait(nftMint.Flatten(), &types.SubmitOptions{ + Autofill: true, + Wallet: &nftWallet, + }) + if err != nil { + fmt.Println("❌ Error minting NFT:", err) + return + } + if !responseMint.Validated { + fmt.Println("❌ NFTokenMint txn is not in a validated ledger", responseMint) + return + } + 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") - return - } + metaMap, ok := responseMint.Meta.(map[string]any) + if !ok { + 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") - return - } + nftokenID, ok := metaMap["nftoken_id"].(string) + if !ok { + fmt.Println("❌ nftoken_id not found or not a string") + return + } - fmt.Println("🌎 nftoken_id:", nftokenID) - fmt.Println() + fmt.Println("🌎 nftoken_id:", nftokenID) + fmt.Println() - // Update NFT - nftModify := transaction.NFTokenModify{ - BaseTx: transaction.BaseTx{ - Account: nftWallet.ClassicAddress, - TransactionType: transaction.NFTokenModifyTx, - }, - URI: "68747470733A2F2F7961686F6F2E636F6D", // https://yahoo.com - NFTokenID: txnTypes.NFTokenID(nftokenID), - } - // nftoken_id - responseModify, err := client.SubmitTxAndWait(nftModify.Flatten(), &types.SubmitOptions{ - Autofill: true, - Wallet: &nftWallet, - }) - if err != nil { - fmt.Println("❌ Error modifying NFT:", err) - return - } - if !responseModify.Validated { - fmt.Println("❌ NFTokenModify txn is not in a validated ledger", responseModify) - return - } - fmt.Println("✅ NFT URI modified successfully! - 🌎 Hash: ", responseModify.Hash) + // Update NFT + nftModify := transaction.NFTokenModify{ + BaseTx: transaction.BaseTx{ + Account: nftWallet.ClassicAddress, + TransactionType: transaction.NFTokenModifyTx, + }, + URI: "68747470733A2F2F7961686F6F2E636F6D", // https://yahoo.com + NFTokenID: txnTypes.NFTokenID(nftokenID), + } + // nftoken_id + responseModify, err := client.SubmitTxAndWait(nftModify.Flatten(), &types.SubmitOptions{ + Autofill: true, + Wallet: &nftWallet, + }) + if err != nil { + fmt.Println("❌ Error modifying NFT:", err) + return + } + if !responseModify.Validated { + fmt.Println("❌ NFTokenModify txn is not in a validated ledger", responseModify) + return + } + fmt.Println("✅ NFT URI modified successfully! - 🌎 Hash: ", responseModify.Hash) } diff --git a/_code-samples/non-fungible-token/go/nft-modify/ws/main.go b/_code-samples/non-fungible-token/go/nft-modify/ws/main.go index 77d28416d4..328682130a 100644 --- a/_code-samples/non-fungible-token/go/nft-modify/ws/main.go +++ b/_code-samples/non-fungible-token/go/nft-modify/ws/main.go @@ -1,117 +1,117 @@ 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...") - client := websocket.NewClient( - websocket.NewClientConfig(). - WithHost("wss://s.devnet.rippletest.net:51233"). - WithFaucetProvider(faucet.NewDevnetFaucetProvider()), - ) + fmt.Println("⏳ Connecting to devnet...") + client := websocket.NewClient( + websocket.NewClientConfig(). + WithHost("wss://s.devnet.rippletest.net:51233"). + WithFaucetProvider(faucet.NewDevnetFaucetProvider()), + ) - defer client.Disconnect() + defer client.Disconnect() - if err := client.Connect(); err != nil { - fmt.Println(err) - return - } + if err := client.Connect(); err != nil { + fmt.Println(err) + return + } - if !client.IsConnected() { - fmt.Println("❌ Failed to connect to devnet") - return - } + if !client.IsConnected() { + fmt.Println("❌ Failed to connect to devnet") + return + } - fmt.Println("✅ Connected to devnet") - fmt.Println() + fmt.Println("✅ Connected to devnet") + fmt.Println() - // Create and fund the nft wallet - fmt.Println("⏳ Funding wallet...") - nftWallet, err := wallet.New(crypto.ED25519()) - if err != nil { - fmt.Println("❌ Error creating nft wallet:", err) - return - } - if err := client.FundWallet(&nftWallet); err != nil { - fmt.Println("❌ Error funding nft wallet:", err) - return - } - fmt.Println("💸 NFT wallet funded!") - fmt.Println() + // Create and fund the nft wallet + fmt.Println("⏳ Funding wallet...") + nftWallet, err := wallet.New(crypto.ED25519()) + if err != nil { + fmt.Println("❌ Error creating nft wallet:", err) + return + } + if err := client.FundWallet(&nftWallet); err != nil { + fmt.Println("❌ Error funding nft wallet:", err) + return + } + fmt.Println("💸 NFT wallet funded!") + fmt.Println() - // Mint NFT - nftMint := transaction.NFTokenMint{ - BaseTx: transaction.BaseTx{ - Account: nftWallet.ClassicAddress, - TransactionType: transaction.NFTokenMintTx, - }, - NFTokenTaxon: 0, - URI: txnTypes.NFTokenURI("68747470733A2F2F676F6F676C652E636F6D"), // https://google.com - } - nftMint.SetMutableFlag() - nftMint.SetTransferableFlag() + // Mint NFT + nftMint := transaction.NFTokenMint{ + BaseTx: transaction.BaseTx{ + Account: nftWallet.ClassicAddress, + TransactionType: transaction.NFTokenMintTx, + }, + NFTokenTaxon: 0, + URI: txnTypes.NFTokenURI("68747470733A2F2F676F6F676C652E636F6D"), // https://google.com + } + nftMint.SetMutableFlag() + nftMint.SetTransferableFlag() - responseMint, err := client.SubmitTxAndWait(nftMint.Flatten(), &types.SubmitOptions{ - Autofill: true, - Wallet: &nftWallet, - }) - if err != nil { - fmt.Println("❌ Error minting NFT:", err) - return - } - if !responseMint.Validated { - fmt.Println("❌ NFTokenMint txn is not in a validated ledger", responseMint) - return - } - fmt.Println("✅ NFT minted successfully! - 🌎 Hash: ", responseMint.Hash) - fmt.Println() + responseMint, err := client.SubmitTxAndWait(nftMint.Flatten(), &types.SubmitOptions{ + Autofill: true, + Wallet: &nftWallet, + }) + if err != nil { + fmt.Println("❌ Error minting NFT:", err) + return + } + if !responseMint.Validated { + fmt.Println("❌ NFTokenMint txn is not in a validated ledger", responseMint) + return + } + 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") - return - } + metaMap, ok := responseMint.Meta.(map[string]any) + if !ok { + 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") - return - } + nftokenID, ok := metaMap["nftoken_id"].(string) + if !ok { + fmt.Println("❌ nftoken_id not found or not a string") + return + } - fmt.Println("🌎 nftoken_id:", nftokenID) - fmt.Println() + fmt.Println("🌎 nftoken_id:", nftokenID) + fmt.Println() - // Update NFT - nftModify := transaction.NFTokenModify{ - BaseTx: transaction.BaseTx{ - Account: nftWallet.ClassicAddress, - TransactionType: transaction.NFTokenModifyTx, - }, - URI: "68747470733A2F2F7961686F6F2E636F6D", // https://yahoo.com - NFTokenID: txnTypes.NFTokenID(nftokenID), - } + // Update NFT + nftModify := transaction.NFTokenModify{ + BaseTx: transaction.BaseTx{ + Account: nftWallet.ClassicAddress, + TransactionType: transaction.NFTokenModifyTx, + }, + URI: "68747470733A2F2F7961686F6F2E636F6D", // https://yahoo.com + NFTokenID: txnTypes.NFTokenID(nftokenID), + } - responseModify, err := client.SubmitTxAndWait(nftModify.Flatten(), &types.SubmitOptions{ - Autofill: true, - Wallet: &nftWallet, - }) - if err != nil { - fmt.Println("❌ Error modifying NFT:", err) - return - } - if !responseModify.Validated { - fmt.Println("❌ NFTokenModify txn is not in a validated ledger", responseModify) - return - } - fmt.Println("✅ NFT URI modified successfully! - 🌎 Hash: ", responseModify.Hash) + responseModify, err := client.SubmitTxAndWait(nftModify.Flatten(), &types.SubmitOptions{ + Autofill: true, + Wallet: &nftWallet, + }) + if err != nil { + fmt.Println("❌ Error modifying NFT:", err) + return + } + if !responseModify.Validated { + fmt.Println("❌ NFTokenModify txn is not in a validated ledger", responseModify) + return + } + fmt.Println("✅ NFT URI modified successfully! - 🌎 Hash: ", responseModify.Hash) } diff --git a/_code-samples/partial-payment/go/rpc/main.go b/_code-samples/partial-payment/go/rpc/main.go index 73751ffcb7..09436459c7 100644 --- a/_code-samples/partial-payment/go/rpc/main.go +++ b/_code-samples/partial-payment/go/rpc/main.go @@ -1,168 +1,168 @@ 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() { - cfg, err := rpc.NewClientConfig( - "https://s.altnet.rippletest.net:51234/", - rpc.WithFaucetProvider(faucet.NewTestnetFaucetProvider()), - ) - if err != nil { - panic(err) - } + cfg, err := rpc.NewClientConfig( + "https://s.altnet.rippletest.net:51234/", + rpc.WithFaucetProvider(faucet.NewTestnetFaucetProvider()), + ) + if err != nil { + panic(err) + } - client := rpc.NewClient(cfg) + client := rpc.NewClient(cfg) - fmt.Println("⏳ Funding wallets...") - w1, err := wallet.New(crypto.ED25519()) - if err != nil { - fmt.Println(err) - return - } + fmt.Println("⏳ Funding wallets...") + w1, err := wallet.New(crypto.ED25519()) + if err != nil { + fmt.Println(err) + return + } - w2, err := wallet.New(crypto.ED25519()) - if err != nil { - fmt.Println(err) - return - } - if err := client.FundWallet(&w1); err != nil { - fmt.Println(err) - return - } + w2, err := wallet.New(crypto.ED25519()) + if err != nil { + fmt.Println(err) + return + } + if err := client.FundWallet(&w1); err != nil { + fmt.Println(err) + return + } - fmt.Println("💸 Wallet 1 funded") - if err := client.FundWallet(&w2); err != nil { - fmt.Println(err) - return - } + fmt.Println("💸 Wallet 1 funded") + if err := client.FundWallet(&w2); err != nil { + fmt.Println(err) + return + } - fmt.Println("💸 Wallet 2 funded") - fmt.Println() + fmt.Println("💸 Wallet 2 funded") + fmt.Println() - time.Sleep(5 * time.Second) + time.Sleep(5 * time.Second) - fmt.Println("⏳ Sending TrustSet transaction...") - ts := &transaction.TrustSet{ - BaseTx: transaction.BaseTx{ - Account: w2.ClassicAddress, - }, - LimitAmount: types.IssuedCurrencyAmount{ - Currency: "FOO", - Issuer: w1.ClassicAddress, - Value: "10000000000", - }, - } + fmt.Println("⏳ Sending TrustSet transaction...") + ts := &transaction.TrustSet{ + BaseTx: transaction.BaseTx{ + Account: w2.ClassicAddress, + }, + LimitAmount: types.IssuedCurrencyAmount{ + Currency: "FOO", + Issuer: w1.ClassicAddress, + Value: "10000000000", + }, + } - flatTs := ts.Flatten() + flatTs := ts.Flatten() - err = client.Autofill(&flatTs) - if err != nil { - fmt.Println(err) - return - } + err = client.Autofill(&flatTs) + if err != nil { + fmt.Println(err) + return + } - blob, _, err := w2.Sign(flatTs) - if err != nil { - fmt.Println(err) - return - } + blob, _, err := w2.Sign(flatTs) + if err != nil { + fmt.Println(err) + return + } - res, err := client.SubmitTxBlobAndWait(blob, false) - if err != nil { - fmt.Println(err) - return - } + res, err := client.SubmitTxBlobAndWait(blob, false) + if err != nil { + fmt.Println(err) + return + } - fmt.Println("✅ TrustSet transaction submitted!") - fmt.Printf("🌐 Hash: %s\n", res.Hash.String()) - fmt.Printf("🌐 Validated: %t\n", res.Validated) - fmt.Println() + 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...") - p := &transaction.Payment{ - BaseTx: transaction.BaseTx{ - Account: w1.GetAddress(), - }, - Amount: types.IssuedCurrencyAmount{ - Currency: "FOO", - Issuer: w1.GetAddress(), - Value: "50", - }, - Destination: w2.GetAddress(), - } + fmt.Println("⏳ Issuing tokens for wallet 2...") + p := &transaction.Payment{ + BaseTx: transaction.BaseTx{ + Account: w1.GetAddress(), + }, + Amount: types.IssuedCurrencyAmount{ + Currency: "FOO", + Issuer: w1.GetAddress(), + Value: "50", + }, + Destination: w2.GetAddress(), + } - flatP := p.Flatten() + flatP := p.Flatten() - err = client.Autofill(&flatP) - if err != nil { - fmt.Println(err) - return - } + err = client.Autofill(&flatP) + if err != nil { + fmt.Println(err) + return + } - blob, _, err = w1.Sign(flatP) - if err != nil { - fmt.Println(err) - return - } + blob, _, err = w1.Sign(flatP) + if err != nil { + fmt.Println(err) + return + } - res, err = client.SubmitTxBlobAndWait(blob, false) - if err != nil { - fmt.Println(err) - return - } + res, err = client.SubmitTxBlobAndWait(blob, false) + if err != nil { + fmt.Println(err) + return + } - fmt.Println("✅ Payment transaction submitted!") - fmt.Printf("🌐 Hash: %s\n", res.Hash.String()) - fmt.Printf("🌐 Validated: %t\n", res.Validated) - fmt.Println() + 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...") - pp := &transaction.Payment{ - BaseTx: transaction.BaseTx{ - Account: w2.GetAddress(), - }, - Amount: types.IssuedCurrencyAmount{ - Currency: "FOO", - Issuer: w1.GetAddress(), - Value: "10", - }, - Destination: w1.GetAddress(), - } + fmt.Println("⏳ Submitting Partial Payment transaction...") + pp := &transaction.Payment{ + BaseTx: transaction.BaseTx{ + Account: w2.GetAddress(), + }, + Amount: types.IssuedCurrencyAmount{ + Currency: "FOO", + Issuer: w1.GetAddress(), + Value: "10", + }, + Destination: w1.GetAddress(), + } - pp.SetPartialPaymentFlag() + pp.SetPartialPaymentFlag() - flatPP := pp.Flatten() + flatPP := pp.Flatten() - err = client.Autofill(&flatPP) - if err != nil { - fmt.Println(err) - return - } + err = client.Autofill(&flatPP) + if err != nil { + fmt.Println(err) + return + } - blob, _, err = w2.Sign(flatPP) - if err != nil { - fmt.Println(err) - return - } + blob, _, err = w2.Sign(flatPP) + if err != nil { + fmt.Println(err) + return + } - res, err = client.SubmitTxBlobAndWait(blob, false) - if err != nil { - fmt.Println(err) - return - } + res, err = client.SubmitTxBlobAndWait(blob, false) + if err != nil { + fmt.Println(err) + return + } - fmt.Println("✅ Partial Payment transaction submitted!") - fmt.Printf("🌐 Hash: %s\n", res.Hash.String()) - fmt.Printf("🌐 Validated: %t\n", res.Validated) - fmt.Println() + fmt.Println("✅ Partial Payment transaction submitted!") + fmt.Printf("🌐 Hash: %s\n", res.Hash.String()) + fmt.Printf("🌐 Validated: %t\n", res.Validated) + fmt.Println() } diff --git a/_code-samples/partial-payment/go/ws/main.go b/_code-samples/partial-payment/go/ws/main.go index af18ae9ac4..1c877b39a7 100644 --- a/_code-samples/partial-payment/go/ws/main.go +++ b/_code-samples/partial-payment/go/ws/main.go @@ -1,179 +1,179 @@ 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...") - client := websocket.NewClient( - websocket.NewClientConfig(). - WithHost("wss://s.altnet.rippletest.net:51233"). - WithFaucetProvider(faucet.NewTestnetFaucetProvider()), - ) - defer client.Disconnect() + fmt.Println("⏳ Connecting to testnet...") + client := websocket.NewClient( + websocket.NewClientConfig(). + WithHost("wss://s.altnet.rippletest.net:51233"). + WithFaucetProvider(faucet.NewTestnetFaucetProvider()), + ) + defer client.Disconnect() - if err := client.Connect(); err != nil { - fmt.Println(err) - return - } + if err := client.Connect(); err != nil { + fmt.Println(err) + return + } - if !client.IsConnected() { - fmt.Println("❌ Failed to connect to testnet") - return - } + if !client.IsConnected() { + fmt.Println("❌ Failed to connect to testnet") + return + } - fmt.Println("✅ Connected to testnet") - fmt.Println() + fmt.Println("✅ Connected to testnet") + fmt.Println() - fmt.Println("⏳ Funding wallets...") - w1, err := wallet.New(crypto.ED25519()) - if err != nil { - fmt.Println(err) - return - } + fmt.Println("⏳ Funding wallets...") + w1, err := wallet.New(crypto.ED25519()) + if err != nil { + fmt.Println(err) + return + } - w2, err := wallet.New(crypto.ED25519()) - if err != nil { - fmt.Println(err) - return - } - if err := client.FundWallet(&w1); err != nil { - fmt.Println(err) - return - } + w2, err := wallet.New(crypto.ED25519()) + if err != nil { + fmt.Println(err) + return + } + if err := client.FundWallet(&w1); err != nil { + fmt.Println(err) + return + } - fmt.Println("💸 Wallet 1 funded") - if err := client.FundWallet(&w2); err != nil { - fmt.Println(err) - return - } + fmt.Println("💸 Wallet 1 funded") + if err := client.FundWallet(&w2); err != nil { + fmt.Println(err) + return + } - fmt.Println("💸 Wallet 2 funded") - fmt.Println() + fmt.Println("💸 Wallet 2 funded") + fmt.Println() - time.Sleep(5 * time.Second) + time.Sleep(5 * time.Second) - fmt.Println("⏳ Sending TrustSet transaction...") - ts := &transaction.TrustSet{ - BaseTx: transaction.BaseTx{ - Account: w2.ClassicAddress, - }, - LimitAmount: types.IssuedCurrencyAmount{ - Currency: "FOO", - Issuer: w1.ClassicAddress, - Value: "10000000000", - }, - } + fmt.Println("⏳ Sending TrustSet transaction...") + ts := &transaction.TrustSet{ + BaseTx: transaction.BaseTx{ + Account: w2.ClassicAddress, + }, + LimitAmount: types.IssuedCurrencyAmount{ + Currency: "FOO", + Issuer: w1.ClassicAddress, + Value: "10000000000", + }, + } - flatTs := ts.Flatten() + flatTs := ts.Flatten() - err = client.Autofill(&flatTs) - if err != nil { - fmt.Println(err) - return - } + err = client.Autofill(&flatTs) + if err != nil { + fmt.Println(err) + return + } - blob, _, err := w2.Sign(flatTs) - if err != nil { - fmt.Println(err) - return - } + blob, _, err := w2.Sign(flatTs) + if err != nil { + fmt.Println(err) + return + } - res, err := client.SubmitTxBlobAndWait(blob, false) - if err != nil { - fmt.Println(err) - return - } + res, err := client.SubmitTxBlobAndWait(blob, false) + if err != nil { + fmt.Println(err) + return + } - fmt.Println("✅ TrustSet transaction submitted!") - fmt.Printf("🌐 Hash: %s\n", res.Hash.String()) - fmt.Printf("🌐 Validated: %t\n", res.Validated) - fmt.Println() + 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...") - p := &transaction.Payment{ - BaseTx: transaction.BaseTx{ - Account: w1.GetAddress(), - }, - Amount: types.IssuedCurrencyAmount{ - Currency: "FOO", - Issuer: w1.GetAddress(), - Value: "50", - }, - Destination: w2.GetAddress(), - } + fmt.Println("⏳ Issuing tokens for wallet 2...") + p := &transaction.Payment{ + BaseTx: transaction.BaseTx{ + Account: w1.GetAddress(), + }, + Amount: types.IssuedCurrencyAmount{ + Currency: "FOO", + Issuer: w1.GetAddress(), + Value: "50", + }, + Destination: w2.GetAddress(), + } - flatP := p.Flatten() + flatP := p.Flatten() - err = client.Autofill(&flatP) - if err != nil { - fmt.Println(err) - return - } + err = client.Autofill(&flatP) + if err != nil { + fmt.Println(err) + return + } - blob, _, err = w1.Sign(flatP) - if err != nil { - fmt.Println(err) - return - } + blob, _, err = w1.Sign(flatP) + if err != nil { + fmt.Println(err) + return + } - res, err = client.SubmitTxBlobAndWait(blob, false) - if err != nil { - fmt.Println(err) - return - } + res, err = client.SubmitTxBlobAndWait(blob, false) + if err != nil { + fmt.Println(err) + return + } - fmt.Println("✅ Payment transaction submitted!") - fmt.Printf("🌐 Hash: %s\n", res.Hash.String()) - fmt.Printf("🌐 Validated: %t\n", res.Validated) - fmt.Println() + 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...") - pp := &transaction.Payment{ - BaseTx: transaction.BaseTx{ - Account: w2.GetAddress(), - }, - Amount: types.IssuedCurrencyAmount{ - Currency: "FOO", - Issuer: w1.GetAddress(), - Value: "10", - }, - Destination: w1.GetAddress(), - } + fmt.Println("⏳ Submitting Partial Payment transaction...") + pp := &transaction.Payment{ + BaseTx: transaction.BaseTx{ + Account: w2.GetAddress(), + }, + Amount: types.IssuedCurrencyAmount{ + Currency: "FOO", + Issuer: w1.GetAddress(), + Value: "10", + }, + Destination: w1.GetAddress(), + } - pp.SetPartialPaymentFlag() + pp.SetPartialPaymentFlag() - flatPP := pp.Flatten() + flatPP := pp.Flatten() - err = client.Autofill(&flatPP) - if err != nil { - fmt.Println(err) - return - } + err = client.Autofill(&flatPP) + if err != nil { + fmt.Println(err) + return + } - blob, _, err = w2.Sign(flatPP) - if err != nil { - fmt.Println(err) - return - } + blob, _, err = w2.Sign(flatPP) + if err != nil { + fmt.Println(err) + return + } - res, err = client.SubmitTxBlobAndWait(blob, false) - if err != nil { - fmt.Println(err) - return - } + res, err = client.SubmitTxBlobAndWait(blob, false) + if err != nil { + fmt.Println(err) + return + } - fmt.Println("✅ Partial Payment transaction submitted!") - fmt.Printf("🌐 Hash: %s\n", res.Hash.String()) - fmt.Printf("🌐 Validated: %t\n", res.Validated) - fmt.Println() + fmt.Println("✅ Partial Payment transaction submitted!") + fmt.Printf("🌐 Hash: %s\n", res.Hash.String()) + fmt.Printf("🌐 Validated: %t\n", res.Validated) + fmt.Println() } diff --git a/_code-samples/paths/go/rpc/main.go b/_code-samples/paths/go/rpc/main.go index 0e25d00dc2..6a74e1b65d 100644 --- a/_code-samples/paths/go/rpc/main.go +++ b/_code-samples/paths/go/rpc/main.go @@ -1,111 +1,111 @@ 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 ( - DestinationAccount = types.Address("rKT4JX4cCof6LcDYRz8o3rGRu7qxzZ2Zwj") + DestinationAccount = types.Address("rKT4JX4cCof6LcDYRz8o3rGRu7qxzZ2Zwj") ) var ( - DestinationAmount = types.IssuedCurrencyAmount{ - Issuer: "rVnYNK9yuxBz4uP8zC8LEFokM2nqH3poc", - Currency: "USD", - Value: "0.001", - } + DestinationAmount = types.IssuedCurrencyAmount{ + Issuer: "rVnYNK9yuxBz4uP8zC8LEFokM2nqH3poc", + Currency: "USD", + Value: "0.001", + } ) func main() { - cfg, err := rpc.NewClientConfig( - "https://s.altnet.rippletest.net:51234/", - rpc.WithFaucetProvider(faucet.NewTestnetFaucetProvider()), - ) - if err != nil { - panic(err) - } + cfg, err := rpc.NewClientConfig( + "https://s.altnet.rippletest.net:51234/", + rpc.WithFaucetProvider(faucet.NewTestnetFaucetProvider()), + ) + if err != nil { + panic(err) + } - client := rpc.NewClient(cfg) + client := rpc.NewClient(cfg) - wallet, err := wallet.New(crypto.ED25519()) - if err != nil { - fmt.Println(err) - return - } + wallet, err := wallet.New(crypto.ED25519()) + if err != nil { + fmt.Println(err) + return + } - fmt.Println("⏳ Funding wallet...") - if err := client.FundWallet(&wallet); err != nil { - fmt.Println(err) - return - } + fmt.Println("⏳ Funding wallet...") + if err := client.FundWallet(&wallet); err != nil { + fmt.Println(err) + return + } - fmt.Println("💸 Wallet funded") - fmt.Println() + fmt.Println("💸 Wallet funded") + fmt.Println() - fmt.Println("⏳ Getting paths...") - res, err := client.GetRipplePathFind(&path.RipplePathFindRequest{ - SourceAccount: wallet.GetAddress(), - SourceCurrencies: []pathtypes.RipplePathFindCurrency{ - { - Currency: "XRP", - }, - }, - DestinationAccount: DestinationAccount, - DestinationAmount: DestinationAmount, - }) - if err != nil { - fmt.Println(err) - return - } + fmt.Println("⏳ Getting paths...") + res, err := client.GetRipplePathFind(&path.RipplePathFindRequest{ + SourceAccount: wallet.GetAddress(), + SourceCurrencies: []pathtypes.RipplePathFindCurrency{ + { + Currency: "XRP", + }, + }, + DestinationAccount: DestinationAccount, + DestinationAmount: DestinationAmount, + }) + if err != nil { + fmt.Println(err) + return + } - fmt.Printf("🌐 Computed paths: %d\n", len(res.Alternatives)) - fmt.Println() + fmt.Printf("🌐 Computed paths: %d\n", len(res.Alternatives)) + fmt.Println() - if len(res.Alternatives) == 0 { - fmt.Println("❌ No alternatives found") - return - } + if len(res.Alternatives) == 0 { + fmt.Println("❌ No alternatives found") + return + } - fmt.Println("⏳ Submitting Payment through path: ", res.Alternatives[0].PathsComputed) - p := &transaction.Payment{ - BaseTx: transaction.BaseTx{ - Account: wallet.GetAddress(), - }, - Destination: DestinationAccount, - Amount: DestinationAmount, - Paths: res.Alternatives[0].PathsComputed, - } + fmt.Println("⏳ Submitting Payment through path: ", res.Alternatives[0].PathsComputed) + p := &transaction.Payment{ + BaseTx: transaction.BaseTx{ + Account: wallet.GetAddress(), + }, + Destination: DestinationAccount, + Amount: DestinationAmount, + Paths: res.Alternatives[0].PathsComputed, + } - flatP := p.Flatten() + flatP := p.Flatten() - if err := client.Autofill(&flatP); err != nil { - fmt.Println(err) - return - } + if err := client.Autofill(&flatP); err != nil { + fmt.Println(err) + return + } - blob, hash, err := wallet.Sign(flatP) - if err != nil { - fmt.Println(err) - return - } + blob, hash, err := wallet.Sign(flatP) + if err != nil { + fmt.Println(err) + return + } - txRes, err := client.SubmitTxBlobAndWait(blob, false) - if err != nil { - fmt.Println(err) - return - } + txRes, err := client.SubmitTxBlobAndWait(blob, false) + if err != nil { + fmt.Println(err) + 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) } diff --git a/_code-samples/paths/go/ws/main.go b/_code-samples/paths/go/ws/main.go index 284b7bed2d..3049a1aeda 100644 --- a/_code-samples/paths/go/ws/main.go +++ b/_code-samples/paths/go/ws/main.go @@ -1,122 +1,122 @@ 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 ( - DestinationAccount = types.Address("rKT4JX4cCof6LcDYRz8o3rGRu7qxzZ2Zwj") + DestinationAccount = types.Address("rKT4JX4cCof6LcDYRz8o3rGRu7qxzZ2Zwj") ) var ( - DestinationAmount = types.IssuedCurrencyAmount{ - Issuer: "rVnYNK9yuxBz4uP8zC8LEFokM2nqH3poc", - Currency: "USD", - Value: "0.001", - } + DestinationAmount = types.IssuedCurrencyAmount{ + Issuer: "rVnYNK9yuxBz4uP8zC8LEFokM2nqH3poc", + Currency: "USD", + Value: "0.001", + } ) func main() { - fmt.Println("⏳ Connecting to testnet...") - client := websocket.NewClient( - websocket.NewClientConfig(). - WithHost("wss://s.altnet.rippletest.net:51233"). - WithFaucetProvider(faucet.NewTestnetFaucetProvider()), - ) - defer client.Disconnect() + fmt.Println("⏳ Connecting to testnet...") + client := websocket.NewClient( + websocket.NewClientConfig(). + WithHost("wss://s.altnet.rippletest.net:51233"). + WithFaucetProvider(faucet.NewTestnetFaucetProvider()), + ) + defer client.Disconnect() - if err := client.Connect(); err != nil { - fmt.Println(err) - return - } + if err := client.Connect(); err != nil { + fmt.Println(err) + return + } - if !client.IsConnected() { - fmt.Println("❌ Failed to connect to testnet") - return - } + if !client.IsConnected() { + fmt.Println("❌ Failed to connect to testnet") + return + } - fmt.Println("✅ Connected to testnet") - fmt.Println() + fmt.Println("✅ Connected to testnet") + fmt.Println() - wallet, err := wallet.New(crypto.ED25519()) - if err != nil { - fmt.Println(err) - return - } + wallet, err := wallet.New(crypto.ED25519()) + if err != nil { + fmt.Println(err) + return + } - fmt.Println("⏳ Funding wallet...") - if err := client.FundWallet(&wallet); err != nil { - fmt.Println(err) - return - } + fmt.Println("⏳ Funding wallet...") + if err := client.FundWallet(&wallet); err != nil { + fmt.Println(err) + return + } - fmt.Println("💸 Wallet funded") - fmt.Println() + fmt.Println("💸 Wallet funded") + fmt.Println() - fmt.Println("⏳ Getting paths...") - res, err := client.GetRipplePathFind(&path.RipplePathFindRequest{ - SourceAccount: wallet.GetAddress(), - SourceCurrencies: []pathtypes.RipplePathFindCurrency{ - { - Currency: "XRP", - }, - }, - DestinationAccount: DestinationAccount, - DestinationAmount: DestinationAmount, - }) - if err != nil { - fmt.Println(err) - return - } + fmt.Println("⏳ Getting paths...") + res, err := client.GetRipplePathFind(&path.RipplePathFindRequest{ + SourceAccount: wallet.GetAddress(), + SourceCurrencies: []pathtypes.RipplePathFindCurrency{ + { + Currency: "XRP", + }, + }, + DestinationAccount: DestinationAccount, + DestinationAmount: DestinationAmount, + }) + if err != nil { + fmt.Println(err) + return + } - fmt.Printf("🌐 Computed paths: %d\n", len(res.Alternatives)) - fmt.Println() + fmt.Printf("🌐 Computed paths: %d\n", len(res.Alternatives)) + fmt.Println() - if len(res.Alternatives) == 0 { - fmt.Println("❌ No alternatives found") - return - } + if len(res.Alternatives) == 0 { + fmt.Println("❌ No alternatives found") + return + } - fmt.Println("⏳ Submitting Payment through path: ", res.Alternatives[0].PathsComputed) - p := &transaction.Payment{ - BaseTx: transaction.BaseTx{ - Account: wallet.GetAddress(), - }, - Destination: DestinationAccount, - Amount: DestinationAmount, - Paths: res.Alternatives[0].PathsComputed, - } + fmt.Println("⏳ Submitting Payment through path: ", res.Alternatives[0].PathsComputed) + p := &transaction.Payment{ + BaseTx: transaction.BaseTx{ + Account: wallet.GetAddress(), + }, + Destination: DestinationAccount, + Amount: DestinationAmount, + Paths: res.Alternatives[0].PathsComputed, + } - flatP := p.Flatten() + flatP := p.Flatten() - if err := client.Autofill(&flatP); err != nil { - fmt.Println(err) - return - } + if err := client.Autofill(&flatP); err != nil { + fmt.Println(err) + return + } - blob, hash, err := wallet.Sign(flatP) - if err != nil { - fmt.Println(err) - return - } + blob, hash, err := wallet.Sign(flatP) + if err != nil { + fmt.Println(err) + return + } - txRes, err := client.SubmitTxBlobAndWait(blob, false) - if err != nil { - fmt.Println(err) - return - } + txRes, err := client.SubmitTxBlobAndWait(blob, false) + if err != nil { + fmt.Println(err) + 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) } diff --git a/_code-samples/secure-signing/go/main.go b/_code-samples/secure-signing/go/main.go index daca4f3bd8..91913228f2 100644 --- a/_code-samples/secure-signing/go/main.go +++ b/_code-samples/secure-signing/go/main.go @@ -1,42 +1,42 @@ package main import ( - "fmt" + "fmt" - "github.com/Peersyst/xrpl-go/pkg/crypto" - "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/transaction" + "github.com/Peersyst/xrpl-go/xrpl/transaction/types" + "github.com/Peersyst/xrpl-go/xrpl/wallet" ) func main() { - w, err := wallet.New(crypto.ED25519()) - if err != nil { - panic(err) - } + w, err := wallet.New(crypto.ED25519()) + if err != nil { + panic(err) + } - p := &transaction.Payment{ - BaseTx: transaction.BaseTx{ - Account: types.Address(w.GetAddress()), - Fee: types.XRPCurrencyAmount(13), - Sequence: 1, - Flags: 2147483648, - LastLedgerSequence: 7835923, - }, - Destination: "rPT1Sjq2YGrBMTttX4GZHjKu9dyfzbpAYe", - Amount: types.XRPCurrencyAmount(10000), - DeliverMax: types.XRPCurrencyAmount(10000), - } + p := &transaction.Payment{ + BaseTx: transaction.BaseTx{ + Account: types.Address(w.GetAddress()), + Fee: types.XRPCurrencyAmount(13), + Sequence: 1, + Flags: 2147483648, + LastLedgerSequence: 7835923, + }, + Destination: "rPT1Sjq2YGrBMTttX4GZHjKu9dyfzbpAYe", + Amount: types.XRPCurrencyAmount(10000), + DeliverMax: types.XRPCurrencyAmount(10000), + } - flattenedTx := p.Flatten() + flattenedTx := p.Flatten() - fmt.Println("Payment object created:", flattenedTx) + fmt.Println("Payment object created:", flattenedTx) - signedTx, txHash, err := w.Sign(flattenedTx) - if err != nil { - panic(err) - } + signedTx, txHash, err := w.Sign(flattenedTx) + if err != nil { + panic(err) + } - fmt.Println("Transaction signed successfully:", signedTx) - fmt.Println("Transaction hash:", txHash) + fmt.Println("Transaction signed successfully:", signedTx) + fmt.Println("Transaction hash:", txHash) } diff --git a/_code-samples/send-a-memo/go/rpc/main.go b/_code-samples/send-a-memo/go/rpc/main.go index 0842b072bd..0272103f10 100644 --- a/_code-samples/send-a-memo/go/rpc/main.go +++ b/_code-samples/send-a-memo/go/rpc/main.go @@ -1,115 +1,115 @@ 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() { - w, err := wallet.FromSeed("sEdSMVV4dJ1JbdBxmakRR4Puu3XVZz2", "") - if err != nil { - fmt.Println(err) - return - } + w, err := wallet.FromSeed("sEdSMVV4dJ1JbdBxmakRR4Puu3XVZz2", "") + if err != nil { + fmt.Println(err) + return + } - receiverWallet, err := wallet.FromSeed("sEd7d8Ci9nevdLCeUMctF3uGXp9WQqJ", "") - if err != nil { - fmt.Println(err) - return - } + receiverWallet, err := wallet.FromSeed("sEd7d8Ci9nevdLCeUMctF3uGXp9WQqJ", "") + if err != nil { + fmt.Println(err) + return + } - cfg, err := rpc.NewClientConfig( - "https://s.altnet.rippletest.net:51234/", - rpc.WithFaucetProvider(faucet.NewTestnetFaucetProvider()), - ) - if err != nil { - panic(err) - } + cfg, err := rpc.NewClientConfig( + "https://s.altnet.rippletest.net:51234/", + rpc.WithFaucetProvider(faucet.NewTestnetFaucetProvider()), + ) + if err != nil { + panic(err) + } - client := rpc.NewClient(cfg) + client := rpc.NewClient(cfg) - balance, err := client.GetXrpBalance(w.GetAddress()) + balance, err := client.GetXrpBalance(w.GetAddress()) - if err != nil || balance == "0" { - fmt.Println("⏳ Funding wallet...") - err = client.FundWallet(&w) - if err != nil { - fmt.Println(err) - return - } - fmt.Println("💸 Wallet funded") - } + if err != nil || balance == "0" { + fmt.Println("⏳ Funding wallet...") + err = client.FundWallet(&w) + if err != nil { + fmt.Println(err) + return + } + fmt.Println("💸 Wallet funded") + } - balance, _ = client.GetXrpBalance(w.GetAddress()) + 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 { - fmt.Println(err) - return - } + amount, err := currency.XrpToDrops("1") + if err != nil { + fmt.Println(err) + return + } - amountUint, err := strconv.ParseUint(amount, 10, 64) - if err != nil { - fmt.Println(err) - return - } + amountUint, err := strconv.ParseUint(amount, 10, 64) + if err != nil { + fmt.Println(err) + return + } - fmt.Println("⏳ Sending payment...") - payment := transactions.Payment{ - BaseTx: transactions.BaseTx{ - Account: types.Address(w.GetAddress()), - Memos: []types.MemoWrapper{ - { - Memo: types.Memo{ - MemoData: hex.EncodeToString([]byte("Hello, World!")), - MemoFormat: hex.EncodeToString([]byte("plain")), - MemoType: hex.EncodeToString([]byte("message")), - }, - }, - { - Memo: types.Memo{ - MemoData: hex.EncodeToString([]byte("Hello, World 2!")), - MemoFormat: hex.EncodeToString([]byte("text/plain")), - MemoType: hex.EncodeToString([]byte("message2")), - }, - }, - }, - }, - Destination: types.Address(receiverWallet.GetAddress()), - Amount: types.XRPCurrencyAmount(amountUint), - } + fmt.Println("⏳ Sending payment...") + payment := transactions.Payment{ + BaseTx: transactions.BaseTx{ + Account: types.Address(w.GetAddress()), + Memos: []types.MemoWrapper{ + { + Memo: types.Memo{ + MemoData: hex.EncodeToString([]byte("Hello, World!")), + MemoFormat: hex.EncodeToString([]byte("plain")), + MemoType: hex.EncodeToString([]byte("message")), + }, + }, + { + Memo: types.Memo{ + MemoData: hex.EncodeToString([]byte("Hello, World 2!")), + MemoFormat: hex.EncodeToString([]byte("text/plain")), + MemoType: hex.EncodeToString([]byte("message2")), + }, + }, + }, + }, + Destination: types.Address(receiverWallet.GetAddress()), + Amount: types.XRPCurrencyAmount(amountUint), + } - flatTx := payment.Flatten() + flatTx := payment.Flatten() - err = client.Autofill(&flatTx) - if err != nil { - fmt.Println(err) - return - } + err = client.Autofill(&flatTx) + if err != nil { + fmt.Println(err) + return + } - txBlob, _, err := w.Sign(flatTx) - if err != nil { - fmt.Println(err) - return - } + txBlob, _, err := w.Sign(flatTx) + if err != nil { + fmt.Println(err) + return + } - response, err := client.SubmitTxBlobAndWait(txBlob, true) - if err != nil { - fmt.Println(err) - return - } + response, err := client.SubmitTxBlobAndWait(txBlob, true) + if err != nil { + fmt.Println(err) + 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) } diff --git a/_code-samples/send-a-memo/go/ws/main.go b/_code-samples/send-a-memo/go/ws/main.go index 4fdc94f8df..69b07be380 100644 --- a/_code-samples/send-a-memo/go/ws/main.go +++ b/_code-samples/send-a-memo/go/ws/main.go @@ -1,121 +1,121 @@ 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() { - w, err := wallet.FromSeed("sEdSMVV4dJ1JbdBxmakRR4Puu3XVZz2", "") - if err != nil { - fmt.Println(err) - return - } + w, err := wallet.FromSeed("sEdSMVV4dJ1JbdBxmakRR4Puu3XVZz2", "") + if err != nil { + fmt.Println(err) + return + } - receiverWallet, err := wallet.FromSeed("sEd7d8Ci9nevdLCeUMctF3uGXp9WQqJ", "") - if err != nil { - fmt.Println(err) - return - } + receiverWallet, err := wallet.FromSeed("sEd7d8Ci9nevdLCeUMctF3uGXp9WQqJ", "") + if err != nil { + fmt.Println(err) + return + } - client := websocket.NewClient( - websocket.NewClientConfig(). - WithHost("wss://s.altnet.rippletest.net:51233"). - WithFaucetProvider(faucet.NewTestnetFaucetProvider()), - ) - defer client.Disconnect() + client := websocket.NewClient( + websocket.NewClientConfig(). + WithHost("wss://s.altnet.rippletest.net:51233"). + WithFaucetProvider(faucet.NewTestnetFaucetProvider()), + ) + defer client.Disconnect() - fmt.Println("⏳ Connecting to server...") - if err := client.Connect(); err != nil { - fmt.Println(err) - return - } + fmt.Println("⏳ Connecting to server...") + if err := client.Connect(); err != nil { + fmt.Println(err) + return + } - fmt.Println("✅ Connected to server") - fmt.Println() + fmt.Println("✅ Connected to server") + fmt.Println() - balance, err := client.GetXrpBalance(w.GetAddress()) + balance, err := client.GetXrpBalance(w.GetAddress()) - if err != nil || balance == "0" { - fmt.Println("⏳ Funding wallet...") - err = client.FundWallet(&w) - if err != nil { - fmt.Println(err) - return - } - fmt.Println("💸 Wallet funded") - } + if err != nil || balance == "0" { + fmt.Println("⏳ Funding wallet...") + err = client.FundWallet(&w) + if err != nil { + fmt.Println(err) + return + } + fmt.Println("💸 Wallet funded") + } - balance, _ = client.GetXrpBalance(w.GetAddress()) + 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 { - fmt.Println(err) - return - } + amount, err := currency.XrpToDrops("1") + if err != nil { + fmt.Println(err) + return + } - amountUint, err := strconv.ParseUint(amount, 10, 64) - if err != nil { - fmt.Println(err) - return - } + amountUint, err := strconv.ParseUint(amount, 10, 64) + if err != nil { + fmt.Println(err) + return + } - fmt.Println("⏳ Sending payment...") - payment := transactions.Payment{ - BaseTx: transactions.BaseTx{ - Account: types.Address(w.GetAddress()), - Memos: []types.MemoWrapper{ - { - Memo: types.Memo{ - MemoData: hex.EncodeToString([]byte("Hello, World!")), - MemoFormat: hex.EncodeToString([]byte("plain")), - MemoType: hex.EncodeToString([]byte("message")), - }, - }, - { - Memo: types.Memo{ - MemoData: hex.EncodeToString([]byte("Hello, World 2!")), - MemoFormat: hex.EncodeToString([]byte("text/plain")), - MemoType: hex.EncodeToString([]byte("message2")), - }, - }, - }, - }, - Destination: types.Address(receiverWallet.GetAddress()), - Amount: types.XRPCurrencyAmount(amountUint), - } + fmt.Println("⏳ Sending payment...") + payment := transactions.Payment{ + BaseTx: transactions.BaseTx{ + Account: types.Address(w.GetAddress()), + Memos: []types.MemoWrapper{ + { + Memo: types.Memo{ + MemoData: hex.EncodeToString([]byte("Hello, World!")), + MemoFormat: hex.EncodeToString([]byte("plain")), + MemoType: hex.EncodeToString([]byte("message")), + }, + }, + { + Memo: types.Memo{ + MemoData: hex.EncodeToString([]byte("Hello, World 2!")), + MemoFormat: hex.EncodeToString([]byte("text/plain")), + MemoType: hex.EncodeToString([]byte("message2")), + }, + }, + }, + }, + Destination: types.Address(receiverWallet.GetAddress()), + Amount: types.XRPCurrencyAmount(amountUint), + } - flatTx := payment.Flatten() + flatTx := payment.Flatten() - err = client.Autofill(&flatTx) - if err != nil { - fmt.Println(err) - return - } + err = client.Autofill(&flatTx) + if err != nil { + fmt.Println(err) + return + } - txBlob, _, err := w.Sign(flatTx) - if err != nil { - fmt.Println(err) - return - } + txBlob, _, err := w.Sign(flatTx) + if err != nil { + fmt.Println(err) + return + } - response, err := client.SubmitTxBlobAndWait(txBlob, true) - if err != nil { - fmt.Println(err) - return - } + response, err := client.SubmitTxBlobAndWait(txBlob, true) + if err != nil { + fmt.Println(err) + 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) } diff --git a/_code-samples/send-xrp/go/rpc/main.go b/_code-samples/send-xrp/go/rpc/main.go index fd62e66556..7081d4b21b 100644 --- a/_code-samples/send-xrp/go/rpc/main.go +++ b/_code-samples/send-xrp/go/rpc/main.go @@ -1,111 +1,111 @@ 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 ( - WalletSeed = "sn3nxiW7v8KXzPzAqzyHXbSSKNuN9" + WalletSeed = "sn3nxiW7v8KXzPzAqzyHXbSSKNuN9" ) func main() { - cfg, err := rpc.NewClientConfig( - "https://s.altnet.rippletest.net:51234/", - rpc.WithMaxFeeXRP(5.0), - rpc.WithFeeCushion(1.5), - rpc.WithFaucetProvider(faucet.NewTestnetFaucetProvider()), - ) - if err != nil { - panic(err) - } + cfg, err := rpc.NewClientConfig( + "https://s.altnet.rippletest.net:51234/", + rpc.WithMaxFeeXRP(5.0), + rpc.WithFeeCushion(1.5), + rpc.WithFaucetProvider(faucet.NewTestnetFaucetProvider()), + ) + if err != nil { + panic(err) + } - client := rpc.NewClient(cfg) + client := rpc.NewClient(cfg) - w, err := wallet.FromSeed(WalletSeed, "") - if err != nil { - fmt.Println(err) - return - } + w, err := wallet.FromSeed(WalletSeed, "") + if err != nil { + fmt.Println(err) + return + } - fmt.Println("⏳ Funding wallet...") - if err := client.FundWallet(&w); err != nil { - fmt.Println(err) - return - } + fmt.Println("⏳ Funding wallet...") + if err := client.FundWallet(&w); err != nil { + fmt.Println(err) + return + } - fmt.Println("💸 Wallet funded") - fmt.Println() + fmt.Println("💸 Wallet funded") + fmt.Println() - xrpAmount, err := currency.XrpToDrops("1") - if err != nil { - fmt.Println(err) - return - } + xrpAmount, err := currency.XrpToDrops("1") + if err != nil { + fmt.Println(err) + return + } - xrpAmountInt, err := strconv.ParseInt(xrpAmount, 10, 64) - if err != nil { - fmt.Println(err) - return - } + xrpAmountInt, err := strconv.ParseInt(xrpAmount, 10, 64) + if err != nil { + fmt.Println(err) + return + } - fmt.Println("⏳ Sending 1 XRP to rPT1Sjq2YGrBMTttX4GZHjKu9dyfzbpAYe...") - p := &transaction.Payment{ - BaseTx: transaction.BaseTx{ - Account: types.Address(w.GetAddress()), - }, - Destination: "rPT1Sjq2YGrBMTttX4GZHjKu9dyfzbpAYe", - Amount: types.XRPCurrencyAmount(xrpAmountInt), - DeliverMax: types.XRPCurrencyAmount(xrpAmountInt), - } + fmt.Println("⏳ Sending 1 XRP to rPT1Sjq2YGrBMTttX4GZHjKu9dyfzbpAYe...") + p := &transaction.Payment{ + BaseTx: transaction.BaseTx{ + Account: types.Address(w.GetAddress()), + }, + Destination: "rPT1Sjq2YGrBMTttX4GZHjKu9dyfzbpAYe", + Amount: types.XRPCurrencyAmount(xrpAmountInt), + DeliverMax: types.XRPCurrencyAmount(xrpAmountInt), + } - flattenedTx := p.Flatten() + flattenedTx := p.Flatten() - if err := client.Autofill(&flattenedTx); err != nil { - fmt.Println(err) - return - } + if err := client.Autofill(&flattenedTx); err != nil { + fmt.Println(err) + return + } - txBlob, _, err := w.Sign(flattenedTx) - if err != nil { - fmt.Println(err) - return - } + txBlob, _, err := w.Sign(flattenedTx) + if err != nil { + fmt.Println(err) + return + } - res, err := client.SubmitTxBlobAndWait(txBlob, false) - if err != nil { - fmt.Println(err) - return - } + res, err := client.SubmitTxBlobAndWait(txBlob, false) + if err != nil { + fmt.Println(err) + return + } - 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() + 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() - flattenedTx2 := p.Flatten() - resp, err := client.SubmitTxAndWait(flattenedTx2, &rpctypes.SubmitOptions{ - Autofill: true, - Wallet: &w, - }) - if err != nil { - fmt.Println(err) - return - } + flattenedTx2 := p.Flatten() + resp, err := client.SubmitTxAndWait(flattenedTx2, &rpctypes.SubmitOptions{ + Autofill: true, + Wallet: &w, + }) + if err != nil { + fmt.Println(err) + 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) } diff --git a/_code-samples/send-xrp/go/ws/main.go b/_code-samples/send-xrp/go/ws/main.go index 84555843ac..d154a9e61a 100644 --- a/_code-samples/send-xrp/go/ws/main.go +++ b/_code-samples/send-xrp/go/ws/main.go @@ -1,35 +1,35 @@ 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() { client := websocket.NewClient( - websocket.NewClientConfig(). - WithHost("wss://s.altnet.rippletest.net:51233"). - WithFaucetProvider(faucet.NewTestnetFaucetProvider()), + websocket.NewClientConfig(). + WithHost("wss://s.altnet.rippletest.net:51233"). + WithFaucetProvider(faucet.NewTestnetFaucetProvider()), ) defer client.Disconnect() if err := client.Connect(); err != nil { - fmt.Println(err) - return + fmt.Println(err) + return } if !client.IsConnected() { - fmt.Println("❌ Failed to connect to testnet") - return + fmt.Println("❌ Failed to connect to testnet") + return } fmt.Println("✅ Connected to testnet") @@ -39,15 +39,15 @@ fmt.Println() const WalletSeed = "sEd7zwWAu7vXMCBkkzokJHEXiKw2B2s" w, err := wallet.FromSeed(WalletSeed, "") if err != nil { - fmt.Println(err) - return + fmt.Println(err) + return } // Funding the wallet fmt.Println("⏳ Funding wallet...") if err := client.FundWallet(&w); err != nil { - fmt.Println(err) - return + fmt.Println(err) + return } fmt.Println("💸 Wallet funded") @@ -55,56 +55,56 @@ fmt.Println() xrpAmount, err := currency.XrpToDrops("1") if err != nil { - fmt.Println(err) - return + fmt.Println(err) + return } xrpAmountInt, err := strconv.ParseInt(xrpAmount, 10, 64) if err != nil { - fmt.Println(err) - return + fmt.Println(err) + return } // Prepare a payment transaction p := &transaction.Payment{ - BaseTx: transaction.BaseTx{ - Account: types.Address(w.GetAddress()), - }, - Destination: "rPT1Sjq2YGrBMTttX4GZHjKu9dyfzbpAYe", - Amount: types.XRPCurrencyAmount(xrpAmountInt), - DeliverMax: types.XRPCurrencyAmount(xrpAmountInt), + BaseTx: transaction.BaseTx{ + Account: types.Address(w.GetAddress()), + }, + Destination: "rPT1Sjq2YGrBMTttX4GZHjKu9dyfzbpAYe", + Amount: types.XRPCurrencyAmount(xrpAmountInt), + DeliverMax: types.XRPCurrencyAmount(xrpAmountInt), } flattenedTx := p.Flatten() if err := client.Autofill(&flattenedTx); err != nil { - fmt.Println(err) - return + fmt.Println(err) + return } // Sign the transaction using the wallet txBlob, _, err := w.Sign(flattenedTx) if err != nil { - fmt.Println(err) - return + fmt.Println(err) + return } // Submit the transaction and wait for the result res_blob, err := client.SubmitTxBlobAndWait(txBlob, false) if err != nil { - fmt.Println(err) - return + fmt.Println(err) + return } // Example with SubmitTxAndWait flattenedTx2 := p.Flatten() res_flat, err := client.SubmitTxAndWait(flattenedTx2, &wstypes.SubmitOptions{ - Autofill: true, - Wallet: &w, + Autofill: true, + Wallet: &w, }) if err != nil { - fmt.Println(err) - return + fmt.Println(err) + return } // Wait for validation ------------------------------------------------------- // SubmitTxBlobAndWait() handles this automatically, but it can take 4-7s. @@ -113,7 +113,7 @@ if err != nil { 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(), + Transaction: res_flat.Hash.String(), }) fmt.Printf("🌐 Result: %s\n", res.Result) } diff --git a/_code-samples/set-regular-key/go/rpc/main.go b/_code-samples/set-regular-key/go/rpc/main.go index dd58029a6a..f4cd3c5569 100644 --- a/_code-samples/set-regular-key/go/rpc/main.go +++ b/_code-samples/set-regular-key/go/rpc/main.go @@ -1,131 +1,131 @@ 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() { - cfg, err := rpc.NewClientConfig( - "https://s.altnet.rippletest.net:51234/", - rpc.WithFaucetProvider(faucet.NewTestnetFaucetProvider()), - ) - if err != nil { - panic(err) - } + cfg, err := rpc.NewClientConfig( + "https://s.altnet.rippletest.net:51234/", + rpc.WithFaucetProvider(faucet.NewTestnetFaucetProvider()), + ) + if err != nil { + panic(err) + } - client := rpc.NewClient(cfg) + client := rpc.NewClient(cfg) - w1, err := wallet.New(crypto.ED25519()) - if err != nil { - fmt.Println(err) - return - } + w1, err := wallet.New(crypto.ED25519()) + if err != nil { + fmt.Println(err) + return + } - w2, err := wallet.New(crypto.ED25519()) - if err != nil { - fmt.Println(err) - return - } + w2, err := wallet.New(crypto.ED25519()) + if err != nil { + fmt.Println(err) + return + } - regularKeyWallet, err := wallet.New(crypto.ED25519()) - if err != nil { - fmt.Println(err) - return - } + regularKeyWallet, err := wallet.New(crypto.ED25519()) + if err != nil { + fmt.Println(err) + return + } - fmt.Println("⏳ Funding wallets...") - if err := client.FundWallet(&w1); err != nil { - fmt.Println(err) - return - } + 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 - } + 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(®ularKeyWallet); err != nil { - fmt.Println(err) - return - } + if err := client.FundWallet(®ularKeyWallet); err != nil { + fmt.Println(err) + return + } - fmt.Println("💸 Regular key wallet funded") - fmt.Println() + fmt.Println("💸 Regular key wallet funded") + fmt.Println() - fmt.Println("⏳ Setting regular key...") - rk := &transaction.SetRegularKey{ - BaseTx: transaction.BaseTx{ - Account: w1.GetAddress(), - }, - RegularKey: regularKeyWallet.GetAddress(), - } + fmt.Println("⏳ Setting regular key...") + rk := &transaction.SetRegularKey{ + BaseTx: transaction.BaseTx{ + Account: w1.GetAddress(), + }, + RegularKey: regularKeyWallet.GetAddress(), + } - flatRk := rk.Flatten() + flatRk := rk.Flatten() - err = client.Autofill(&flatRk) - if err != nil { - fmt.Println(err) - return - } + err = client.Autofill(&flatRk) + if err != nil { + fmt.Println(err) + return + } - blob, _, err := w1.Sign(flatRk) - if err != nil { - fmt.Println(err) - return - } + blob, _, err := w1.Sign(flatRk) + if err != nil { + fmt.Println(err) + return + } - res, err := client.SubmitTxBlobAndWait(blob, false) - if err != nil { - fmt.Println(err) - return - } + res, err := client.SubmitTxBlobAndWait(blob, false) + if err != nil { + fmt.Println(err) + return + } - fmt.Println("✅ SetRegularKey transaction submitted") - fmt.Printf("🌐 Hash: %s\n", res.Hash) - fmt.Printf("🌐 Validated: %t\n", res.Validated) - fmt.Println() + 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...") - p := &transaction.Payment{ - BaseTx: transaction.BaseTx{ - Account: w1.GetAddress(), - }, - Destination: w2.GetAddress(), - Amount: types.XRPCurrencyAmount(10000), - } + fmt.Println("⏳ Checking if regular key is set...") + p := &transaction.Payment{ + BaseTx: transaction.BaseTx{ + Account: w1.GetAddress(), + }, + Destination: w2.GetAddress(), + Amount: types.XRPCurrencyAmount(10000), + } - flatP := p.Flatten() + flatP := p.Flatten() - err = client.Autofill(&flatP) - if err != nil { - fmt.Println(err) - return - } + err = client.Autofill(&flatP) + if err != nil { + fmt.Println(err) + return + } - blob, _, err = regularKeyWallet.Sign(flatP) - if err != nil { - fmt.Println(err) - return - } + blob, _, err = regularKeyWallet.Sign(flatP) + if err != nil { + fmt.Println(err) + return + } - res, err = client.SubmitTxBlobAndWait(blob, false) - if err != nil { - fmt.Println(err) - return - } + res, err = client.SubmitTxBlobAndWait(blob, false) + if err != nil { + fmt.Println(err) + 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) } diff --git a/_code-samples/set-regular-key/go/ws/main.go b/_code-samples/set-regular-key/go/ws/main.go index 3bb0ec6256..8f1416a59f 100644 --- a/_code-samples/set-regular-key/go/ws/main.go +++ b/_code-samples/set-regular-key/go/ws/main.go @@ -1,142 +1,142 @@ 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...") - client := websocket.NewClient( - websocket.NewClientConfig(). - WithHost("wss://s.altnet.rippletest.net:51233"). - WithFaucetProvider(faucet.NewTestnetFaucetProvider()), - ) - defer client.Disconnect() + fmt.Println("⏳ Connecting to testnet...") + client := websocket.NewClient( + websocket.NewClientConfig(). + WithHost("wss://s.altnet.rippletest.net:51233"). + WithFaucetProvider(faucet.NewTestnetFaucetProvider()), + ) + defer client.Disconnect() - if err := client.Connect(); err != nil { - fmt.Println(err) - return - } + if err := client.Connect(); err != nil { + fmt.Println(err) + return + } - if !client.IsConnected() { - fmt.Println("❌ Failed to connect to testnet") - return - } + if !client.IsConnected() { + fmt.Println("❌ Failed to connect to testnet") + return + } - fmt.Println("✅ Connected to testnet") - fmt.Println() + fmt.Println("✅ Connected to testnet") + fmt.Println() - w1, err := wallet.New(crypto.ED25519()) - if err != nil { - fmt.Println(err) - return - } + w1, err := wallet.New(crypto.ED25519()) + if err != nil { + fmt.Println(err) + return + } - w2, err := wallet.New(crypto.ED25519()) - if err != nil { - fmt.Println(err) - return - } + w2, err := wallet.New(crypto.ED25519()) + if err != nil { + fmt.Println(err) + return + } - regularKeyWallet, err := wallet.New(crypto.ED25519()) - if err != nil { - fmt.Println(err) - return - } + regularKeyWallet, err := wallet.New(crypto.ED25519()) + if err != nil { + fmt.Println(err) + return + } - fmt.Println("⏳ Funding wallets...") - if err := client.FundWallet(&w1); err != nil { - fmt.Println(err) - return - } + 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 - } + 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(®ularKeyWallet); err != nil { - fmt.Println(err) - return - } + if err := client.FundWallet(®ularKeyWallet); err != nil { + fmt.Println(err) + return + } - fmt.Println("💸 Regular key wallet funded") - fmt.Println() + fmt.Println("💸 Regular key wallet funded") + fmt.Println() - fmt.Println("⏳ Setting regular key...") - rk := &transaction.SetRegularKey{ - BaseTx: transaction.BaseTx{ - Account: w1.GetAddress(), - }, - RegularKey: regularKeyWallet.GetAddress(), - } + fmt.Println("⏳ Setting regular key...") + rk := &transaction.SetRegularKey{ + BaseTx: transaction.BaseTx{ + Account: w1.GetAddress(), + }, + RegularKey: regularKeyWallet.GetAddress(), + } - flatRk := rk.Flatten() + flatRk := rk.Flatten() - err = client.Autofill(&flatRk) - if err != nil { - fmt.Println(err) - return - } + err = client.Autofill(&flatRk) + if err != nil { + fmt.Println(err) + return + } - blob, _, err := w1.Sign(flatRk) - if err != nil { - fmt.Println(err) - return - } + blob, _, err := w1.Sign(flatRk) + if err != nil { + fmt.Println(err) + return + } - res, err := client.SubmitTxBlobAndWait(blob, false) - if err != nil { - fmt.Println(err) - return - } + res, err := client.SubmitTxBlobAndWait(blob, false) + if err != nil { + fmt.Println(err) + return + } - fmt.Println("✅ SetRegularKey transaction submitted") - fmt.Printf("🌐 Hash: %s\n", res.Hash) - fmt.Printf("🌐 Validated: %t\n", res.Validated) - fmt.Println() + 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...") - p := &transaction.Payment{ - BaseTx: transaction.BaseTx{ - Account: w1.GetAddress(), - }, - Destination: w2.GetAddress(), - Amount: types.XRPCurrencyAmount(10000), - } + fmt.Println("⏳ Checking if regular key is set...") + p := &transaction.Payment{ + BaseTx: transaction.BaseTx{ + Account: w1.GetAddress(), + }, + Destination: w2.GetAddress(), + Amount: types.XRPCurrencyAmount(10000), + } - flatP := p.Flatten() + flatP := p.Flatten() - err = client.Autofill(&flatP) - if err != nil { - fmt.Println(err) - return - } + err = client.Autofill(&flatP) + if err != nil { + fmt.Println(err) + return + } - blob, _, err = regularKeyWallet.Sign(flatP) - if err != nil { - fmt.Println(err) - return - } + blob, _, err = regularKeyWallet.Sign(flatP) + if err != nil { + fmt.Println(err) + return + } - res, err = client.SubmitTxBlobAndWait(blob, false) - if err != nil { - fmt.Println(err) - return - } + res, err = client.SubmitTxBlobAndWait(blob, false) + if err != nil { + fmt.Println(err) + 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) } diff --git a/_code-samples/use-tickets/go/main.go b/_code-samples/use-tickets/go/main.go index 626e8932d9..e56852c85a 100644 --- a/_code-samples/use-tickets/go/main.go +++ b/_code-samples/use-tickets/go/main.go @@ -1,134 +1,134 @@ 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() { - cfg, err := rpc.NewClientConfig( - "https://s.altnet.rippletest.net:51234/", - rpc.WithFaucetProvider(faucet.NewTestnetFaucetProvider()), - ) - if err != nil { - panic(err) - } + cfg, err := rpc.NewClientConfig( + "https://s.altnet.rippletest.net:51234/", + rpc.WithFaucetProvider(faucet.NewTestnetFaucetProvider()), + ) + if err != nil { + panic(err) + } - client := rpc.NewClient(cfg) + client := rpc.NewClient(cfg) - w, err := wallet.New(crypto.ED25519()) - if err != nil { - fmt.Println(err) - return - } + w, err := wallet.New(crypto.ED25519()) + if err != nil { + fmt.Println(err) + return + } - fmt.Println("⏳ Funding wallet...") - if err := client.FundWallet(&w); err != nil { - fmt.Println(err) - return - } + fmt.Println("⏳ Funding wallet...") + if err := client.FundWallet(&w); err != nil { + fmt.Println(err) + return + } - fmt.Println("💸 Wallet funded") - fmt.Println() + fmt.Println("💸 Wallet funded") + fmt.Println() - info, err := client.GetAccountInfo(&account.InfoRequest{ - Account: w.GetAddress(), - }) - if err != nil { - fmt.Println(err) - return - } + info, err := client.GetAccountInfo(&account.InfoRequest{ + Account: w.GetAddress(), + }) + if err != nil { + fmt.Println(err) + return + } - fmt.Println("🌐 Current wallet sequence:", info.AccountData.Sequence) - fmt.Println() + fmt.Println("🌐 Current wallet sequence:", info.AccountData.Sequence) + fmt.Println() - fmt.Println("⏳ Submitting TicketCreate transaction...") - tc := &transaction.TicketCreate{ - BaseTx: transaction.BaseTx{ - Account: w.GetAddress(), - Sequence: info.AccountData.Sequence, - }, - TicketCount: 10, - } + fmt.Println("⏳ Submitting TicketCreate transaction...") + tc := &transaction.TicketCreate{ + BaseTx: transaction.BaseTx{ + Account: w.GetAddress(), + Sequence: info.AccountData.Sequence, + }, + TicketCount: 10, + } - flatTc := tc.Flatten() + flatTc := tc.Flatten() - if err := client.Autofill(&flatTc); err != nil { - fmt.Println(err) - return - } + if err := client.Autofill(&flatTc); err != nil { + fmt.Println(err) + return + } - blob, _, err := w.Sign(flatTc) - if err != nil { - fmt.Println(err) - return - } + blob, _, err := w.Sign(flatTc) + if err != nil { + fmt.Println(err) + return + } - res, err := client.SubmitTxBlobAndWait(blob, false) - if err != nil { - fmt.Println(err) - return - } + res, err := client.SubmitTxBlobAndWait(blob, false) + if err != nil { + fmt.Println(err) + return + } - fmt.Println("✅ TicketCreate transaction submitted") - fmt.Printf("🌐 Hash: %s\n", res.Hash) - fmt.Printf("🌐 Validated: %t\n", res.Validated) - fmt.Println() + 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{ - Account: w.GetAddress(), - }) - if err != nil { - fmt.Println(err) - return - } + objects, err := client.GetAccountObjects(&account.ObjectsRequest{ + Account: w.GetAddress(), + }) + if err != nil { + fmt.Println(err) + 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 { - fmt.Println(err) - return - } + seq, err := objects.AccountObjects[0]["TicketSequence"].(json.Number).Int64() + if err != nil { + fmt.Println(err) + return + } - fmt.Println("⏳ Submitting AccountSet transaction...") - as := &transaction.AccountSet{ - BaseTx: transaction.BaseTx{ - Account: w.GetAddress(), - Sequence: 0, - TicketSequence: uint32(seq), - }, - } + fmt.Println("⏳ Submitting AccountSet transaction...") + as := &transaction.AccountSet{ + BaseTx: transaction.BaseTx{ + Account: w.GetAddress(), + Sequence: 0, + TicketSequence: uint32(seq), + }, + } - flatAs := as.Flatten() + flatAs := as.Flatten() - if err := client.Autofill(&flatAs); err != nil { - fmt.Println(err) - return - } + if err := client.Autofill(&flatAs); err != nil { + fmt.Println(err) + return + } - flatAs["Sequence"] = uint32(0) + flatAs["Sequence"] = uint32(0) - blob, _, err = w.Sign(flatAs) - if err != nil { - fmt.Println(err) - return - } + blob, _, err = w.Sign(flatAs) + if err != nil { + fmt.Println(err) + return + } - res, err = client.SubmitTxBlobAndWait(blob, false) - if err != nil { - fmt.Println(err) - return - } + res, err = client.SubmitTxBlobAndWait(blob, false) + if err != nil { + fmt.Println(err) + 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) }