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

chore(samples): replace tab for 4 spaces

Browse Source
This commit is contained in:
banasa44
2025-07-23 10:51:03 +02:00
committed by akcodez
parent 2abda7d682
commit 43630fbdca
44 changed files with 5891 additions and 5891 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -1,208 +1,208 @@
package main package main
import ( import (
"fmt" "fmt"
"github.com/Peersyst/xrpl-go/pkg/crypto" "github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet" "github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/rpc" "github.com/Peersyst/xrpl-go/xrpl/rpc"
"github.com/Peersyst/xrpl-go/xrpl/rpc/types" "github.com/Peersyst/xrpl-go/xrpl/rpc/types"
"github.com/Peersyst/xrpl-go/xrpl/transaction" "github.com/Peersyst/xrpl-go/xrpl/transaction"
txnTypes "github.com/Peersyst/xrpl-go/xrpl/transaction/types" txnTypes "github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet" "github.com/Peersyst/xrpl-go/xrpl/wallet"
) )
var ( var (
CreatePaymentTx = func(sender, receiver *wallet.Wallet, amount txnTypes.CurrencyAmount) *transaction.Payment { CreatePaymentTx = func(sender, receiver *wallet.Wallet, amount txnTypes.CurrencyAmount) *transaction.Payment {
return &transaction.Payment{ return &transaction.Payment{
BaseTx: transaction.BaseTx{ BaseTx: transaction.BaseTx{
Account: sender.GetAddress(), Account: sender.GetAddress(),
TransactionType: transaction.PaymentTx, TransactionType: transaction.PaymentTx,
Flags: txnTypes.TfInnerBatchTxn, Flags: txnTypes.TfInnerBatchTxn,
}, },
Amount: amount, Amount: amount,
Destination: receiver.GetAddress(), Destination: receiver.GetAddress(),
} }
} }
) )
func main() { func main() {
// Configure the client // Configure the client
cfg, err := rpc.NewClientConfig( cfg, err := rpc.NewClientConfig(
"https://s.devnet.rippletest.net:51234/", "https://s.devnet.rippletest.net:51234/",
rpc.WithFaucetProvider(faucet.NewDevnetFaucetProvider()), rpc.WithFaucetProvider(faucet.NewDevnetFaucetProvider()),
) )
if err != nil { if err != nil {
panic(err) panic(err)
} }
client := rpc.NewClient(cfg) client := rpc.NewClient(cfg)
// Create and fund wallets // Create and fund wallets
userWallet, err := wallet.New(crypto.ED25519()) userWallet, err := wallet.New(crypto.ED25519())
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
user2Wallet, err := wallet.New(crypto.ED25519()) user2Wallet, err := wallet.New(crypto.ED25519())
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
receiverWallet, err := wallet.New(crypto.ED25519()) receiverWallet, err := wallet.New(crypto.ED25519())
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("⏳ Funding wallets...") fmt.Println("⏳ Funding wallets...")
if err := client.FundWallet(&userWallet); err != nil { if err := client.FundWallet(&userWallet); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
if err := client.FundWallet(&user2Wallet); err != nil { if err := client.FundWallet(&user2Wallet); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("💸 Wallets funded") fmt.Println("💸 Wallets funded")
// Check initial balances // Check initial balances
userBalance, err := client.GetXrpBalance(userWallet.ClassicAddress) userBalance, err := client.GetXrpBalance(userWallet.ClassicAddress)
if err != nil { if err != nil {
userBalance = "0" userBalance = "0"
} }
user2Balance, err := client.GetXrpBalance(user2Wallet.ClassicAddress) user2Balance, err := client.GetXrpBalance(user2Wallet.ClassicAddress)
if err != nil { if err != nil {
user2Balance = "0" user2Balance = "0"
} }
receiverBalance, err := client.GetXrpBalance(receiverWallet.ClassicAddress) receiverBalance, err := client.GetXrpBalance(receiverWallet.ClassicAddress)
if err != nil { if err != nil {
receiverBalance = "0" receiverBalance = "0"
} }
fmt.Printf("💳 User initial balance: %s XRP\n", userBalance) fmt.Printf("💳 User initial balance: %s XRP\n", userBalance)
fmt.Printf("💳 User2 initial balance: %s XRP\n", user2Balance) fmt.Printf("💳 User2 initial balance: %s XRP\n", user2Balance)
fmt.Printf("💳 Receiver initial balance: %s XRP\n", receiverBalance) fmt.Printf("💳 Receiver initial balance: %s XRP\n", receiverBalance)
fmt.Println() fmt.Println()
fmt.Printf("Batch transaction test\n") fmt.Printf("Batch transaction test\n")
// Create test batch transaction // Create test batch transaction
batchTx := &transaction.Batch{ batchTx := &transaction.Batch{
BaseTx: transaction.BaseTx{ BaseTx: transaction.BaseTx{
Account: txnTypes.Address(userWallet.ClassicAddress), Account: txnTypes.Address(userWallet.ClassicAddress),
TransactionType: transaction.BatchTx, TransactionType: transaction.BatchTx,
}, },
RawTransactions: []txnTypes.RawTransaction{ RawTransactions: []txnTypes.RawTransaction{
{RawTransaction: CreatePaymentTx(&userWallet, &receiverWallet, txnTypes.XRPCurrencyAmount(5000000)).Flatten()}, {RawTransaction: CreatePaymentTx(&userWallet, &receiverWallet, txnTypes.XRPCurrencyAmount(5000000)).Flatten()},
{RawTransaction: CreatePaymentTx(&userWallet, &receiverWallet, txnTypes.XRPCurrencyAmount(5000000)).Flatten()}, {RawTransaction: CreatePaymentTx(&userWallet, &receiverWallet, txnTypes.XRPCurrencyAmount(5000000)).Flatten()},
}, },
} }
batchTx.SetAllOrNothingFlag() batchTx.SetAllOrNothingFlag()
flattenedBatchTx := batchTx.Flatten() flattenedBatchTx := batchTx.Flatten()
fmt.Println("⏳ Autofilling flattened batch transaction...") fmt.Println("⏳ Autofilling flattened batch transaction...")
if err := client.Autofill(&flattenedBatchTx); err != nil { if err := client.Autofill(&flattenedBatchTx); err != nil {
fmt.Println("Autofill error:", err) fmt.Println("Autofill error:", err)
return return
} }
fmt.Println("⏳ Signing batch transaction...") fmt.Println("⏳ Signing batch transaction...")
response, err := client.SubmitTxAndWait(flattenedBatchTx, &types.SubmitOptions{ response, err := client.SubmitTxAndWait(flattenedBatchTx, &types.SubmitOptions{
Autofill: false, Autofill: false,
Wallet: &userWallet, Wallet: &userWallet,
}) })
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("✅ Batch transaction submitted") fmt.Println("✅ Batch transaction submitted")
fmt.Printf("🌐 Hash: %s\n", response.Hash.String()) fmt.Printf("🌐 Hash: %s\n", response.Hash.String())
fmt.Printf("🌐 Validated: %t\n", response.Validated) fmt.Printf("🌐 Validated: %t\n", response.Validated)
fmt.Println() fmt.Println()
// Check final balances // Check final balances
finalUserBalance, err := client.GetXrpBalance(userWallet.ClassicAddress) finalUserBalance, err := client.GetXrpBalance(userWallet.ClassicAddress)
if err != nil { if err != nil {
finalUserBalance = "0" finalUserBalance = "0"
} }
finalReceiverBalance, err := client.GetXrpBalance(receiverWallet.ClassicAddress) finalReceiverBalance, err := client.GetXrpBalance(receiverWallet.ClassicAddress)
if err != nil { if err != nil {
finalReceiverBalance = "0" 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.Println()
fmt.Printf("Multisig Batch transaction test\n") fmt.Printf("Multisig Batch transaction test\n")
// Create test batch transaction // Create test batch transaction
multiBatchTx := &transaction.Batch{ multiBatchTx := &transaction.Batch{
BaseTx: transaction.BaseTx{ BaseTx: transaction.BaseTx{
Account: txnTypes.Address(userWallet.ClassicAddress), Account: txnTypes.Address(userWallet.ClassicAddress),
TransactionType: transaction.BatchTx, TransactionType: transaction.BatchTx,
}, },
RawTransactions: []txnTypes.RawTransaction{ RawTransactions: []txnTypes.RawTransaction{
{RawTransaction: CreatePaymentTx(&userWallet, &receiverWallet, txnTypes.XRPCurrencyAmount(5000000)).Flatten()}, {RawTransaction: CreatePaymentTx(&userWallet, &receiverWallet, txnTypes.XRPCurrencyAmount(5000000)).Flatten()},
{RawTransaction: CreatePaymentTx(&user2Wallet, &receiverWallet, txnTypes.XRPCurrencyAmount(5000000)).Flatten()}, {RawTransaction: CreatePaymentTx(&user2Wallet, &receiverWallet, txnTypes.XRPCurrencyAmount(5000000)).Flatten()},
}, },
BatchSigners: []txnTypes.BatchSigner{ BatchSigners: []txnTypes.BatchSigner{
{ {
BatchSigner: txnTypes.BatchSignerData{ BatchSigner: txnTypes.BatchSignerData{
Account: txnTypes.Address(user2Wallet.ClassicAddress), Account: txnTypes.Address(user2Wallet.ClassicAddress),
SigningPubKey: user2Wallet.PublicKey, SigningPubKey: user2Wallet.PublicKey,
}, },
}, },
}, },
} }
multiBatchTx.SetAllOrNothingFlag() multiBatchTx.SetAllOrNothingFlag()
flattenedMultiBatchTx := multiBatchTx.Flatten() flattenedMultiBatchTx := multiBatchTx.Flatten()
fmt.Println("⏳ Autofilling flattened multi batch transaction...") fmt.Println("⏳ Autofilling flattened multi batch transaction...")
if err := client.AutofillMultisigned(&flattenedMultiBatchTx, 1); err != nil { if err := client.AutofillMultisigned(&flattenedMultiBatchTx, 1); err != nil {
fmt.Println("Autofill error:", err) fmt.Println("Autofill error:", err)
return return
} }
fmt.Println("⏳ Signing multi batch transaction...") fmt.Println("⏳ Signing multi batch transaction...")
if err := wallet.SignMultiBatch(user2Wallet, &flattenedMultiBatchTx, nil); err != nil { if err := wallet.SignMultiBatch(user2Wallet, &flattenedMultiBatchTx, nil); err != nil {
fmt.Println("Signing error:", err) fmt.Println("Signing error:", err)
return return
} }
response, err = client.SubmitTxAndWait(flattenedMultiBatchTx, &types.SubmitOptions{ response, err = client.SubmitTxAndWait(flattenedMultiBatchTx, &types.SubmitOptions{
Autofill: false, Autofill: false,
Wallet: &userWallet, Wallet: &userWallet,
}) })
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("✅ Multisig Batch transaction submitted") fmt.Println("✅ Multisig Batch transaction submitted")
fmt.Printf("🌐 Hash: %s\n", response.Hash.String()) fmt.Printf("🌐 Hash: %s\n", response.Hash.String())
fmt.Printf("🌐 Validated: %t\n", response.Validated) fmt.Printf("🌐 Validated: %t\n", response.Validated)
fmt.Println() fmt.Println()
// Check final balances // Check final balances
finalUser2Balance, err := client.GetXrpBalance(user2Wallet.ClassicAddress) finalUser2Balance, err := client.GetXrpBalance(user2Wallet.ClassicAddress)
if err != nil { if err != nil {
finalUser2Balance = "0" finalUser2Balance = "0"
} }
finalUserBalance, err = client.GetXrpBalance(userWallet.ClassicAddress) finalUserBalance, err = client.GetXrpBalance(userWallet.ClassicAddress)
if err != nil { if err != nil {
finalUserBalance = "0" finalUserBalance = "0"
} }
finalReceiverBalance, err = client.GetXrpBalance(receiverWallet.ClassicAddress) finalReceiverBalance, err = client.GetXrpBalance(receiverWallet.ClassicAddress)
if err != nil { if err != nil {
finalReceiverBalance = "0" finalReceiverBalance = "0"
} }
fmt.Printf("💳 User final balance: %s XRP\n", finalUserBalance) fmt.Printf("💳 User final balance: %s XRP\n", finalUserBalance)
fmt.Printf("💳 User2 final balance: %s XRP\n", finalUser2Balance) fmt.Printf("💳 User2 final balance: %s XRP\n", finalUser2Balance)
fmt.Printf("💳 Receiver final balance: %s XRP\n", finalReceiverBalance) fmt.Printf("💳 Receiver final balance: %s XRP\n", finalReceiverBalance)
} }

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

@@ -1,210 +1,210 @@
package main package main
import ( import (
"fmt" "fmt"
"github.com/Peersyst/xrpl-go/pkg/crypto" "github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet" "github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/transaction" "github.com/Peersyst/xrpl-go/xrpl/transaction"
txnTypes "github.com/Peersyst/xrpl-go/xrpl/transaction/types" txnTypes "github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet" "github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/xrpl/websocket" "github.com/Peersyst/xrpl-go/xrpl/websocket"
"github.com/Peersyst/xrpl-go/xrpl/websocket/types" "github.com/Peersyst/xrpl-go/xrpl/websocket/types"
) )
var ( var (
CreatePaymentTx = func(sender, receiver *wallet.Wallet, amount txnTypes.CurrencyAmount) *transaction.Payment { CreatePaymentTx = func(sender, receiver *wallet.Wallet, amount txnTypes.CurrencyAmount) *transaction.Payment {
return &transaction.Payment{ return &transaction.Payment{
BaseTx: transaction.BaseTx{ BaseTx: transaction.BaseTx{
Account: sender.GetAddress(), Account: sender.GetAddress(),
TransactionType: transaction.PaymentTx, TransactionType: transaction.PaymentTx,
Flags: txnTypes.TfInnerBatchTxn, Flags: txnTypes.TfInnerBatchTxn,
}, },
Amount: amount, Amount: amount,
Destination: receiver.GetAddress(), Destination: receiver.GetAddress(),
} }
} }
) )
func main() { func main() {
// Connect to testnet // Connect to testnet
client := websocket.NewClient( client := websocket.NewClient(
websocket.NewClientConfig(). websocket.NewClientConfig().
WithHost("wss://s.devnet.rippletest.net:51233"). WithHost("wss://s.devnet.rippletest.net:51233").
WithFaucetProvider(faucet.NewDevnetFaucetProvider()), WithFaucetProvider(faucet.NewDevnetFaucetProvider()),
) )
defer client.Disconnect() defer client.Disconnect()
if err := client.Connect(); err != nil { if err := client.Connect(); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
// Create and fund wallets // Create and fund wallets
userWallet, err := wallet.New(crypto.ED25519()) userWallet, err := wallet.New(crypto.ED25519())
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
user2Wallet, err := wallet.New(crypto.ED25519()) user2Wallet, err := wallet.New(crypto.ED25519())
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
receiverWallet, err := wallet.New(crypto.ED25519()) receiverWallet, err := wallet.New(crypto.ED25519())
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("⏳ Funding wallets...") fmt.Println("⏳ Funding wallets...")
if err := client.FundWallet(&userWallet); err != nil { if err := client.FundWallet(&userWallet); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
if err := client.FundWallet(&user2Wallet); err != nil { if err := client.FundWallet(&user2Wallet); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("💸 Wallets funded") fmt.Println("💸 Wallets funded")
// Check initial balances // Check initial balances
userBalance, err := client.GetXrpBalance(userWallet.ClassicAddress) userBalance, err := client.GetXrpBalance(userWallet.ClassicAddress)
if err != nil { if err != nil {
userBalance = "0" userBalance = "0"
} }
user2Balance, err := client.GetXrpBalance(user2Wallet.ClassicAddress) user2Balance, err := client.GetXrpBalance(user2Wallet.ClassicAddress)
if err != nil { if err != nil {
user2Balance = "0" user2Balance = "0"
} }
receiverBalance, err := client.GetXrpBalance(receiverWallet.ClassicAddress) receiverBalance, err := client.GetXrpBalance(receiverWallet.ClassicAddress)
if err != nil { if err != nil {
receiverBalance = "0" receiverBalance = "0"
} }
fmt.Printf("💳 User initial balance: %s XRP\n", userBalance) fmt.Printf("💳 User initial balance: %s XRP\n", userBalance)
fmt.Printf("💳 User2 initial balance: %s XRP\n", user2Balance) fmt.Printf("💳 User2 initial balance: %s XRP\n", user2Balance)
fmt.Printf("💳 Receiver initial balance: %s XRP\n", receiverBalance) fmt.Printf("💳 Receiver initial balance: %s XRP\n", receiverBalance)
fmt.Println() fmt.Println()
fmt.Printf("Batch transaction test\n") fmt.Printf("Batch transaction test\n")
// Create test batch transaction // Create test batch transaction
batchTx := &transaction.Batch{ batchTx := &transaction.Batch{
BaseTx: transaction.BaseTx{ BaseTx: transaction.BaseTx{
Account: txnTypes.Address(userWallet.ClassicAddress), Account: txnTypes.Address(userWallet.ClassicAddress),
TransactionType: transaction.BatchTx, TransactionType: transaction.BatchTx,
}, },
RawTransactions: []txnTypes.RawTransaction{ RawTransactions: []txnTypes.RawTransaction{
{RawTransaction: CreatePaymentTx(&userWallet, &receiverWallet, txnTypes.XRPCurrencyAmount(5000000)).Flatten()}, {RawTransaction: CreatePaymentTx(&userWallet, &receiverWallet, txnTypes.XRPCurrencyAmount(5000000)).Flatten()},
{RawTransaction: CreatePaymentTx(&userWallet, &receiverWallet, txnTypes.XRPCurrencyAmount(5000000)).Flatten()}, {RawTransaction: CreatePaymentTx(&userWallet, &receiverWallet, txnTypes.XRPCurrencyAmount(5000000)).Flatten()},
}, },
} }
batchTx.SetAllOrNothingFlag() batchTx.SetAllOrNothingFlag()
flattenedBatchTx := batchTx.Flatten() flattenedBatchTx := batchTx.Flatten()
fmt.Println("⏳ Autofilling flattened batch transaction...") fmt.Println("⏳ Autofilling flattened batch transaction...")
if err := client.Autofill(&flattenedBatchTx); err != nil { if err := client.Autofill(&flattenedBatchTx); err != nil {
fmt.Println("Autofill error:", err) fmt.Println("Autofill error:", err)
return return
} }
fmt.Println("⏳ Signing batch transaction...") fmt.Println("⏳ Signing batch transaction...")
response, err := client.SubmitTxAndWait(flattenedBatchTx, &types.SubmitOptions{ response, err := client.SubmitTxAndWait(flattenedBatchTx, &types.SubmitOptions{
Autofill: false, Autofill: false,
Wallet: &userWallet, Wallet: &userWallet,
}) })
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("✅ Batch transaction submitted") fmt.Println("✅ Batch transaction submitted")
fmt.Printf("🌐 Hash: %s\n", response.Hash.String()) fmt.Printf("🌐 Hash: %s\n", response.Hash.String())
fmt.Printf("🌐 Validated: %t\n", response.Validated) fmt.Printf("🌐 Validated: %t\n", response.Validated)
fmt.Println() fmt.Println()
// Check final balances // Check final balances
finalUserBalance, err := client.GetXrpBalance(userWallet.ClassicAddress) finalUserBalance, err := client.GetXrpBalance(userWallet.ClassicAddress)
if err != nil { if err != nil {
finalUserBalance = "0" finalUserBalance = "0"
} }
finalReceiverBalance, err := client.GetXrpBalance(receiverWallet.ClassicAddress) finalReceiverBalance, err := client.GetXrpBalance(receiverWallet.ClassicAddress)
if err != nil { if err != nil {
finalReceiverBalance = "0" 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.Println()
fmt.Printf("Multisig Batch transaction test\n") fmt.Printf("Multisig Batch transaction test\n")
// Create test batch transaction // Create test batch transaction
multiBatchTx := &transaction.Batch{ multiBatchTx := &transaction.Batch{
BaseTx: transaction.BaseTx{ BaseTx: transaction.BaseTx{
Account: txnTypes.Address(userWallet.ClassicAddress), Account: txnTypes.Address(userWallet.ClassicAddress),
TransactionType: transaction.BatchTx, TransactionType: transaction.BatchTx,
}, },
RawTransactions: []txnTypes.RawTransaction{ RawTransactions: []txnTypes.RawTransaction{
{RawTransaction: CreatePaymentTx(&userWallet, &receiverWallet, txnTypes.XRPCurrencyAmount(5000000)).Flatten()}, {RawTransaction: CreatePaymentTx(&userWallet, &receiverWallet, txnTypes.XRPCurrencyAmount(5000000)).Flatten()},
{RawTransaction: CreatePaymentTx(&user2Wallet, &receiverWallet, txnTypes.XRPCurrencyAmount(5000000)).Flatten()}, {RawTransaction: CreatePaymentTx(&user2Wallet, &receiverWallet, txnTypes.XRPCurrencyAmount(5000000)).Flatten()},
}, },
BatchSigners: []txnTypes.BatchSigner{ BatchSigners: []txnTypes.BatchSigner{
{ {
BatchSigner: txnTypes.BatchSignerData{ BatchSigner: txnTypes.BatchSignerData{
Account: txnTypes.Address(user2Wallet.ClassicAddress), Account: txnTypes.Address(user2Wallet.ClassicAddress),
SigningPubKey: user2Wallet.PublicKey, SigningPubKey: user2Wallet.PublicKey,
}, },
}, },
}, },
} }
multiBatchTx.SetAllOrNothingFlag() multiBatchTx.SetAllOrNothingFlag()
flattenedMultiBatchTx := multiBatchTx.Flatten() flattenedMultiBatchTx := multiBatchTx.Flatten()
fmt.Println("⏳ Autofilling flattened multi batch transaction...") fmt.Println("⏳ Autofilling flattened multi batch transaction...")
if err := client.AutofillMultisigned(&flattenedMultiBatchTx, 1); err != nil { if err := client.AutofillMultisigned(&flattenedMultiBatchTx, 1); err != nil {
fmt.Println("Autofill error:", err) fmt.Println("Autofill error:", err)
return return
} }
fmt.Println("⏳ Signing multi batch transaction...") fmt.Println("⏳ Signing multi batch transaction...")
if err := wallet.SignMultiBatch(user2Wallet, &flattenedMultiBatchTx, nil); err != nil { if err := wallet.SignMultiBatch(user2Wallet, &flattenedMultiBatchTx, nil); err != nil {
fmt.Println("Signing error:", err) fmt.Println("Signing error:", err)
return return
} }
response, err = client.SubmitTxAndWait(flattenedMultiBatchTx, &types.SubmitOptions{ response, err = client.SubmitTxAndWait(flattenedMultiBatchTx, &types.SubmitOptions{
Autofill: false, Autofill: false,
Wallet: &userWallet, Wallet: &userWallet,
}) })
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("✅ Multisig Batch transaction submitted") fmt.Println("✅ Multisig Batch transaction submitted")
fmt.Printf("🌐 Hash: %s\n", response.Hash.String()) fmt.Printf("🌐 Hash: %s\n", response.Hash.String())
fmt.Printf("🌐 Validated: %t\n", response.Validated) fmt.Printf("🌐 Validated: %t\n", response.Validated)
fmt.Println() fmt.Println()
// Check final balances // Check final balances
finalUser2Balance, err := client.GetXrpBalance(user2Wallet.ClassicAddress) finalUser2Balance, err := client.GetXrpBalance(user2Wallet.ClassicAddress)
if err != nil { if err != nil {
finalUser2Balance = "0" finalUser2Balance = "0"
} }
finalUserBalance, err = client.GetXrpBalance(userWallet.ClassicAddress) finalUserBalance, err = client.GetXrpBalance(userWallet.ClassicAddress)
if err != nil { if err != nil {
finalUserBalance = "0" finalUserBalance = "0"
} }
finalReceiverBalance, err = client.GetXrpBalance(receiverWallet.ClassicAddress) finalReceiverBalance, err = client.GetXrpBalance(receiverWallet.ClassicAddress)
if err != nil { if err != nil {
finalReceiverBalance = "0" finalReceiverBalance = "0"
} }
fmt.Printf("💳 User final balance: %s XRP\n", finalUserBalance) fmt.Printf("💳 User final balance: %s XRP\n", finalUserBalance)
fmt.Printf("💳 User2 final balance: %s XRP\n", finalUser2Balance) fmt.Printf("💳 User2 final balance: %s XRP\n", finalUser2Balance)
fmt.Printf("💳 Receiver final balance: %s XRP\n", finalReceiverBalance) fmt.Printf("💳 Receiver final balance: %s XRP\n", finalReceiverBalance)
} }

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

@@ -1,162 +1,162 @@
package main package main
import ( import (
"fmt" "fmt"
"github.com/Peersyst/xrpl-go/pkg/crypto" "github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet" "github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/ledger-entry-types" "github.com/Peersyst/xrpl-go/xrpl/ledger-entry-types"
"github.com/Peersyst/xrpl-go/xrpl/rpc" "github.com/Peersyst/xrpl-go/xrpl/rpc"
"github.com/Peersyst/xrpl-go/xrpl/transaction" "github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types" "github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet" "github.com/Peersyst/xrpl-go/xrpl/wallet"
) )
func main() { func main() {
cfg, err := rpc.NewClientConfig( cfg, err := rpc.NewClientConfig(
"https://s.altnet.rippletest.net:51234/", "https://s.altnet.rippletest.net:51234/",
rpc.WithFaucetProvider(faucet.NewTestnetFaucetProvider()), rpc.WithFaucetProvider(faucet.NewTestnetFaucetProvider()),
) )
if err != nil { if err != nil {
panic(err) panic(err)
} }
client := rpc.NewClient(cfg) client := rpc.NewClient(cfg)
w, err := wallet.New(crypto.ED25519()) w, err := wallet.New(crypto.ED25519())
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
receiverWallet, err := wallet.New(crypto.ED25519()) receiverWallet, err := wallet.New(crypto.ED25519())
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("⏳ Setting up wallets...") fmt.Println("⏳ Setting up wallets...")
if err := client.FundWallet(&w); err != nil { if err := client.FundWallet(&w); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("💸 Sender wallet funded!") fmt.Println("💸 Sender wallet funded!")
if err := client.FundWallet(&receiverWallet); err != nil { if err := client.FundWallet(&receiverWallet); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("💸 Receiver wallet funded!") fmt.Println("💸 Receiver wallet funded!")
fmt.Println() fmt.Println()
fmt.Println("✅ Wallets setup complete!") fmt.Println("✅ Wallets setup complete!")
fmt.Println("💳 Sender wallet:", w.ClassicAddress) fmt.Println("💳 Sender wallet:", w.ClassicAddress)
fmt.Println("💳 Receiver wallet:", receiverWallet.ClassicAddress) fmt.Println("💳 Receiver wallet:", receiverWallet.ClassicAddress)
fmt.Println() fmt.Println()
fmt.Println("⏳ Creating check...") fmt.Println("⏳ Creating check...")
cc := &transaction.CheckCreate{ cc := &transaction.CheckCreate{
BaseTx: transaction.BaseTx{ BaseTx: transaction.BaseTx{
Account: w.GetAddress(), Account: w.GetAddress(),
}, },
Destination: receiverWallet.GetAddress(), Destination: receiverWallet.GetAddress(),
SendMax: types.XRPCurrencyAmount(1000000), SendMax: types.XRPCurrencyAmount(1000000),
InvoiceID: "46060241FABCF692D4D934BA2A6C4427CD4279083E38C77CBE642243E43BE291", InvoiceID: "46060241FABCF692D4D934BA2A6C4427CD4279083E38C77CBE642243E43BE291",
} }
flatCc := cc.Flatten() flatCc := cc.Flatten()
if err := client.Autofill(&flatCc); err != nil { if err := client.Autofill(&flatCc); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
blob, _, err := w.Sign(flatCc) blob, _, err := w.Sign(flatCc)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
res, err := client.SubmitTxBlobAndWait(blob, false) res, err := client.SubmitTxBlobAndWait(blob, false)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
if !res.Validated { if !res.Validated {
fmt.Println("❌ Check creation failed!") fmt.Println("❌ Check creation failed!")
fmt.Println("Try again!") fmt.Println("Try again!")
fmt.Println() fmt.Println()
return return
} }
fmt.Println("✅ Check created!") fmt.Println("✅ Check created!")
fmt.Printf("🌐 Hash: %s\n", res.Hash.String()) fmt.Printf("🌐 Hash: %s\n", res.Hash.String())
fmt.Println() fmt.Println()
meta, ok := res.Meta.(map[string]interface{}) meta, ok := res.Meta.(map[string]interface{})
if !ok { if !ok {
fmt.Println("❌ Meta is not of type TxObjMeta") fmt.Println("❌ Meta is not of type TxObjMeta")
return return
} }
var checkID string var checkID string
affectedNodes := meta["AffectedNodes"].([]interface{}) affectedNodes := meta["AffectedNodes"].([]interface{})
for _, node := range affectedNodes { for _, node := range affectedNodes {
affectedNode, ok := node.(map[string]interface{}) affectedNode, ok := node.(map[string]interface{})
if !ok { if !ok {
fmt.Println("❌ Node is not of type map[string]interface{}") fmt.Println("❌ Node is not of type map[string]interface{}")
return return
} }
createdNode, ok := affectedNode["CreatedNode"].(map[string]interface{}) createdNode, ok := affectedNode["CreatedNode"].(map[string]interface{})
if !ok { if !ok {
continue continue
} }
if createdNode["LedgerEntryType"] == string(ledger.CheckEntry) { if createdNode["LedgerEntryType"] == string(ledger.CheckEntry) {
checkID = createdNode["LedgerIndex"].(string) checkID = createdNode["LedgerIndex"].(string)
} }
} }
if checkID == "" { if checkID == "" {
fmt.Println("Check not found") fmt.Println("Check not found")
return return
} }
fmt.Println("⏳ Cashing out check...") fmt.Println("⏳ Cashing out check...")
checkCash := &transaction.CheckCash{ checkCash := &transaction.CheckCash{
BaseTx: transaction.BaseTx{ BaseTx: transaction.BaseTx{
Account: receiverWallet.GetAddress(), Account: receiverWallet.GetAddress(),
}, },
CheckID: types.Hash256(checkID), CheckID: types.Hash256(checkID),
Amount: types.XRPCurrencyAmount(1000000), Amount: types.XRPCurrencyAmount(1000000),
} }
flatCheckCash := checkCash.Flatten() flatCheckCash := checkCash.Flatten()
if err := client.Autofill(&flatCheckCash); err != nil { if err := client.Autofill(&flatCheckCash); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
blob, _, err = receiverWallet.Sign(flatCheckCash) blob, _, err = receiverWallet.Sign(flatCheckCash)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
res, err = client.SubmitTxBlobAndWait(blob, false) res, err = client.SubmitTxBlobAndWait(blob, false)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("✅ Check cashed out!") fmt.Println("✅ Check cashed out!")
fmt.Printf("🌐 Hash: %s\n", res.Hash.String()) fmt.Printf("🌐 Hash: %s\n", res.Hash.String())
fmt.Println() fmt.Println()
} }

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

@@ -1,173 +1,173 @@
package main package main
import ( import (
"fmt" "fmt"
"github.com/Peersyst/xrpl-go/pkg/crypto" "github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet" "github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/ledger-entry-types" "github.com/Peersyst/xrpl-go/xrpl/ledger-entry-types"
"github.com/Peersyst/xrpl-go/xrpl/transaction" "github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types" "github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet" "github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/xrpl/websocket" "github.com/Peersyst/xrpl-go/xrpl/websocket"
) )
func main() { func main() {
fmt.Println("⏳ Connecting to testnet...") fmt.Println("⏳ Connecting to testnet...")
client := websocket.NewClient( client := websocket.NewClient(
websocket.NewClientConfig(). websocket.NewClientConfig().
WithHost("wss://s.altnet.rippletest.net:51233"). WithHost("wss://s.altnet.rippletest.net:51233").
WithFaucetProvider(faucet.NewTestnetFaucetProvider()), WithFaucetProvider(faucet.NewTestnetFaucetProvider()),
) )
defer client.Disconnect() defer client.Disconnect()
if err := client.Connect(); err != nil { if err := client.Connect(); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
if !client.IsConnected() { if !client.IsConnected() {
fmt.Println("❌ Failed to connect to testnet") fmt.Println("❌ Failed to connect to testnet")
return return
} }
fmt.Println("✅ Connected to testnet") fmt.Println("✅ Connected to testnet")
fmt.Println() fmt.Println()
w, err := wallet.New(crypto.ED25519()) w, err := wallet.New(crypto.ED25519())
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
receiverWallet, err := wallet.New(crypto.ED25519()) receiverWallet, err := wallet.New(crypto.ED25519())
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("⏳ Setting up wallets...") fmt.Println("⏳ Setting up wallets...")
if err := client.FundWallet(&w); err != nil { if err := client.FundWallet(&w); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("💸 Sender wallet funded!") fmt.Println("💸 Sender wallet funded!")
if err := client.FundWallet(&receiverWallet); err != nil { if err := client.FundWallet(&receiverWallet); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("💸 Receiver wallet funded!") fmt.Println("💸 Receiver wallet funded!")
fmt.Println() fmt.Println()
fmt.Println("✅ Wallets setup complete!") fmt.Println("✅ Wallets setup complete!")
fmt.Println("💳 Sender wallet:", w.ClassicAddress) fmt.Println("💳 Sender wallet:", w.ClassicAddress)
fmt.Println("💳 Receiver wallet:", receiverWallet.ClassicAddress) fmt.Println("💳 Receiver wallet:", receiverWallet.ClassicAddress)
fmt.Println() fmt.Println()
fmt.Println("⏳ Creating check...") fmt.Println("⏳ Creating check...")
cc := &transaction.CheckCreate{ cc := &transaction.CheckCreate{
BaseTx: transaction.BaseTx{ BaseTx: transaction.BaseTx{
Account: w.GetAddress(), Account: w.GetAddress(),
}, },
Destination: receiverWallet.GetAddress(), Destination: receiverWallet.GetAddress(),
SendMax: types.XRPCurrencyAmount(1000000), SendMax: types.XRPCurrencyAmount(1000000),
InvoiceID: "46060241FABCF692D4D934BA2A6C4427CD4279083E38C77CBE642243E43BE291", InvoiceID: "46060241FABCF692D4D934BA2A6C4427CD4279083E38C77CBE642243E43BE291",
} }
flatCc := cc.Flatten() flatCc := cc.Flatten()
if err := client.Autofill(&flatCc); err != nil { if err := client.Autofill(&flatCc); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
blob, _, err := w.Sign(flatCc) blob, _, err := w.Sign(flatCc)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
res, err := client.SubmitTxBlobAndWait(blob, false) res, err := client.SubmitTxBlobAndWait(blob, false)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
if !res.Validated { if !res.Validated {
fmt.Println("❌ Check creation failed!") fmt.Println("❌ Check creation failed!")
fmt.Println("Try again!") fmt.Println("Try again!")
fmt.Println() fmt.Println()
return return
} }
fmt.Println("✅ Check created!") fmt.Println("✅ Check created!")
fmt.Printf("🌐 Hash: %s\n", res.Hash.String()) fmt.Printf("🌐 Hash: %s\n", res.Hash.String())
fmt.Println() fmt.Println()
meta, ok := res.Meta.(map[string]interface{}) meta, ok := res.Meta.(map[string]interface{})
if !ok { if !ok {
fmt.Println("❌ Meta is not of type TxObjMeta") fmt.Println("❌ Meta is not of type TxObjMeta")
return return
} }
var checkID string var checkID string
affectedNodes := meta["AffectedNodes"].([]interface{}) affectedNodes := meta["AffectedNodes"].([]interface{})
for _, node := range affectedNodes { for _, node := range affectedNodes {
affectedNode, ok := node.(map[string]interface{}) affectedNode, ok := node.(map[string]interface{})
if !ok { if !ok {
fmt.Println("❌ Node is not of type map[string]interface{}") fmt.Println("❌ Node is not of type map[string]interface{}")
return return
} }
createdNode, ok := affectedNode["CreatedNode"].(map[string]interface{}) createdNode, ok := affectedNode["CreatedNode"].(map[string]interface{})
if !ok { if !ok {
continue continue
} }
if createdNode["LedgerEntryType"] == string(ledger.CheckEntry) { if createdNode["LedgerEntryType"] == string(ledger.CheckEntry) {
checkID = createdNode["LedgerIndex"].(string) checkID = createdNode["LedgerIndex"].(string)
} }
} }
if checkID == "" { if checkID == "" {
fmt.Println("Check not found") fmt.Println("Check not found")
return return
} }
fmt.Println("⏳ Cashing out check...") fmt.Println("⏳ Cashing out check...")
checkCash := &transaction.CheckCash{ checkCash := &transaction.CheckCash{
BaseTx: transaction.BaseTx{ BaseTx: transaction.BaseTx{
Account: receiverWallet.GetAddress(), Account: receiverWallet.GetAddress(),
}, },
CheckID: types.Hash256(checkID), CheckID: types.Hash256(checkID),
Amount: types.XRPCurrencyAmount(1000000), Amount: types.XRPCurrencyAmount(1000000),
} }
flatCheckCash := checkCash.Flatten() flatCheckCash := checkCash.Flatten()
if err := client.Autofill(&flatCheckCash); err != nil { if err := client.Autofill(&flatCheckCash); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
blob, _, err = receiverWallet.Sign(flatCheckCash) blob, _, err = receiverWallet.Sign(flatCheckCash)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
res, err = client.SubmitTxBlobAndWait(blob, false) res, err = client.SubmitTxBlobAndWait(blob, false)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("✅ Check cashed out!") fmt.Println("✅ Check cashed out!")
fmt.Printf("🌐 Hash: %s\n", res.Hash.String()) fmt.Printf("🌐 Hash: %s\n", res.Hash.String())
fmt.Println() fmt.Println()
} }

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

@@ -1,251 +1,251 @@
package main package main
import ( import (
"fmt" "fmt"
"github.com/Peersyst/xrpl-go/pkg/crypto" "github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet" "github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/rpc" "github.com/Peersyst/xrpl-go/xrpl/rpc"
transactions "github.com/Peersyst/xrpl-go/xrpl/transaction" transactions "github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types" "github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet" "github.com/Peersyst/xrpl-go/xrpl/wallet"
) )
const ( const (
currencyCode = "FOO" currencyCode = "FOO"
) )
func main() { func main() {
// //
// Configure client // Configure client
// //
cfg, err := rpc.NewClientConfig( cfg, err := rpc.NewClientConfig(
"https://s.altnet.rippletest.net:51234/", "https://s.altnet.rippletest.net:51234/",
rpc.WithFaucetProvider(faucet.NewTestnetFaucetProvider()), rpc.WithFaucetProvider(faucet.NewTestnetFaucetProvider()),
) )
if err != nil { if err != nil {
panic(err) panic(err)
} }
client := rpc.NewClient(cfg) client := rpc.NewClient(cfg)
// //
// Configure wallets // Configure wallets
// //
fmt.Println("⏳ Setting up wallets...") fmt.Println("⏳ Setting up wallets...")
coldWallet, err := wallet.New(crypto.ED25519()) coldWallet, err := wallet.New(crypto.ED25519())
if err != nil { if err != nil {
fmt.Printf("❌ Error creating cold wallet: %s\n", err) fmt.Printf("❌ Error creating cold wallet: %s\n", err)
return return
} }
err = client.FundWallet(&coldWallet) err = client.FundWallet(&coldWallet)
if err != nil { if err != nil {
fmt.Printf("❌ Error funding cold wallet: %s\n", err) fmt.Printf("❌ Error funding cold wallet: %s\n", err)
return return
} }
fmt.Println("💸 Cold wallet funded!") fmt.Println("💸 Cold wallet funded!")
hotWallet, err := wallet.New(crypto.ED25519()) hotWallet, err := wallet.New(crypto.ED25519())
if err != nil { if err != nil {
fmt.Printf("❌ Error creating hot wallet: %s\n", err) fmt.Printf("❌ Error creating hot wallet: %s\n", err)
return return
} }
err = client.FundWallet(&hotWallet) err = client.FundWallet(&hotWallet)
if err != nil { if err != nil {
fmt.Printf("❌ Error funding hot wallet: %s\n", err) fmt.Printf("❌ Error funding hot wallet: %s\n", err)
return return
} }
fmt.Println("💸 Hot wallet funded!") fmt.Println("💸 Hot wallet funded!")
fmt.Println() fmt.Println()
fmt.Println("✅ Wallets setup complete!") fmt.Println("✅ Wallets setup complete!")
fmt.Println("💳 Cold wallet:", coldWallet.ClassicAddress) fmt.Println("💳 Cold wallet:", coldWallet.ClassicAddress)
fmt.Println("💳 Hot wallet:", hotWallet.ClassicAddress) fmt.Println("💳 Hot wallet:", hotWallet.ClassicAddress)
fmt.Println() fmt.Println()
// //
// Configure cold address settings // Configure cold address settings
// //
fmt.Println("⏳ Configuring cold address settings...") fmt.Println("⏳ Configuring cold address settings...")
coldWalletAccountSet := &transactions.AccountSet{ coldWalletAccountSet := &transactions.AccountSet{
BaseTx: transactions.BaseTx{ BaseTx: transactions.BaseTx{
Account: types.Address(coldWallet.ClassicAddress), Account: types.Address(coldWallet.ClassicAddress),
}, },
TickSize: types.TickSize(5), TickSize: types.TickSize(5),
TransferRate: types.TransferRate(0), TransferRate: types.TransferRate(0),
Domain: types.Domain("6578616D706C652E636F6D"), // example.com Domain: types.Domain("6578616D706C652E636F6D"), // example.com
} }
coldWalletAccountSet.SetAsfAllowTrustLineClawback() coldWalletAccountSet.SetAsfAllowTrustLineClawback()
coldWalletAccountSet.SetDisallowXRP() coldWalletAccountSet.SetDisallowXRP()
coldWalletAccountSet.SetRequireDestTag() coldWalletAccountSet.SetRequireDestTag()
flattenedTx := coldWalletAccountSet.Flatten() flattenedTx := coldWalletAccountSet.Flatten()
err = client.Autofill(&flattenedTx) err = client.Autofill(&flattenedTx)
if err != nil { if err != nil {
fmt.Printf("❌ Error autofilling transaction: %s\n", err) fmt.Printf("❌ Error autofilling transaction: %s\n", err)
return return
} }
txBlob, _, err := coldWallet.Sign(flattenedTx) txBlob, _, err := coldWallet.Sign(flattenedTx)
if err != nil { if err != nil {
fmt.Printf("❌ Error signing transaction: %s\n", err) fmt.Printf("❌ Error signing transaction: %s\n", err)
return return
} }
response, err := client.SubmitTxBlobAndWait(txBlob, false) response, err := client.SubmitTxBlobAndWait(txBlob, false)
if err != nil { if err != nil {
fmt.Printf("❌ Error submitting transaction: %s\n", err) fmt.Printf("❌ Error submitting transaction: %s\n", err)
return return
} }
if !response.Validated { if !response.Validated {
fmt.Println("❌ Cold wallet unfreezing failed!") fmt.Println("❌ Cold wallet unfreezing failed!")
fmt.Println("Try again!") fmt.Println("Try again!")
fmt.Println() fmt.Println()
return return
} }
fmt.Println("✅ Cold address settings configured!") fmt.Println("✅ Cold address settings configured!")
fmt.Printf("🌐 Hash: %s\n", response.Hash.String()) fmt.Printf("🌐 Hash: %s\n", response.Hash.String())
fmt.Println() fmt.Println()
// //
// Create trust line from hot to cold address // Create trust line from hot to cold address
// //
fmt.Println("⏳ Creating trust line from hot to cold address...") fmt.Println("⏳ Creating trust line from hot to cold address...")
hotColdTrustSet := &transactions.TrustSet{ hotColdTrustSet := &transactions.TrustSet{
BaseTx: transactions.BaseTx{ BaseTx: transactions.BaseTx{
Account: types.Address(hotWallet.ClassicAddress), Account: types.Address(hotWallet.ClassicAddress),
}, },
LimitAmount: types.IssuedCurrencyAmount{ LimitAmount: types.IssuedCurrencyAmount{
Currency: currencyCode, Currency: currencyCode,
Issuer: types.Address(coldWallet.ClassicAddress), Issuer: types.Address(coldWallet.ClassicAddress),
Value: "100000000000000", Value: "100000000000000",
}, },
} }
flattenedTx = hotColdTrustSet.Flatten() flattenedTx = hotColdTrustSet.Flatten()
err = client.Autofill(&flattenedTx) err = client.Autofill(&flattenedTx)
if err != nil { if err != nil {
fmt.Printf("❌ Error autofilling transaction: %s\n", err) fmt.Printf("❌ Error autofilling transaction: %s\n", err)
return return
} }
txBlob, _, err = hotWallet.Sign(flattenedTx) txBlob, _, err = hotWallet.Sign(flattenedTx)
if err != nil { if err != nil {
fmt.Printf("❌ Error signing transaction: %s\n", err) fmt.Printf("❌ Error signing transaction: %s\n", err)
return return
} }
response, err = client.SubmitTxBlobAndWait(txBlob, false) response, err = client.SubmitTxBlobAndWait(txBlob, false)
if err != nil { if err != nil {
fmt.Printf("❌ Error submitting transaction: %s\n", err) fmt.Printf("❌ Error submitting transaction: %s\n", err)
return return
} }
if !response.Validated { if !response.Validated {
fmt.Println("❌ Trust line from hot to cold address creation failed!") fmt.Println("❌ Trust line from hot to cold address creation failed!")
fmt.Println("Try again!") fmt.Println("Try again!")
fmt.Println() fmt.Println()
return return
} }
fmt.Println("✅ Trust line from hot to cold address created!") fmt.Println("✅ Trust line from hot to cold address created!")
fmt.Printf("🌐 Hash: %s\n", response.Hash.String()) fmt.Printf("🌐 Hash: %s\n", response.Hash.String())
fmt.Println() fmt.Println()
// //
// Send tokens from cold wallet to hot wallet // Send tokens from cold wallet to hot wallet
// //
fmt.Println("⏳ Sending tokens from cold wallet to hot wallet...") fmt.Println("⏳ Sending tokens from cold wallet to hot wallet...")
coldToHotPayment := &transactions.Payment{ coldToHotPayment := &transactions.Payment{
BaseTx: transactions.BaseTx{ BaseTx: transactions.BaseTx{
Account: types.Address(coldWallet.ClassicAddress), Account: types.Address(coldWallet.ClassicAddress),
}, },
Amount: types.IssuedCurrencyAmount{ Amount: types.IssuedCurrencyAmount{
Currency: currencyCode, Currency: currencyCode,
Issuer: types.Address(coldWallet.ClassicAddress), Issuer: types.Address(coldWallet.ClassicAddress),
Value: "3800", Value: "3800",
}, },
Destination: types.Address(hotWallet.ClassicAddress), Destination: types.Address(hotWallet.ClassicAddress),
DestinationTag: types.DestinationTag(1), DestinationTag: types.DestinationTag(1),
} }
flattenedTx = coldToHotPayment.Flatten() flattenedTx = coldToHotPayment.Flatten()
err = client.Autofill(&flattenedTx) err = client.Autofill(&flattenedTx)
if err != nil { if err != nil {
fmt.Printf("❌ Error autofilling transaction: %s\n", err) fmt.Printf("❌ Error autofilling transaction: %s\n", err)
return return
} }
txBlob, _, err = coldWallet.Sign(flattenedTx) txBlob, _, err = coldWallet.Sign(flattenedTx)
if err != nil { if err != nil {
fmt.Printf("❌ Error signing transaction: %s\n", err) fmt.Printf("❌ Error signing transaction: %s\n", err)
return return
} }
response, err = client.SubmitTxBlobAndWait(txBlob, false) response, err = client.SubmitTxBlobAndWait(txBlob, false)
if err != nil { if err != nil {
fmt.Printf("❌ Error submitting transaction: %s\n", err) fmt.Printf("❌ Error submitting transaction: %s\n", err)
return return
} }
if !response.Validated { if !response.Validated {
fmt.Println("❌ Tokens not sent from cold wallet to hot wallet!") fmt.Println("❌ Tokens not sent from cold wallet to hot wallet!")
fmt.Println("Try again!") fmt.Println("Try again!")
fmt.Println() fmt.Println()
return return
} }
fmt.Println("✅ Tokens sent from cold wallet to hot wallet!") fmt.Println("✅ Tokens sent from cold wallet to hot wallet!")
fmt.Printf("🌐 Hash: %s\n", response.Hash.String()) fmt.Printf("🌐 Hash: %s\n", response.Hash.String())
fmt.Println() fmt.Println()
// //
// Claw back tokens from customer one // Claw back tokens from customer one
// //
fmt.Println("⏳ Clawing back tokens from hot wallet...") fmt.Println("⏳ Clawing back tokens from hot wallet...")
coldWalletClawback := &transactions.Clawback{ coldWalletClawback := &transactions.Clawback{
BaseTx: transactions.BaseTx{ BaseTx: transactions.BaseTx{
Account: types.Address(coldWallet.ClassicAddress), Account: types.Address(coldWallet.ClassicAddress),
}, },
Amount: types.IssuedCurrencyAmount{ Amount: types.IssuedCurrencyAmount{
Currency: currencyCode, Currency: currencyCode,
Issuer: types.Address(hotWallet.ClassicAddress), Issuer: types.Address(hotWallet.ClassicAddress),
Value: "50", Value: "50",
}, },
} }
flattenedTx = coldWalletClawback.Flatten() flattenedTx = coldWalletClawback.Flatten()
err = client.Autofill(&flattenedTx) err = client.Autofill(&flattenedTx)
if err != nil { if err != nil {
fmt.Printf("❌ Error autofilling transaction: %s\n", err) fmt.Printf("❌ Error autofilling transaction: %s\n", err)
return return
} }
txBlob, _, err = coldWallet.Sign(flattenedTx) txBlob, _, err = coldWallet.Sign(flattenedTx)
if err != nil { if err != nil {
fmt.Printf("❌ Error signing transaction: %s\n", err) fmt.Printf("❌ Error signing transaction: %s\n", err)
return return
} }
response, err = client.SubmitTxBlobAndWait(txBlob, false) response, err = client.SubmitTxBlobAndWait(txBlob, false)
if err != nil { if err != nil {
fmt.Printf("❌ Error submitting transaction: %s\n", err) fmt.Printf("❌ Error submitting transaction: %s\n", err)
return return
} }
if !response.Validated { if !response.Validated {
fmt.Println("❌ Tokens not clawed back from customer one!") fmt.Println("❌ Tokens not clawed back from customer one!")
fmt.Println("Try again!") fmt.Println("Try again!")
return return
} }
fmt.Println("✅ Tokens clawed back from customer one!") fmt.Println("✅ Tokens clawed back from customer one!")
fmt.Printf("🌐 Hash: %s\n", response.Hash.String()) fmt.Printf("🌐 Hash: %s\n", response.Hash.String())
fmt.Println() fmt.Println()
} }

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

@@ -1,258 +1,258 @@
package main package main
import ( import (
"fmt" "fmt"
"github.com/Peersyst/xrpl-go/pkg/crypto" "github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet" "github.com/Peersyst/xrpl-go/xrpl/faucet"
transactions "github.com/Peersyst/xrpl-go/xrpl/transaction" transactions "github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types" "github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet" "github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/xrpl/websocket" "github.com/Peersyst/xrpl-go/xrpl/websocket"
) )
const ( const (
currencyCode = "FOO" currencyCode = "FOO"
) )
func main() { func main() {
// //
// Configure client // Configure client
// //
fmt.Println("⏳ Setting up client...") fmt.Println("⏳ Setting up client...")
client := websocket.NewClient( client := websocket.NewClient(
websocket.NewClientConfig(). websocket.NewClientConfig().
WithHost("wss://s.altnet.rippletest.net"). WithHost("wss://s.altnet.rippletest.net").
WithFaucetProvider(faucet.NewTestnetFaucetProvider()), WithFaucetProvider(faucet.NewTestnetFaucetProvider()),
) )
fmt.Println("✅ Client configured!") fmt.Println("✅ Client configured!")
fmt.Println() fmt.Println()
fmt.Println("Connecting to server...") fmt.Println("Connecting to server...")
if err := client.Connect(); err != nil { if err := client.Connect(); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("Connection: ", client.IsConnected()) fmt.Println("Connection: ", client.IsConnected())
// //
// Configure wallets // Configure wallets
// //
fmt.Println("⏳ Setting up wallets...") fmt.Println("⏳ Setting up wallets...")
coldWallet, err := wallet.New(crypto.ED25519()) coldWallet, err := wallet.New(crypto.ED25519())
if err != nil { if err != nil {
fmt.Printf("❌ Error creating cold wallet: %s\n", err) fmt.Printf("❌ Error creating cold wallet: %s\n", err)
return return
} }
err = client.FundWallet(&coldWallet) err = client.FundWallet(&coldWallet)
if err != nil { if err != nil {
fmt.Printf("❌ Error funding cold wallet: %s\n", err) fmt.Printf("❌ Error funding cold wallet: %s\n", err)
return return
} }
fmt.Println("💸 Cold wallet funded!") fmt.Println("💸 Cold wallet funded!")
hotWallet, err := wallet.New(crypto.ED25519()) hotWallet, err := wallet.New(crypto.ED25519())
if err != nil { if err != nil {
fmt.Printf("❌ Error creating hot wallet: %s\n", err) fmt.Printf("❌ Error creating hot wallet: %s\n", err)
return return
} }
err = client.FundWallet(&hotWallet) err = client.FundWallet(&hotWallet)
if err != nil { if err != nil {
fmt.Printf("❌ Error funding hot wallet: %s\n", err) fmt.Printf("❌ Error funding hot wallet: %s\n", err)
return return
} }
fmt.Println("💸 Hot wallet funded!") fmt.Println("💸 Hot wallet funded!")
fmt.Println() fmt.Println()
fmt.Println("✅ Wallets setup complete!") fmt.Println("✅ Wallets setup complete!")
fmt.Println("💳 Cold wallet:", coldWallet.ClassicAddress) fmt.Println("💳 Cold wallet:", coldWallet.ClassicAddress)
fmt.Println("💳 Hot wallet:", hotWallet.ClassicAddress) fmt.Println("💳 Hot wallet:", hotWallet.ClassicAddress)
fmt.Println() fmt.Println()
// //
// Configure cold address settings // Configure cold address settings
// //
fmt.Println("⏳ Configuring cold address settings...") fmt.Println("⏳ Configuring cold address settings...")
coldWalletAccountSet := &transactions.AccountSet{ coldWalletAccountSet := &transactions.AccountSet{
BaseTx: transactions.BaseTx{ BaseTx: transactions.BaseTx{
Account: types.Address(coldWallet.ClassicAddress), Account: types.Address(coldWallet.ClassicAddress),
}, },
TickSize: types.TickSize(5), TickSize: types.TickSize(5),
TransferRate: types.TransferRate(0), TransferRate: types.TransferRate(0),
Domain: types.Domain("6578616D706C652E636F6D"), // example.com Domain: types.Domain("6578616D706C652E636F6D"), // example.com
} }
coldWalletAccountSet.SetAsfAllowTrustLineClawback() coldWalletAccountSet.SetAsfAllowTrustLineClawback()
coldWalletAccountSet.SetDisallowXRP() coldWalletAccountSet.SetDisallowXRP()
coldWalletAccountSet.SetRequireDestTag() coldWalletAccountSet.SetRequireDestTag()
flattenedTx := coldWalletAccountSet.Flatten() flattenedTx := coldWalletAccountSet.Flatten()
err = client.Autofill(&flattenedTx) err = client.Autofill(&flattenedTx)
if err != nil { if err != nil {
fmt.Printf("❌ Error autofilling transaction: %s\n", err) fmt.Printf("❌ Error autofilling transaction: %s\n", err)
return return
} }
txBlob, _, err := coldWallet.Sign(flattenedTx) txBlob, _, err := coldWallet.Sign(flattenedTx)
if err != nil { if err != nil {
fmt.Printf("❌ Error signing transaction: %s\n", err) fmt.Printf("❌ Error signing transaction: %s\n", err)
return return
} }
response, err := client.SubmitTxBlobAndWait(txBlob, false) response, err := client.SubmitTxBlobAndWait(txBlob, false)
if err != nil { if err != nil {
fmt.Printf("❌ Error submitting transaction: %s\n", err) fmt.Printf("❌ Error submitting transaction: %s\n", err)
return return
} }
if !response.Validated { if !response.Validated {
fmt.Println("❌ Cold wallet unfreezing failed!") fmt.Println("❌ Cold wallet unfreezing failed!")
fmt.Println("Try again!") fmt.Println("Try again!")
fmt.Println() fmt.Println()
return return
} }
fmt.Println("✅ Cold address settings configured!") fmt.Println("✅ Cold address settings configured!")
fmt.Printf("🌐 Hash: %s\n", response.Hash.String()) fmt.Printf("🌐 Hash: %s\n", response.Hash.String())
fmt.Println() fmt.Println()
// //
// Create trust line from hot to cold address // Create trust line from hot to cold address
// //
fmt.Println("⏳ Creating trust line from hot to cold address...") fmt.Println("⏳ Creating trust line from hot to cold address...")
hotColdTrustSet := &transactions.TrustSet{ hotColdTrustSet := &transactions.TrustSet{
BaseTx: transactions.BaseTx{ BaseTx: transactions.BaseTx{
Account: types.Address(hotWallet.ClassicAddress), Account: types.Address(hotWallet.ClassicAddress),
}, },
LimitAmount: types.IssuedCurrencyAmount{ LimitAmount: types.IssuedCurrencyAmount{
Currency: currencyCode, Currency: currencyCode,
Issuer: types.Address(coldWallet.ClassicAddress), Issuer: types.Address(coldWallet.ClassicAddress),
Value: "100000000000000", Value: "100000000000000",
}, },
} }
flattenedTx = hotColdTrustSet.Flatten() flattenedTx = hotColdTrustSet.Flatten()
err = client.Autofill(&flattenedTx) err = client.Autofill(&flattenedTx)
if err != nil { if err != nil {
fmt.Printf("❌ Error autofilling transaction: %s\n", err) fmt.Printf("❌ Error autofilling transaction: %s\n", err)
return return
} }
txBlob, _, err = hotWallet.Sign(flattenedTx) txBlob, _, err = hotWallet.Sign(flattenedTx)
if err != nil { if err != nil {
fmt.Printf("❌ Error signing transaction: %s\n", err) fmt.Printf("❌ Error signing transaction: %s\n", err)
return return
} }
response, err = client.SubmitTxBlobAndWait(txBlob, false) response, err = client.SubmitTxBlobAndWait(txBlob, false)
if err != nil { if err != nil {
fmt.Printf("❌ Error submitting transaction: %s\n", err) fmt.Printf("❌ Error submitting transaction: %s\n", err)
return return
} }
if !response.Validated { if !response.Validated {
fmt.Println("❌ Trust line from hot to cold address creation failed!") fmt.Println("❌ Trust line from hot to cold address creation failed!")
fmt.Println("Try again!") fmt.Println("Try again!")
fmt.Println() fmt.Println()
return return
} }
fmt.Println("✅ Trust line from hot to cold address created!") fmt.Println("✅ Trust line from hot to cold address created!")
fmt.Printf("🌐 Hash: %s\n", response.Hash.String()) fmt.Printf("🌐 Hash: %s\n", response.Hash.String())
fmt.Println() fmt.Println()
// //
// Send tokens from cold wallet to hot wallet // Send tokens from cold wallet to hot wallet
// //
fmt.Println("⏳ Sending tokens from cold wallet to hot wallet...") fmt.Println("⏳ Sending tokens from cold wallet to hot wallet...")
coldToHotPayment := &transactions.Payment{ coldToHotPayment := &transactions.Payment{
BaseTx: transactions.BaseTx{ BaseTx: transactions.BaseTx{
Account: types.Address(coldWallet.ClassicAddress), Account: types.Address(coldWallet.ClassicAddress),
}, },
Amount: types.IssuedCurrencyAmount{ Amount: types.IssuedCurrencyAmount{
Currency: currencyCode, Currency: currencyCode,
Issuer: types.Address(coldWallet.ClassicAddress), Issuer: types.Address(coldWallet.ClassicAddress),
Value: "3800", Value: "3800",
}, },
Destination: types.Address(hotWallet.ClassicAddress), Destination: types.Address(hotWallet.ClassicAddress),
DestinationTag: types.DestinationTag(1), DestinationTag: types.DestinationTag(1),
} }
flattenedTx = coldToHotPayment.Flatten() flattenedTx = coldToHotPayment.Flatten()
err = client.Autofill(&flattenedTx) err = client.Autofill(&flattenedTx)
if err != nil { if err != nil {
fmt.Printf("❌ Error autofilling transaction: %s\n", err) fmt.Printf("❌ Error autofilling transaction: %s\n", err)
return return
} }
txBlob, _, err = coldWallet.Sign(flattenedTx) txBlob, _, err = coldWallet.Sign(flattenedTx)
if err != nil { if err != nil {
fmt.Printf("❌ Error signing transaction: %s\n", err) fmt.Printf("❌ Error signing transaction: %s\n", err)
return return
} }
response, err = client.SubmitTxBlobAndWait(txBlob, false) response, err = client.SubmitTxBlobAndWait(txBlob, false)
if err != nil { if err != nil {
fmt.Printf("❌ Error submitting transaction: %s\n", err) fmt.Printf("❌ Error submitting transaction: %s\n", err)
return return
} }
if !response.Validated { if !response.Validated {
fmt.Println("❌ Tokens not sent from cold wallet to hot wallet!") fmt.Println("❌ Tokens not sent from cold wallet to hot wallet!")
fmt.Println("Try again!") fmt.Println("Try again!")
fmt.Println() fmt.Println()
return return
} }
fmt.Println("✅ Tokens sent from cold wallet to hot wallet!") fmt.Println("✅ Tokens sent from cold wallet to hot wallet!")
fmt.Printf("🌐 Hash: %s\n", response.Hash.String()) fmt.Printf("🌐 Hash: %s\n", response.Hash.String())
fmt.Println() fmt.Println()
// //
// Claw back tokens from customer one // Claw back tokens from customer one
// //
fmt.Println("⏳ Clawing back tokens from hot wallet...") fmt.Println("⏳ Clawing back tokens from hot wallet...")
coldWalletClawback := &transactions.Clawback{ coldWalletClawback := &transactions.Clawback{
BaseTx: transactions.BaseTx{ BaseTx: transactions.BaseTx{
Account: types.Address(coldWallet.ClassicAddress), Account: types.Address(coldWallet.ClassicAddress),
}, },
Amount: types.IssuedCurrencyAmount{ Amount: types.IssuedCurrencyAmount{
Currency: currencyCode, Currency: currencyCode,
Issuer: types.Address(hotWallet.ClassicAddress), Issuer: types.Address(hotWallet.ClassicAddress),
Value: "50", Value: "50",
}, },
} }
flattenedTx = coldWalletClawback.Flatten() flattenedTx = coldWalletClawback.Flatten()
err = client.Autofill(&flattenedTx) err = client.Autofill(&flattenedTx)
if err != nil { if err != nil {
fmt.Printf("❌ Error autofilling transaction: %s\n", err) fmt.Printf("❌ Error autofilling transaction: %s\n", err)
return return
} }
txBlob, _, err = coldWallet.Sign(flattenedTx) txBlob, _, err = coldWallet.Sign(flattenedTx)
if err != nil { if err != nil {
fmt.Printf("❌ Error signing transaction: %s\n", err) fmt.Printf("❌ Error signing transaction: %s\n", err)
return return
} }
response, err = client.SubmitTxBlobAndWait(txBlob, false) response, err = client.SubmitTxBlobAndWait(txBlob, false)
if err != nil { if err != nil {
fmt.Printf("❌ Error submitting transaction: %s\n", err) fmt.Printf("❌ Error submitting transaction: %s\n", err)
return return
} }
if !response.Validated { if !response.Validated {
fmt.Println("❌ Tokens not clawed back from customer one!") fmt.Println("❌ Tokens not clawed back from customer one!")
fmt.Println("Try again!") fmt.Println("Try again!")
return return
} }
fmt.Println("✅ Tokens clawed back from customer one!") fmt.Println("✅ Tokens clawed back from customer one!")
fmt.Printf("🌐 Hash: %s\n", response.Hash.String()) fmt.Printf("🌐 Hash: %s\n", response.Hash.String())
fmt.Println() fmt.Println()
} }

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

@@ -1,109 +1,109 @@
package main package main
import ( import (
"encoding/hex" "encoding/hex"
"fmt" "fmt"
"time" "time"
"github.com/Peersyst/xrpl-go/examples/clients" "github.com/Peersyst/xrpl-go/examples/clients"
"github.com/Peersyst/xrpl-go/pkg/crypto" "github.com/Peersyst/xrpl-go/pkg/crypto"
rippleTime "github.com/Peersyst/xrpl-go/xrpl/time" rippleTime "github.com/Peersyst/xrpl-go/xrpl/time"
"github.com/Peersyst/xrpl-go/xrpl/transaction" "github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types" "github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet" "github.com/Peersyst/xrpl-go/xrpl/wallet"
) )
func main() { func main() {
// As of February 2025, Credential is only available on Devnet. // As of February 2025, Credential is only available on Devnet.
client := clients.GetDevnetRpcClient() client := clients.GetDevnetRpcClient()
// Configure wallets // Configure wallets
// Issuer // Issuer
fmt.Println("⏳ Setting up credential issuer wallet...") fmt.Println("⏳ Setting up credential issuer wallet...")
issuer, err := wallet.New(crypto.ED25519()) issuer, err := wallet.New(crypto.ED25519())
if err != nil { if err != nil {
fmt.Printf("❌ Error creating issuer wallet: %s\n", err) fmt.Printf("❌ Error creating issuer wallet: %s\n", err)
return return
} }
err = client.FundWallet(&issuer) err = client.FundWallet(&issuer)
if err != nil { if err != nil {
fmt.Printf("❌ Error funding issuer wallet: %s\n", err) fmt.Printf("❌ Error funding issuer wallet: %s\n", err)
return return
} }
fmt.Printf("✅ Issuer wallet funded: %s\n", issuer.ClassicAddress) fmt.Printf("✅ Issuer wallet funded: %s\n", issuer.ClassicAddress)
// ----------------------------------------------------- // -----------------------------------------------------
// Subject (destination) // Subject (destination)
fmt.Println("⏳ Setting up Subject wallet...") fmt.Println("⏳ Setting up Subject wallet...")
subjectWallet, err := wallet.New(crypto.ED25519()) subjectWallet, err := wallet.New(crypto.ED25519())
if err != nil { if err != nil {
fmt.Printf("❌ Error creating subject wallet: %s\n", err) fmt.Printf("❌ Error creating subject wallet: %s\n", err)
return return
} }
err = client.FundWallet(&subjectWallet) err = client.FundWallet(&subjectWallet)
if err != nil { if err != nil {
fmt.Printf("❌ Error funding subject wallet: %s\n", err) fmt.Printf("❌ Error funding subject wallet: %s\n", err)
return return
} }
fmt.Printf("✅ Subject wallet funded: %s\n", subjectWallet.ClassicAddress) fmt.Printf("✅ Subject wallet funded: %s\n", subjectWallet.ClassicAddress)
// ----------------------------------------------------- // -----------------------------------------------------
// Creating the CredentialCreate transaction // Creating the CredentialCreate transaction
fmt.Println("⏳ Creating CredentialCreate transaction...") fmt.Println("⏳ Creating CredentialCreate transaction...")
expiration, err := rippleTime.IsoTimeToRippleTime(time.Now().Add(time.Hour * 24).Format(time.RFC3339)) expiration, err := rippleTime.IsoTimeToRippleTime(time.Now().Add(time.Hour * 24).Format(time.RFC3339))
credentialType := types.CredentialType("6D795F63726564656E7469616C") credentialType := types.CredentialType("6D795F63726564656E7469616C")
if err != nil { if err != nil {
fmt.Printf("❌ Error converting expiration to ripple time: %s\n", err) fmt.Printf("❌ Error converting expiration to ripple time: %s\n", err)
return return
} }
txn := &transaction.CredentialCreate{ txn := &transaction.CredentialCreate{
BaseTx: transaction.BaseTx{ BaseTx: transaction.BaseTx{
Account: types.Address(issuer.ClassicAddress), Account: types.Address(issuer.ClassicAddress),
}, },
CredentialType: credentialType, CredentialType: credentialType,
Subject: types.Address(subjectWallet.ClassicAddress), Subject: types.Address(subjectWallet.ClassicAddress),
Expiration: uint32(expiration), Expiration: uint32(expiration),
URI: hex.EncodeToString([]byte("https://example.com")), URI: hex.EncodeToString([]byte("https://example.com")),
} }
clients.SubmitTxBlobAndWait(client, txn, issuer) clients.SubmitTxBlobAndWait(client, txn, issuer)
// ----------------------------------------------------- // -----------------------------------------------------
// Creating the CredentialAccept transaction // Creating the CredentialAccept transaction
fmt.Println("⏳ Creating CredentialAccept transaction...") fmt.Println("⏳ Creating CredentialAccept transaction...")
acceptTxn := &transaction.CredentialAccept{ acceptTxn := &transaction.CredentialAccept{
BaseTx: transaction.BaseTx{ BaseTx: transaction.BaseTx{
Account: types.Address(subjectWallet.ClassicAddress), Account: types.Address(subjectWallet.ClassicAddress),
}, },
CredentialType: credentialType, CredentialType: credentialType,
Issuer: types.Address(issuer.ClassicAddress), Issuer: types.Address(issuer.ClassicAddress),
} }
clients.SubmitTxBlobAndWait(client, acceptTxn, subjectWallet) clients.SubmitTxBlobAndWait(client, acceptTxn, subjectWallet)
// ----------------------------------------------------- // -----------------------------------------------------
// Creating the CredentialDelete transaction // Creating the CredentialDelete transaction
fmt.Println("⏳ Creating CredentialDelete transaction...") fmt.Println("⏳ Creating CredentialDelete transaction...")
deleteTxn := &transaction.CredentialDelete{ deleteTxn := &transaction.CredentialDelete{
BaseTx: transaction.BaseTx{ BaseTx: transaction.BaseTx{
Account: types.Address(issuer.ClassicAddress), Account: types.Address(issuer.ClassicAddress),
}, },
CredentialType: credentialType, CredentialType: credentialType,
Issuer: types.Address(issuer.ClassicAddress), Issuer: types.Address(issuer.ClassicAddress),
Subject: types.Address(subjectWallet.ClassicAddress), Subject: types.Address(subjectWallet.ClassicAddress),
} }
clients.SubmitTxBlobAndWait(client, deleteTxn, issuer) clients.SubmitTxBlobAndWait(client, deleteTxn, issuer)
} }

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

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

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

@@ -1,131 +1,131 @@
package main package main
import ( import (
"fmt" "fmt"
"github.com/Peersyst/xrpl-go/pkg/crypto" "github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet" "github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/rpc" "github.com/Peersyst/xrpl-go/xrpl/rpc"
"github.com/Peersyst/xrpl-go/xrpl/rpc/types" "github.com/Peersyst/xrpl-go/xrpl/rpc/types"
transactions "github.com/Peersyst/xrpl-go/xrpl/transaction" transactions "github.com/Peersyst/xrpl-go/xrpl/transaction"
txnTypes "github.com/Peersyst/xrpl-go/xrpl/transaction/types" txnTypes "github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet" "github.com/Peersyst/xrpl-go/xrpl/wallet"
) )
func main() { func main() {
// Configure the client // Configure the client
cfg, err := rpc.NewClientConfig( cfg, err := rpc.NewClientConfig(
"https://s.devnet.rippletest.net:51234/", "https://s.devnet.rippletest.net:51234/",
rpc.WithFaucetProvider(faucet.NewDevnetFaucetProvider()), rpc.WithFaucetProvider(faucet.NewDevnetFaucetProvider()),
) )
if err != nil { if err != nil {
panic(err) panic(err)
} }
client := rpc.NewClient(cfg) client := rpc.NewClient(cfg)
// Create and fund wallets // Create and fund wallets
delegatorWallet, err := wallet.New(crypto.ED25519()) delegatorWallet, err := wallet.New(crypto.ED25519())
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
delegateeWallet, err := wallet.New(crypto.ED25519()) delegateeWallet, err := wallet.New(crypto.ED25519())
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("⏳ Funding wallets...") fmt.Println("⏳ Funding wallets...")
if err := client.FundWallet(&delegatorWallet); err != nil { if err := client.FundWallet(&delegatorWallet); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
if err := client.FundWallet(&delegateeWallet); err != nil { if err := client.FundWallet(&delegateeWallet); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("💸 Wallets funded") fmt.Println("💸 Wallets funded")
// Check initial balances // Check initial balances
delegatorBalance, err := client.GetXrpBalance(delegatorWallet.ClassicAddress) delegatorBalance, err := client.GetXrpBalance(delegatorWallet.ClassicAddress)
if err != nil { if err != nil {
delegatorBalance = "0" delegatorBalance = "0"
} }
delegateeBalance, err := client.GetXrpBalance(delegateeWallet.ClassicAddress) delegateeBalance, err := client.GetXrpBalance(delegateeWallet.ClassicAddress)
if err != nil { if err != nil {
delegateeBalance = "0" delegateeBalance = "0"
} }
fmt.Printf("💳 Delegator initial balance: %s XRP\n", delegatorBalance) fmt.Printf("💳 Delegator initial balance: %s XRP\n", delegatorBalance)
fmt.Printf("💳 Delegatee initial balance: %s XRP\n", delegateeBalance) fmt.Printf("💳 Delegatee initial balance: %s XRP\n", delegateeBalance)
fmt.Println() fmt.Println()
// Create DelegateSet transaction // Create DelegateSet transaction
delegateSetTx := &transactions.DelegateSet{ delegateSetTx := &transactions.DelegateSet{
BaseTx: transactions.BaseTx{ BaseTx: transactions.BaseTx{
Account: txnTypes.Address(delegatorWallet.ClassicAddress), Account: txnTypes.Address(delegatorWallet.ClassicAddress),
}, },
Authorize: txnTypes.Address(delegateeWallet.ClassicAddress), Authorize: txnTypes.Address(delegateeWallet.ClassicAddress),
Permissions: []txnTypes.Permission{ Permissions: []txnTypes.Permission{
{ {
Permission: txnTypes.PermissionValue{ Permission: txnTypes.PermissionValue{
PermissionValue: "Payment", PermissionValue: "Payment",
}, },
}, },
}, },
} }
// Submit DelegateSet transaction // Submit DelegateSet transaction
response, err := client.SubmitTxAndWait(delegateSetTx.Flatten(), &types.SubmitOptions{ response, err := client.SubmitTxAndWait(delegateSetTx.Flatten(), &types.SubmitOptions{
Autofill: true, Autofill: true,
Wallet: &delegatorWallet, Wallet: &delegatorWallet,
}) })
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("✅ DelegateSet transaction submitted") fmt.Println("✅ DelegateSet transaction submitted")
fmt.Printf("🌐 Hash: %s\n", response.Hash) fmt.Printf("🌐 Hash: %s\n", response.Hash)
fmt.Printf("🌐 Validated: %t\n", response.Validated) fmt.Printf("🌐 Validated: %t\n", response.Validated)
fmt.Println() fmt.Println()
// Create delegated payment transaction // Create delegated payment transaction
delegatedPaymentTx := &transactions.Payment{ delegatedPaymentTx := &transactions.Payment{
BaseTx: transactions.BaseTx{ BaseTx: transactions.BaseTx{
Account: txnTypes.Address(delegatorWallet.ClassicAddress), Account: txnTypes.Address(delegatorWallet.ClassicAddress),
Delegate: txnTypes.Address(delegateeWallet.ClassicAddress), Delegate: txnTypes.Address(delegateeWallet.ClassicAddress),
}, },
Destination: txnTypes.Address(delegateeWallet.ClassicAddress), Destination: txnTypes.Address(delegateeWallet.ClassicAddress),
Amount: txnTypes.XRPCurrencyAmount(1000000), // 1 XRP Amount: txnTypes.XRPCurrencyAmount(1000000), // 1 XRP
} }
// Submit delegated payment // Submit delegated payment
response2, err := client.SubmitTxAndWait(delegatedPaymentTx.Flatten(), &types.SubmitOptions{ response2, err := client.SubmitTxAndWait(delegatedPaymentTx.Flatten(), &types.SubmitOptions{
Autofill: true, Autofill: true,
Wallet: &delegateeWallet, Wallet: &delegateeWallet,
}) })
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("✅ Delegated payment submitted") fmt.Println("✅ Delegated payment submitted")
fmt.Printf("🌐 Hash: %s\n", response2.Hash) fmt.Printf("🌐 Hash: %s\n", response2.Hash)
fmt.Printf("🌐 Validated: %t\n", response2.Validated) fmt.Printf("🌐 Validated: %t\n", response2.Validated)
fmt.Println() fmt.Println()
// Check final balances // Check final balances
finalDelegatorBalance, err := client.GetXrpBalance(delegatorWallet.ClassicAddress) finalDelegatorBalance, err := client.GetXrpBalance(delegatorWallet.ClassicAddress)
if err != nil { if err != nil {
finalDelegatorBalance = "0" finalDelegatorBalance = "0"
} }
finalDelegateeBalance, err := client.GetXrpBalance(delegateeWallet.ClassicAddress) finalDelegateeBalance, err := client.GetXrpBalance(delegateeWallet.ClassicAddress)
if err != nil { if err != nil {
finalDelegateeBalance = "0" finalDelegateeBalance = "0"
} }
fmt.Printf("💳 Delegator final balance: %s XRP\n", finalDelegatorBalance) fmt.Printf("💳 Delegator final balance: %s XRP\n", finalDelegatorBalance)
fmt.Printf("💳 Delegatee final balance: %s XRP\n", finalDelegateeBalance) fmt.Printf("💳 Delegatee final balance: %s XRP\n", finalDelegateeBalance)
} }

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

@@ -1,151 +1,151 @@
package main package main
import ( import (
"fmt" "fmt"
"github.com/Peersyst/xrpl-go/pkg/crypto" "github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet" "github.com/Peersyst/xrpl-go/xrpl/faucet"
transactions "github.com/Peersyst/xrpl-go/xrpl/transaction" transactions "github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types" "github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet" "github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/xrpl/websocket" "github.com/Peersyst/xrpl-go/xrpl/websocket"
) )
func main() { func main() {
// Connect to testnet // Connect to testnet
client := websocket.NewClient( client := websocket.NewClient(
websocket.NewClientConfig(). websocket.NewClientConfig().
WithHost("wss://s.devnet.rippletest.net:51233"). WithHost("wss://s.devnet.rippletest.net:51233").
WithFaucetProvider(faucet.NewDevnetFaucetProvider()), WithFaucetProvider(faucet.NewDevnetFaucetProvider()),
) )
defer client.Disconnect() defer client.Disconnect()
if err := client.Connect(); err != nil { if err := client.Connect(); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
// Create and fund wallets // Create and fund wallets
delegatorWallet, err := wallet.New(crypto.ED25519()) delegatorWallet, err := wallet.New(crypto.ED25519())
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
delegateeWallet, err := wallet.New(crypto.ED25519()) delegateeWallet, err := wallet.New(crypto.ED25519())
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("⏳ Funding wallets...") fmt.Println("⏳ Funding wallets...")
if err := client.FundWallet(&delegatorWallet); err != nil { if err := client.FundWallet(&delegatorWallet); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
if err := client.FundWallet(&delegateeWallet); err != nil { if err := client.FundWallet(&delegateeWallet); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("💸 Wallets funded") fmt.Println("💸 Wallets funded")
// Check initial balances // Check initial balances
delegatorBalance, err := client.GetXrpBalance(delegatorWallet.ClassicAddress) delegatorBalance, err := client.GetXrpBalance(delegatorWallet.ClassicAddress)
if err != nil { if err != nil {
delegatorBalance = "0" delegatorBalance = "0"
} }
delegateeBalance, err := client.GetXrpBalance(delegateeWallet.ClassicAddress) delegateeBalance, err := client.GetXrpBalance(delegateeWallet.ClassicAddress)
if err != nil { if err != nil {
delegateeBalance = "0" delegateeBalance = "0"
} }
fmt.Printf("💳 Delegator initial balance: %s XRP\n", delegatorBalance) fmt.Printf("💳 Delegator initial balance: %s XRP\n", delegatorBalance)
fmt.Printf("💳 Delegatee initial balance: %s XRP\n", delegateeBalance) fmt.Printf("💳 Delegatee initial balance: %s XRP\n", delegateeBalance)
fmt.Println() fmt.Println()
// Create DelegateSet transaction // Create DelegateSet transaction
delegateSetTx := &transactions.DelegateSet{ delegateSetTx := &transactions.DelegateSet{
BaseTx: transactions.BaseTx{ BaseTx: transactions.BaseTx{
Account: types.Address(delegatorWallet.ClassicAddress), Account: types.Address(delegatorWallet.ClassicAddress),
}, },
Authorize: types.Address(delegateeWallet.ClassicAddress), Authorize: types.Address(delegateeWallet.ClassicAddress),
Permissions: []types.Permission{ Permissions: []types.Permission{
{ {
Permission: types.PermissionValue{ Permission: types.PermissionValue{
PermissionValue: "Payment", PermissionValue: "Payment",
}, },
}, },
}, },
} }
// Submit DelegateSet transaction // Submit DelegateSet transaction
flattenedTx := delegateSetTx.Flatten() flattenedTx := delegateSetTx.Flatten()
if err := client.Autofill(&flattenedTx); err != nil { if err := client.Autofill(&flattenedTx); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
txBlob, _, err := delegatorWallet.Sign(flattenedTx) txBlob, _, err := delegatorWallet.Sign(flattenedTx)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
response, err := client.SubmitTxBlobAndWait(txBlob, false) response, err := client.SubmitTxBlobAndWait(txBlob, false)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("✅ DelegateSet transaction submitted") fmt.Println("✅ DelegateSet transaction submitted")
fmt.Printf("🌐 Hash: %s\n", response.Hash) fmt.Printf("🌐 Hash: %s\n", response.Hash)
fmt.Printf("🌐 Validated: %t\n", response.Validated) fmt.Printf("🌐 Validated: %t\n", response.Validated)
fmt.Println() fmt.Println()
// Create delegated payment transaction // Create delegated payment transaction
delegatedPaymentTx := &transactions.Payment{ delegatedPaymentTx := &transactions.Payment{
BaseTx: transactions.BaseTx{ BaseTx: transactions.BaseTx{
Account: types.Address(delegatorWallet.ClassicAddress), Account: types.Address(delegatorWallet.ClassicAddress),
Delegate: types.Address(delegateeWallet.ClassicAddress), Delegate: types.Address(delegateeWallet.ClassicAddress),
}, },
Destination: types.Address(delegateeWallet.ClassicAddress), Destination: types.Address(delegateeWallet.ClassicAddress),
Amount: types.XRPCurrencyAmount(1000000), // 1 XRP Amount: types.XRPCurrencyAmount(1000000), // 1 XRP
} }
// Submit delegated payment // Submit delegated payment
flatDelegatedPayment := delegatedPaymentTx.Flatten() flatDelegatedPayment := delegatedPaymentTx.Flatten()
if err := client.Autofill(&flatDelegatedPayment); err != nil { if err := client.Autofill(&flatDelegatedPayment); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
txBlob2, _, err := delegateeWallet.Sign(flatDelegatedPayment) txBlob2, _, err := delegateeWallet.Sign(flatDelegatedPayment)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
response2, err := client.SubmitTxBlobAndWait(txBlob2, false) response2, err := client.SubmitTxBlobAndWait(txBlob2, false)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("✅ Delegated payment submitted") fmt.Println("✅ Delegated payment submitted")
fmt.Printf("🌐 Hash: %s\n", response2.Hash) fmt.Printf("🌐 Hash: %s\n", response2.Hash)
fmt.Printf("🌐 Validated: %t\n", response2.Validated) fmt.Printf("🌐 Validated: %t\n", response2.Validated)
fmt.Println() fmt.Println()
// Check final balances // Check final balances
finalDelegatorBalance, err := client.GetXrpBalance(delegatorWallet.ClassicAddress) finalDelegatorBalance, err := client.GetXrpBalance(delegatorWallet.ClassicAddress)
if err != nil { if err != nil {
finalDelegatorBalance = "0" finalDelegatorBalance = "0"
} }
finalDelegateeBalance, err := client.GetXrpBalance(delegateeWallet.ClassicAddress) finalDelegateeBalance, err := client.GetXrpBalance(delegateeWallet.ClassicAddress)
if err != nil { if err != nil {
finalDelegateeBalance = "0" finalDelegateeBalance = "0"
} }
fmt.Printf("💳 Delegator final balance: %s XRP\n", finalDelegatorBalance) fmt.Printf("💳 Delegator final balance: %s XRP\n", finalDelegatorBalance)
fmt.Printf("💳 Delegatee final balance: %s XRP\n", finalDelegateeBalance) fmt.Printf("💳 Delegatee final balance: %s XRP\n", finalDelegateeBalance)
} }

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

@@ -1,220 +1,220 @@
package main package main
import ( import (
"encoding/hex" "encoding/hex"
"fmt" "fmt"
"time" "time"
"github.com/Peersyst/xrpl-go/examples/clients" "github.com/Peersyst/xrpl-go/examples/clients"
"github.com/Peersyst/xrpl-go/pkg/crypto" "github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/queries/account" "github.com/Peersyst/xrpl-go/xrpl/queries/account"
"github.com/Peersyst/xrpl-go/xrpl/queries/common" "github.com/Peersyst/xrpl-go/xrpl/queries/common"
rippletime "github.com/Peersyst/xrpl-go/xrpl/time" rippletime "github.com/Peersyst/xrpl-go/xrpl/time"
"github.com/Peersyst/xrpl-go/xrpl/transaction" "github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types" "github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet" "github.com/Peersyst/xrpl-go/xrpl/wallet"
) )
func main() { func main() {
client := clients.GetDevnetRpcClient() client := clients.GetDevnetRpcClient()
// Configure wallets // Configure wallets
// Issuer // Issuer
fmt.Println("⏳ Setting up credential issuer wallet...") fmt.Println("⏳ Setting up credential issuer wallet...")
issuer, err := wallet.New(crypto.ED25519()) issuer, err := wallet.New(crypto.ED25519())
if err != nil { if err != nil {
fmt.Printf("❌ Error creating credential issuer wallet: %s\n", err) fmt.Printf("❌ Error creating credential issuer wallet: %s\n", err)
return return
} }
err = client.FundWallet(&issuer) err = client.FundWallet(&issuer)
if err != nil { if err != nil {
fmt.Printf("❌ Error funding credential issuer wallet: %s\n", err) fmt.Printf("❌ Error funding credential issuer wallet: %s\n", err)
return return
} }
fmt.Printf("✅ Credential issuer wallet funded: %s\n", issuer.ClassicAddress) fmt.Printf("✅ Credential issuer wallet funded: %s\n", issuer.ClassicAddress)
// ----------------------------------------------------- // -----------------------------------------------------
// Holder 1 // Holder 1
fmt.Println("⏳ Setting up holder 1 wallet...") fmt.Println("⏳ Setting up holder 1 wallet...")
holderWallet1, err := wallet.New(crypto.ED25519()) holderWallet1, err := wallet.New(crypto.ED25519())
if err != nil { if err != nil {
fmt.Printf("❌ Error creating holder 1 wallet: %s\n", err) fmt.Printf("❌ Error creating holder 1 wallet: %s\n", err)
return return
} }
err = client.FundWallet(&holderWallet1) err = client.FundWallet(&holderWallet1)
if err != nil { if err != nil {
fmt.Printf("❌ Error funding holder 1 wallet: %s\n", err) fmt.Printf("❌ Error funding holder 1 wallet: %s\n", err)
return return
} }
fmt.Printf("✅ Holder 1 wallet funded: %s\n", holderWallet1.ClassicAddress) fmt.Printf("✅ Holder 1 wallet funded: %s\n", holderWallet1.ClassicAddress)
// ----------------------------------------------------- // -----------------------------------------------------
// Enabling DepositAuth on the issuer account with an AccountSet transaction // Enabling DepositAuth on the issuer account with an AccountSet transaction
fmt.Println("⏳ Enabling DepositAuth on the issuer account...") fmt.Println("⏳ Enabling DepositAuth on the issuer account...")
accountSetTx := &transaction.AccountSet{ accountSetTx := &transaction.AccountSet{
BaseTx: transaction.BaseTx{ BaseTx: transaction.BaseTx{
Account: issuer.ClassicAddress, Account: issuer.ClassicAddress,
TransactionType: transaction.AccountSetTx, TransactionType: transaction.AccountSetTx,
}, },
} }
accountSetTx.SetAsfDepositAuth() accountSetTx.SetAsfDepositAuth()
clients.SubmitTxBlobAndWait(client, accountSetTx, issuer) clients.SubmitTxBlobAndWait(client, accountSetTx, issuer)
// ----------------------------------------------------- // -----------------------------------------------------
// Creating the CredentialCreate transaction // Creating the CredentialCreate transaction
fmt.Println("⏳ Creating the CredentialCreate transaction...") fmt.Println("⏳ Creating the CredentialCreate transaction...")
expiration, err := rippletime.IsoTimeToRippleTime(time.Now().Add(time.Hour * 24).Format(time.RFC3339)) expiration, err := rippletime.IsoTimeToRippleTime(time.Now().Add(time.Hour * 24).Format(time.RFC3339))
if err != nil { if err != nil {
fmt.Printf("❌ Error converting expiration to ripple time: %s\n", err) fmt.Printf("❌ Error converting expiration to ripple time: %s\n", err)
return return
} }
credentialType := types.CredentialType("6D795F63726564656E7469616C") // my_credential credentialType := types.CredentialType("6D795F63726564656E7469616C") // my_credential
credentialCreateTx := &transaction.CredentialCreate{ credentialCreateTx := &transaction.CredentialCreate{
BaseTx: transaction.BaseTx{ BaseTx: transaction.BaseTx{
Account: issuer.ClassicAddress, Account: issuer.ClassicAddress,
TransactionType: transaction.CredentialCreateTx, TransactionType: transaction.CredentialCreateTx,
}, },
Expiration: uint32(expiration), Expiration: uint32(expiration),
CredentialType: credentialType, CredentialType: credentialType,
Subject: types.Address(holderWallet1.ClassicAddress), Subject: types.Address(holderWallet1.ClassicAddress),
URI: hex.EncodeToString([]byte("https://example.com")), URI: hex.EncodeToString([]byte("https://example.com")),
} }
clients.SubmitTxBlobAndWait(client, credentialCreateTx, issuer) clients.SubmitTxBlobAndWait(client, credentialCreateTx, issuer)
// ----------------------------------------------------- // -----------------------------------------------------
// Creating the CredentialAccept transaction // Creating the CredentialAccept transaction
fmt.Println("⏳ Creating the CredentialAccept transaction...") fmt.Println("⏳ Creating the CredentialAccept transaction...")
credentialAcceptTx := &transaction.CredentialAccept{ credentialAcceptTx := &transaction.CredentialAccept{
BaseTx: transaction.BaseTx{ BaseTx: transaction.BaseTx{
Account: holderWallet1.ClassicAddress, Account: holderWallet1.ClassicAddress,
TransactionType: transaction.CredentialAcceptTx, TransactionType: transaction.CredentialAcceptTx,
}, },
CredentialType: credentialType, CredentialType: credentialType,
Issuer: types.Address(issuer.ClassicAddress), Issuer: types.Address(issuer.ClassicAddress),
} }
clients.SubmitTxBlobAndWait(client, credentialAcceptTx, holderWallet1) clients.SubmitTxBlobAndWait(client, credentialAcceptTx, holderWallet1)
// ----------------------------------------------------- // -----------------------------------------------------
// Creating the DepositPreauth transaction // Creating the DepositPreauth transaction
fmt.Println("⏳ Creating the DepositPreauth transaction using AuthorizeCredentials...") fmt.Println("⏳ Creating the DepositPreauth transaction using AuthorizeCredentials...")
depositPreauthTx := &transaction.DepositPreauth{ depositPreauthTx := &transaction.DepositPreauth{
BaseTx: transaction.BaseTx{ BaseTx: transaction.BaseTx{
Account: issuer.ClassicAddress, Account: issuer.ClassicAddress,
TransactionType: transaction.DepositPreauthTx, TransactionType: transaction.DepositPreauthTx,
}, },
AuthorizeCredentials: []types.AuthorizeCredentialsWrapper{ AuthorizeCredentials: []types.AuthorizeCredentialsWrapper{
{ {
Credential: types.AuthorizeCredentials{ Credential: types.AuthorizeCredentials{
Issuer: issuer.ClassicAddress, Issuer: issuer.ClassicAddress,
CredentialType: credentialType, CredentialType: credentialType,
}, },
}, },
}, },
} }
clients.SubmitTxBlobAndWait(client, depositPreauthTx, issuer) clients.SubmitTxBlobAndWait(client, depositPreauthTx, issuer)
// ----------------------------------------------------- // -----------------------------------------------------
// Get the credential ID // Get the credential ID
fmt.Println("⏳ Getting the credential ID from the holder 1 account...") fmt.Println("⏳ Getting the credential ID from the holder 1 account...")
objectsRequest := &account.ObjectsRequest{ objectsRequest := &account.ObjectsRequest{
Account: holderWallet1.ClassicAddress, Account: holderWallet1.ClassicAddress,
Type: account.CredentialObject, Type: account.CredentialObject,
LedgerIndex: common.Validated, LedgerIndex: common.Validated,
} }
objectsResponse, err := client.GetAccountObjects(objectsRequest) objectsResponse, err := client.GetAccountObjects(objectsRequest)
if err != nil { if err != nil {
fmt.Printf("❌ Error getting the credential ID: %s\n", err) fmt.Printf("❌ Error getting the credential ID: %s\n", err)
return return
} }
// Check if we have any credential objects // Check if we have any credential objects
if len(objectsResponse.AccountObjects) == 0 { if len(objectsResponse.AccountObjects) == 0 {
fmt.Println("❌ No credential objects found") fmt.Println("❌ No credential objects found")
return return
} }
// Extract the credential ID // Extract the credential ID
credentialID, ok := objectsResponse.AccountObjects[0]["index"].(string) credentialID, ok := objectsResponse.AccountObjects[0]["index"].(string)
if !ok { if !ok {
fmt.Println("❌ Could not extract credential ID from response") fmt.Println("❌ Could not extract credential ID from response")
return return
} }
fmt.Printf("✅ Credential ID: %s\n", credentialID) fmt.Printf("✅ Credential ID: %s\n", credentialID)
fmt.Println() fmt.Println()
// ----------------------------------------------------- // -----------------------------------------------------
// Sending XRP to the holder 1 account // Sending XRP to the holder 1 account
fmt.Println("⏳ Sending XRP to the issuer account, should succeed...") fmt.Println("⏳ Sending XRP to the issuer account, should succeed...")
sendTx := &transaction.Payment{ sendTx := &transaction.Payment{
BaseTx: transaction.BaseTx{ BaseTx: transaction.BaseTx{
Account: holderWallet1.ClassicAddress, Account: holderWallet1.ClassicAddress,
TransactionType: transaction.PaymentTx, TransactionType: transaction.PaymentTx,
}, },
Amount: types.XRPCurrencyAmount(1000000), Amount: types.XRPCurrencyAmount(1000000),
Destination: issuer.ClassicAddress, Destination: issuer.ClassicAddress,
CredentialIDs: types.CredentialIDs{credentialID}, CredentialIDs: types.CredentialIDs{credentialID},
} }
clients.SubmitTxBlobAndWait(client, sendTx, holderWallet1) clients.SubmitTxBlobAndWait(client, sendTx, holderWallet1)
// ----------------------------------------------------- // -----------------------------------------------------
// Unauthorizing the holder 1 account // Unauthorizing the holder 1 account
fmt.Println("⏳ Unauthorizing the holder 1 account with the DepositPreauth transaction and the UnauthorizeCredentials field...") fmt.Println("⏳ Unauthorizing the holder 1 account with the DepositPreauth transaction and the UnauthorizeCredentials field...")
unauthorizeTx := &transaction.DepositPreauth{ unauthorizeTx := &transaction.DepositPreauth{
BaseTx: transaction.BaseTx{ BaseTx: transaction.BaseTx{
Account: issuer.ClassicAddress, Account: issuer.ClassicAddress,
TransactionType: transaction.DepositPreauthTx, TransactionType: transaction.DepositPreauthTx,
}, },
UnauthorizeCredentials: []types.AuthorizeCredentialsWrapper{ UnauthorizeCredentials: []types.AuthorizeCredentialsWrapper{
{ {
Credential: types.AuthorizeCredentials{ Credential: types.AuthorizeCredentials{
Issuer: issuer.ClassicAddress, Issuer: issuer.ClassicAddress,
CredentialType: credentialType, CredentialType: credentialType,
}, },
}, },
}, },
} }
clients.SubmitTxBlobAndWait(client, unauthorizeTx, issuer) clients.SubmitTxBlobAndWait(client, unauthorizeTx, issuer)
// ----------------------------------------------------- // -----------------------------------------------------
// Sending XRP to the holder 1 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)...") fmt.Println("⏳ Sending XRP to the issuer account again (which should fail)...")
sendTx2 := &transaction.Payment{ sendTx2 := &transaction.Payment{
BaseTx: transaction.BaseTx{ BaseTx: transaction.BaseTx{
Account: holderWallet1.ClassicAddress, Account: holderWallet1.ClassicAddress,
TransactionType: transaction.PaymentTx, TransactionType: transaction.PaymentTx,
}, },
Amount: types.XRPCurrencyAmount(1000000), Amount: types.XRPCurrencyAmount(1000000),
Destination: issuer.ClassicAddress, Destination: issuer.ClassicAddress,
CredentialIDs: types.CredentialIDs{credentialID}, CredentialIDs: types.CredentialIDs{credentialID},
} }
clients.SubmitTxBlobAndWait(client, sendTx2, holderWallet1) clients.SubmitTxBlobAndWait(client, sendTx2, holderWallet1)
} }

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

@@ -1,234 +1,234 @@
package main package main
import ( import (
"encoding/hex" "encoding/hex"
"fmt" "fmt"
"time" "time"
"github.com/Peersyst/xrpl-go/examples/clients" "github.com/Peersyst/xrpl-go/examples/clients"
"github.com/Peersyst/xrpl-go/pkg/crypto" "github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/queries/account" "github.com/Peersyst/xrpl-go/xrpl/queries/account"
"github.com/Peersyst/xrpl-go/xrpl/queries/common" "github.com/Peersyst/xrpl-go/xrpl/queries/common"
rippletime "github.com/Peersyst/xrpl-go/xrpl/time" rippletime "github.com/Peersyst/xrpl-go/xrpl/time"
"github.com/Peersyst/xrpl-go/xrpl/transaction" "github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types" "github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet" "github.com/Peersyst/xrpl-go/xrpl/wallet"
) )
func main() { func main() {
fmt.Println("⏳ Setting up client...") fmt.Println("⏳ Setting up client...")
client := clients.GetDevnetWebsocketClient() client := clients.GetDevnetWebsocketClient()
fmt.Println("Connecting to server...") fmt.Println("Connecting to server...")
if err := client.Connect(); err != nil { if err := client.Connect(); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("✅ Client configured!") fmt.Println("✅ Client configured!")
fmt.Println() fmt.Println()
fmt.Printf("Connection: %t", client.IsConnected()) fmt.Printf("Connection: %t", client.IsConnected())
fmt.Println() fmt.Println()
// Configure wallets // Configure wallets
// Issuer // Issuer
fmt.Println("⏳ Setting up credential issuer wallet...") fmt.Println("⏳ Setting up credential issuer wallet...")
issuer, err := wallet.New(crypto.ED25519()) issuer, err := wallet.New(crypto.ED25519())
if err != nil { if err != nil {
fmt.Printf("❌ Error creating credential issuer wallet: %s\n", err) fmt.Printf("❌ Error creating credential issuer wallet: %s\n", err)
return return
} }
err = client.FundWallet(&issuer) err = client.FundWallet(&issuer)
if err != nil { if err != nil {
fmt.Printf("❌ Error funding credential issuer wallet: %s\n", err) fmt.Printf("❌ Error funding credential issuer wallet: %s\n", err)
return return
} }
fmt.Printf("✅ Credential issuer wallet funded: %s\n", issuer.ClassicAddress) fmt.Printf("✅ Credential issuer wallet funded: %s\n", issuer.ClassicAddress)
// ----------------------------------------------------- // -----------------------------------------------------
// Holder 1 // Holder 1
fmt.Println("⏳ Setting up holder 1 wallet...") fmt.Println("⏳ Setting up holder 1 wallet...")
holderWallet1, err := wallet.New(crypto.ED25519()) holderWallet1, err := wallet.New(crypto.ED25519())
if err != nil { if err != nil {
fmt.Printf("❌ Error creating holder 1 wallet: %s\n", err) fmt.Printf("❌ Error creating holder 1 wallet: %s\n", err)
return return
} }
err = client.FundWallet(&holderWallet1) err = client.FundWallet(&holderWallet1)
if err != nil { if err != nil {
fmt.Printf("❌ Error funding holder 1 wallet: %s\n", err) fmt.Printf("❌ Error funding holder 1 wallet: %s\n", err)
return return
} }
fmt.Printf("✅ Holder 1 wallet funded: %s\n", holderWallet1.ClassicAddress) fmt.Printf("✅ Holder 1 wallet funded: %s\n", holderWallet1.ClassicAddress)
// ----------------------------------------------------- // -----------------------------------------------------
// Enabling DepositAuth on the issuer account with an AccountSet transaction // Enabling DepositAuth on the issuer account with an AccountSet transaction
fmt.Println("⏳ Enabling DepositAuth on the issuer account...") fmt.Println("⏳ Enabling DepositAuth on the issuer account...")
accountSetTx := &transaction.AccountSet{ accountSetTx := &transaction.AccountSet{
BaseTx: transaction.BaseTx{ BaseTx: transaction.BaseTx{
Account: issuer.ClassicAddress, Account: issuer.ClassicAddress,
TransactionType: transaction.AccountSetTx, TransactionType: transaction.AccountSetTx,
}, },
} }
accountSetTx.SetAsfDepositAuth() accountSetTx.SetAsfDepositAuth()
clients.SubmitTxBlobAndWait(client, accountSetTx, issuer) clients.SubmitTxBlobAndWait(client, accountSetTx, issuer)
// ----------------------------------------------------- // -----------------------------------------------------
// Creating the CredentialCreate transaction // Creating the CredentialCreate transaction
fmt.Println("⏳ Creating the CredentialCreate transaction...") fmt.Println("⏳ Creating the CredentialCreate transaction...")
expiration, err := rippletime.IsoTimeToRippleTime(time.Now().Add(time.Hour * 24).Format(time.RFC3339)) expiration, err := rippletime.IsoTimeToRippleTime(time.Now().Add(time.Hour * 24).Format(time.RFC3339))
if err != nil { if err != nil {
fmt.Printf("❌ Error converting expiration to ripple time: %s\n", err) fmt.Printf("❌ Error converting expiration to ripple time: %s\n", err)
return return
} }
credentialType := types.CredentialType("6D795F63726564656E7469616C") // my_credential credentialType := types.CredentialType("6D795F63726564656E7469616C") // my_credential
credentialCreateTx := &transaction.CredentialCreate{ credentialCreateTx := &transaction.CredentialCreate{
BaseTx: transaction.BaseTx{ BaseTx: transaction.BaseTx{
Account: issuer.ClassicAddress, Account: issuer.ClassicAddress,
TransactionType: transaction.CredentialCreateTx, TransactionType: transaction.CredentialCreateTx,
}, },
Expiration: uint32(expiration), Expiration: uint32(expiration),
CredentialType: credentialType, CredentialType: credentialType,
Subject: types.Address(holderWallet1.ClassicAddress), Subject: types.Address(holderWallet1.ClassicAddress),
URI: hex.EncodeToString([]byte("https://example.com")), URI: hex.EncodeToString([]byte("https://example.com")),
} }
clients.SubmitTxBlobAndWait(client, credentialCreateTx, issuer) clients.SubmitTxBlobAndWait(client, credentialCreateTx, issuer)
// ----------------------------------------------------- // -----------------------------------------------------
// Creating the CredentialAccept transaction // Creating the CredentialAccept transaction
fmt.Println("⏳ Creating the CredentialAccept transaction...") fmt.Println("⏳ Creating the CredentialAccept transaction...")
credentialAcceptTx := &transaction.CredentialAccept{ credentialAcceptTx := &transaction.CredentialAccept{
BaseTx: transaction.BaseTx{ BaseTx: transaction.BaseTx{
Account: holderWallet1.ClassicAddress, Account: holderWallet1.ClassicAddress,
TransactionType: transaction.CredentialAcceptTx, TransactionType: transaction.CredentialAcceptTx,
}, },
CredentialType: credentialType, CredentialType: credentialType,
Issuer: types.Address(issuer.ClassicAddress), Issuer: types.Address(issuer.ClassicAddress),
} }
clients.SubmitTxBlobAndWait(client, credentialAcceptTx, holderWallet1) clients.SubmitTxBlobAndWait(client, credentialAcceptTx, holderWallet1)
// ----------------------------------------------------- // -----------------------------------------------------
// Creating the DepositPreauth transaction // Creating the DepositPreauth transaction
fmt.Println("⏳ Creating the DepositPreauth transaction using AuthorizeCredentials...") fmt.Println("⏳ Creating the DepositPreauth transaction using AuthorizeCredentials...")
depositPreauthTx := &transaction.DepositPreauth{ depositPreauthTx := &transaction.DepositPreauth{
BaseTx: transaction.BaseTx{ BaseTx: transaction.BaseTx{
Account: issuer.ClassicAddress, Account: issuer.ClassicAddress,
TransactionType: transaction.DepositPreauthTx, TransactionType: transaction.DepositPreauthTx,
}, },
AuthorizeCredentials: []types.AuthorizeCredentialsWrapper{ AuthorizeCredentials: []types.AuthorizeCredentialsWrapper{
{ {
Credential: types.AuthorizeCredentials{ Credential: types.AuthorizeCredentials{
Issuer: issuer.ClassicAddress, Issuer: issuer.ClassicAddress,
CredentialType: credentialType, CredentialType: credentialType,
}, },
}, },
}, },
} }
clients.SubmitTxBlobAndWait(client, depositPreauthTx, issuer) clients.SubmitTxBlobAndWait(client, depositPreauthTx, issuer)
// ----------------------------------------------------- // -----------------------------------------------------
// Get the credential ID // Get the credential ID
fmt.Println("⏳ Getting the credential ID from the holder 1 account...") fmt.Println("⏳ Getting the credential ID from the holder 1 account...")
objectsRequest := &account.ObjectsRequest{ objectsRequest := &account.ObjectsRequest{
Account: holderWallet1.ClassicAddress, Account: holderWallet1.ClassicAddress,
Type: account.CredentialObject, Type: account.CredentialObject,
LedgerIndex: common.Validated, LedgerIndex: common.Validated,
} }
objectsResponse, err := client.GetAccountObjects(objectsRequest) objectsResponse, err := client.GetAccountObjects(objectsRequest)
if err != nil { if err != nil {
fmt.Printf("❌ Error getting the credential ID: %s\n", err) fmt.Printf("❌ Error getting the credential ID: %s\n", err)
return return
} }
// Check if we have any credential objects // Check if we have any credential objects
if len(objectsResponse.AccountObjects) == 0 { if len(objectsResponse.AccountObjects) == 0 {
fmt.Println("❌ No credential objects found") fmt.Println("❌ No credential objects found")
return return
} }
// Extract the credential ID // Extract the credential ID
credentialID, ok := objectsResponse.AccountObjects[0]["index"].(string) credentialID, ok := objectsResponse.AccountObjects[0]["index"].(string)
if !ok { if !ok {
fmt.Println("❌ Could not extract credential ID from response") fmt.Println("❌ Could not extract credential ID from response")
return return
} }
fmt.Printf("✅ Credential ID: %s\n", credentialID) fmt.Printf("✅ Credential ID: %s\n", credentialID)
fmt.Println() fmt.Println()
// ----------------------------------------------------- // -----------------------------------------------------
// Sending XRP to the holder 1 account // Sending XRP to the holder 1 account
fmt.Println("⏳ Sending XRP to the issuer account, should succeed...") fmt.Println("⏳ Sending XRP to the issuer account, should succeed...")
sendTx := &transaction.Payment{ sendTx := &transaction.Payment{
BaseTx: transaction.BaseTx{ BaseTx: transaction.BaseTx{
Account: holderWallet1.ClassicAddress, Account: holderWallet1.ClassicAddress,
TransactionType: transaction.PaymentTx, TransactionType: transaction.PaymentTx,
}, },
Amount: types.XRPCurrencyAmount(1000000), Amount: types.XRPCurrencyAmount(1000000),
Destination: issuer.ClassicAddress, Destination: issuer.ClassicAddress,
CredentialIDs: types.CredentialIDs{credentialID}, CredentialIDs: types.CredentialIDs{credentialID},
} }
clients.SubmitTxBlobAndWait(client, sendTx, holderWallet1) clients.SubmitTxBlobAndWait(client, sendTx, holderWallet1)
// ----------------------------------------------------- // -----------------------------------------------------
// Unauthorize the holder 1 account // Unauthorize the holder 1 account
fmt.Println("⏳ Unauthorize the holder 1 account with the DepositPreauth transaction and the UnauthorizeCredentials field...") fmt.Println("⏳ Unauthorize the holder 1 account with the DepositPreauth transaction and the UnauthorizeCredentials field...")
unauthorizeTx := &transaction.DepositPreauth{ unauthorizeTx := &transaction.DepositPreauth{
BaseTx: transaction.BaseTx{ BaseTx: transaction.BaseTx{
Account: issuer.ClassicAddress, Account: issuer.ClassicAddress,
TransactionType: transaction.DepositPreauthTx, TransactionType: transaction.DepositPreauthTx,
}, },
UnauthorizeCredentials: []types.AuthorizeCredentialsWrapper{ UnauthorizeCredentials: []types.AuthorizeCredentialsWrapper{
{ {
Credential: types.AuthorizeCredentials{ Credential: types.AuthorizeCredentials{
Issuer: issuer.ClassicAddress, Issuer: issuer.ClassicAddress,
CredentialType: credentialType, CredentialType: credentialType,
}, },
}, },
}, },
} }
clients.SubmitTxBlobAndWait(client, unauthorizeTx, issuer) clients.SubmitTxBlobAndWait(client, unauthorizeTx, issuer)
// ----------------------------------------------------- // -----------------------------------------------------
// Sending XRP to the holder 1 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)...") fmt.Println("⏳ Sending XRP to the issuer account again (which should fail)...")
sendTx2 := &transaction.Payment{ sendTx2 := &transaction.Payment{
BaseTx: transaction.BaseTx{ BaseTx: transaction.BaseTx{
Account: holderWallet1.ClassicAddress, Account: holderWallet1.ClassicAddress,
TransactionType: transaction.PaymentTx, TransactionType: transaction.PaymentTx,
}, },
Amount: types.XRPCurrencyAmount(1000000), Amount: types.XRPCurrencyAmount(1000000),
Destination: issuer.ClassicAddress, Destination: issuer.ClassicAddress,
CredentialIDs: types.CredentialIDs{credentialID}, CredentialIDs: types.CredentialIDs{credentialID},
} }
clients.SubmitTxBlobAndWait(client, sendTx2, holderWallet1) clients.SubmitTxBlobAndWait(client, sendTx2, holderWallet1)
} }

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

@@ -1,347 +1,347 @@
package main package main
import ( import (
"fmt" "fmt"
"github.com/Peersyst/xrpl-go/pkg/crypto" "github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/currency" "github.com/Peersyst/xrpl-go/xrpl/currency"
"github.com/Peersyst/xrpl-go/xrpl/faucet" "github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/rpc" "github.com/Peersyst/xrpl-go/xrpl/rpc"
transactions "github.com/Peersyst/xrpl-go/xrpl/transaction" transactions "github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types" "github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet" "github.com/Peersyst/xrpl-go/xrpl/wallet"
) )
const ( const (
currencyCode = "USDA" currencyCode = "USDA"
) )
type SubmittableTransaction interface { type SubmittableTransaction interface {
TxType() transactions.TxType TxType() transactions.TxType
Flatten() transactions.FlatTransaction // Ensures all transactions can be flattened Flatten() transactions.FlatTransaction // Ensures all transactions can be flattened
} }
func main() { func main() {
client := getRpcClient() client := getRpcClient()
// Configure wallets // Configure wallets
// Issuer // Issuer
fmt.Println("⏳ Setting up issuer wallet...") fmt.Println("⏳ Setting up issuer wallet...")
issuer, err := wallet.New(crypto.ED25519()) issuer, err := wallet.New(crypto.ED25519())
if err != nil { if err != nil {
fmt.Printf("❌ Error creating issuer wallet: %s\n", err) fmt.Printf("❌ Error creating issuer wallet: %s\n", err)
return return
} }
err = client.FundWallet(&issuer) err = client.FundWallet(&issuer)
if err != nil { if err != nil {
fmt.Printf("❌ Error funding issuer wallet: %s\n", err) fmt.Printf("❌ Error funding issuer wallet: %s\n", err)
return return
} }
fmt.Printf("✅ Issuer wallet funded: %s\n", issuer.ClassicAddress) fmt.Printf("✅ Issuer wallet funded: %s\n", issuer.ClassicAddress)
// ----------------------------------------------------- // -----------------------------------------------------
// Holder 1 // Holder 1
fmt.Println("⏳ Setting up holder 1 wallet...") fmt.Println("⏳ Setting up holder 1 wallet...")
holderWallet1, err := wallet.New(crypto.ED25519()) holderWallet1, err := wallet.New(crypto.ED25519())
if err != nil { if err != nil {
fmt.Printf("❌ Error creating holder wallet 1: %s\n", err) fmt.Printf("❌ Error creating holder wallet 1: %s\n", err)
return return
} }
err = client.FundWallet(&holderWallet1) err = client.FundWallet(&holderWallet1)
if err != nil { if err != nil {
fmt.Printf("❌ Error funding holder wallet 1: %s\n", err) fmt.Printf("❌ Error funding holder wallet 1: %s\n", err)
return return
} }
fmt.Printf("✅ Holder wallet 1 funded: %s\n", holderWallet1.ClassicAddress) fmt.Printf("✅ Holder wallet 1 funded: %s\n", holderWallet1.ClassicAddress)
// ----------------------------------------------------- // -----------------------------------------------------
// Holder 2 // Holder 2
fmt.Println("⏳ Setting up holder 2 wallet...") fmt.Println("⏳ Setting up holder 2 wallet...")
holderWallet2, err := wallet.New(crypto.ED25519()) holderWallet2, err := wallet.New(crypto.ED25519())
if err != nil { if err != nil {
fmt.Printf("❌ Error creating holder wallet 2: %s\n", err) fmt.Printf("❌ Error creating holder wallet 2: %s\n", err)
return return
} }
err = client.FundWallet(&holderWallet2) err = client.FundWallet(&holderWallet2)
if err != nil { if err != nil {
fmt.Printf("❌ Error funding holder wallet 2: %s\n", err) fmt.Printf("❌ Error funding holder wallet 2: %s\n", err)
return return
} }
fmt.Printf("✅ Holder wallet 2 funded: %s\n", holderWallet2.ClassicAddress) fmt.Printf("✅ Holder wallet 2 funded: %s\n", holderWallet2.ClassicAddress)
fmt.Println() fmt.Println()
fmt.Println("✅ Wallets setup complete!") fmt.Println("✅ Wallets setup complete!")
fmt.Println() fmt.Println()
// ----------------------------------------------------- // -----------------------------------------------------
// Configuring Issuing account // Configuring Issuing account
fmt.Println("⏳ Configuring issuer address settings...") fmt.Println("⏳ Configuring issuer address settings...")
accountSet := &transactions.AccountSet{ accountSet := &transactions.AccountSet{
BaseTx: transactions.BaseTx{ BaseTx: transactions.BaseTx{
Account: types.Address(issuer.ClassicAddress), Account: types.Address(issuer.ClassicAddress),
}, },
Domain: types.Domain("697373756572"), // issuer Domain: types.Domain("697373756572"), // issuer
} }
accountSet.SetAsfDefaultRipple() accountSet.SetAsfDefaultRipple()
submitAndWait(client, accountSet, issuer) submitAndWait(client, accountSet, issuer)
// ----------------------------------------------------- // -----------------------------------------------------
// Trustline from the holder 1 to the issuer // Trustline from the holder 1 to the issuer
fmt.Println("⏳ Setting up trustline from holder 1 to the issuer...") fmt.Println("⏳ Setting up trustline from holder 1 to the issuer...")
trustSet := &transactions.TrustSet{ trustSet := &transactions.TrustSet{
BaseTx: transactions.BaseTx{ BaseTx: transactions.BaseTx{
Account: types.Address(holderWallet1.ClassicAddress), Account: types.Address(holderWallet1.ClassicAddress),
}, },
LimitAmount: types.IssuedCurrencyAmount{ LimitAmount: types.IssuedCurrencyAmount{
Currency: currency.ConvertStringToHex(currencyCode), Currency: currency.ConvertStringToHex(currencyCode),
Issuer: types.Address(issuer.ClassicAddress), Issuer: types.Address(issuer.ClassicAddress),
Value: "1000000000", Value: "1000000000",
}} }}
trustSet.SetSetNoRippleFlag() trustSet.SetSetNoRippleFlag()
submitAndWait(client, trustSet, holderWallet1) submitAndWait(client, trustSet, holderWallet1)
// ----------------------------------------------------- // -----------------------------------------------------
// Trustline from the holder 2 to the issuer // Trustline from the holder 2 to the issuer
fmt.Println("⏳ Setting up trustline from holder 2 to the issuer...") fmt.Println("⏳ Setting up trustline from holder 2 to the issuer...")
trustSet = &transactions.TrustSet{ trustSet = &transactions.TrustSet{
BaseTx: transactions.BaseTx{ BaseTx: transactions.BaseTx{
Account: types.Address(holderWallet2.ClassicAddress), Account: types.Address(holderWallet2.ClassicAddress),
}, },
LimitAmount: types.IssuedCurrencyAmount{ LimitAmount: types.IssuedCurrencyAmount{
Currency: currency.ConvertStringToHex(currencyCode), Currency: currency.ConvertStringToHex(currencyCode),
Issuer: types.Address(issuer.ClassicAddress), Issuer: types.Address(issuer.ClassicAddress),
Value: "1000000000", Value: "1000000000",
}, },
} }
trustSet.SetSetNoRippleFlag() trustSet.SetSetNoRippleFlag()
submitAndWait(client, trustSet, holderWallet2) submitAndWait(client, trustSet, holderWallet2)
// ----------------------------------------------------- // -----------------------------------------------------
// Minting to Holder 1 // Minting to Holder 1
fmt.Println("⏳ Minting to Holder 1...") fmt.Println("⏳ Minting to Holder 1...")
payment := &transactions.Payment{ payment := &transactions.Payment{
BaseTx: transactions.BaseTx{ BaseTx: transactions.BaseTx{
Account: types.Address(issuer.ClassicAddress), Account: types.Address(issuer.ClassicAddress),
}, },
Destination: types.Address(holderWallet1.ClassicAddress), Destination: types.Address(holderWallet1.ClassicAddress),
Amount: types.IssuedCurrencyAmount{ Amount: types.IssuedCurrencyAmount{
Currency: currency.ConvertStringToHex(currencyCode), Currency: currency.ConvertStringToHex(currencyCode),
Issuer: types.Address(issuer.ClassicAddress), Issuer: types.Address(issuer.ClassicAddress),
Value: "50000", Value: "50000",
}, },
} }
submitAndWait(client, payment, issuer) submitAndWait(client, payment, issuer)
// ----------------------------------------------------- // -----------------------------------------------------
// Minting to Holder 2 // Minting to Holder 2
fmt.Println("⏳ Minting to Holder 2...") fmt.Println("⏳ Minting to Holder 2...")
payment = &transactions.Payment{ payment = &transactions.Payment{
BaseTx: transactions.BaseTx{ BaseTx: transactions.BaseTx{
Account: types.Address(issuer.ClassicAddress), Account: types.Address(issuer.ClassicAddress),
}, },
Destination: types.Address(holderWallet2.ClassicAddress), Destination: types.Address(holderWallet2.ClassicAddress),
Amount: types.IssuedCurrencyAmount{ Amount: types.IssuedCurrencyAmount{
Currency: currency.ConvertStringToHex(currencyCode), Currency: currency.ConvertStringToHex(currencyCode),
Issuer: types.Address(issuer.ClassicAddress), Issuer: types.Address(issuer.ClassicAddress),
Value: "40000", Value: "40000",
}, },
} }
submitAndWait(client, payment, issuer) submitAndWait(client, payment, issuer)
// ----------------------------------------------------- // -----------------------------------------------------
// Sending payment from Holder 1 to Holder 2 // Sending payment from Holder 1 to Holder 2
fmt.Println("⏳ Sending payment from Holder 1 to Holder 2...") fmt.Println("⏳ Sending payment from Holder 1 to Holder 2...")
payment = &transactions.Payment{ payment = &transactions.Payment{
BaseTx: transactions.BaseTx{ BaseTx: transactions.BaseTx{
Account: types.Address(holderWallet1.ClassicAddress), Account: types.Address(holderWallet1.ClassicAddress),
}, },
Destination: types.Address(holderWallet2.ClassicAddress), Destination: types.Address(holderWallet2.ClassicAddress),
Amount: types.IssuedCurrencyAmount{ Amount: types.IssuedCurrencyAmount{
Currency: currency.ConvertStringToHex(currencyCode), Currency: currency.ConvertStringToHex(currencyCode),
Issuer: types.Address(issuer.ClassicAddress), Issuer: types.Address(issuer.ClassicAddress),
Value: "20", Value: "20",
}, },
} }
submitAndWait(client, payment, holderWallet1) submitAndWait(client, payment, holderWallet1)
// ----------------------------------------------------- // -----------------------------------------------------
// Freezing and Deep Freezing holder1 // Freezing and Deep Freezing holder1
fmt.Println("⏳ Freezing and Deep Freezing holder 1 trustline...") fmt.Println("⏳ Freezing and Deep Freezing holder 1 trustline...")
trustSet = &transactions.TrustSet{ trustSet = &transactions.TrustSet{
BaseTx: transactions.BaseTx{ BaseTx: transactions.BaseTx{
Account: types.Address(issuer.ClassicAddress), Account: types.Address(issuer.ClassicAddress),
}, },
LimitAmount: types.IssuedCurrencyAmount{ LimitAmount: types.IssuedCurrencyAmount{
Currency: currency.ConvertStringToHex(currencyCode), Currency: currency.ConvertStringToHex(currencyCode),
Issuer: types.Address(holderWallet1.ClassicAddress), Issuer: types.Address(holderWallet1.ClassicAddress),
Value: "0", Value: "0",
}, },
} }
trustSet.SetSetFreezeFlag() trustSet.SetSetFreezeFlag()
trustSet.SetSetDeepFreezeFlag() 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 // Sending payment from Holder 1 to Holder 2 (which should fail), Holder 1 can't decrease its balance
fmt.Println("⏳ Sending payment from Holder 1 to Holder 2 (which should fail). Holder 1 can't decrease its balance...") fmt.Println("⏳ Sending payment from Holder 1 to Holder 2 (which should fail). Holder 1 can't decrease its balance...")
payment = &transactions.Payment{ payment = &transactions.Payment{
BaseTx: transactions.BaseTx{ BaseTx: transactions.BaseTx{
Account: types.Address(holderWallet1.ClassicAddress), Account: types.Address(holderWallet1.ClassicAddress),
}, },
Destination: types.Address(holderWallet2.ClassicAddress), Destination: types.Address(holderWallet2.ClassicAddress),
Amount: types.IssuedCurrencyAmount{ Amount: types.IssuedCurrencyAmount{
Currency: currency.ConvertStringToHex(currencyCode), Currency: currency.ConvertStringToHex(currencyCode),
Issuer: types.Address(issuer.ClassicAddress), Issuer: types.Address(issuer.ClassicAddress),
Value: "10", Value: "10",
}, },
} }
submitAndWait(client, payment, holderWallet1) 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 // Sending payment from Holder 2 to Holder 1 (which should fail), Holder 1 can't increase its balance
fmt.Println("⏳ Sending payment from Holder 2 to Holder 1 (which should fail). Holder 1 can't increase its balance...") fmt.Println("⏳ Sending payment from Holder 2 to Holder 1 (which should fail). Holder 1 can't increase its balance...")
payment = &transactions.Payment{ payment = &transactions.Payment{
BaseTx: transactions.BaseTx{ BaseTx: transactions.BaseTx{
Account: types.Address(holderWallet2.ClassicAddress), Account: types.Address(holderWallet2.ClassicAddress),
}, },
Destination: types.Address(holderWallet1.ClassicAddress), Destination: types.Address(holderWallet1.ClassicAddress),
Amount: types.IssuedCurrencyAmount{ Amount: types.IssuedCurrencyAmount{
Currency: currency.ConvertStringToHex(currencyCode), Currency: currency.ConvertStringToHex(currencyCode),
Issuer: types.Address(issuer.ClassicAddress), Issuer: types.Address(issuer.ClassicAddress),
Value: "10", Value: "10",
}, },
} }
submitAndWait(client, payment, holderWallet2) submitAndWait(client, payment, holderWallet2)
// ------------------- SHOULD FAIL ⬇️ ------------------ // ------------------- SHOULD FAIL ⬇️ ------------------
// Creating OfferCreate transaction (which should fail), Holder 1 can't create an offer // Creating OfferCreate transaction (which should fail), Holder 1 can't create an offer
fmt.Println("⏳ Creating OfferCreate transaction (which should fail). Holder 1 can't create an offer...") fmt.Println("⏳ Creating OfferCreate transaction (which should fail). Holder 1 can't create an offer...")
offerCreate := &transactions.OfferCreate{ offerCreate := &transactions.OfferCreate{
BaseTx: transactions.BaseTx{ BaseTx: transactions.BaseTx{
Account: types.Address(holderWallet1.ClassicAddress), Account: types.Address(holderWallet1.ClassicAddress),
}, },
TakerPays: types.IssuedCurrencyAmount{ TakerPays: types.IssuedCurrencyAmount{
Currency: currency.ConvertStringToHex(currencyCode), Currency: currency.ConvertStringToHex(currencyCode),
Issuer: types.Address(issuer.ClassicAddress), Issuer: types.Address(issuer.ClassicAddress),
Value: "10", Value: "10",
}, },
TakerGets: types.XRPCurrencyAmount(10), TakerGets: types.XRPCurrencyAmount(10),
} }
submitAndWait(client, offerCreate, holderWallet1) submitAndWait(client, offerCreate, holderWallet1)
// ----------------------------------------------------- // -----------------------------------------------------
// Unfreezing and Deep Unfreezing holder 1 // Unfreezing and Deep Unfreezing holder 1
fmt.Println("⏳ Unfreezing and Deep Unfreezing holder 1 trustline...") fmt.Println("⏳ Unfreezing and Deep Unfreezing holder 1 trustline...")
trustSet = &transactions.TrustSet{ trustSet = &transactions.TrustSet{
BaseTx: transactions.BaseTx{ BaseTx: transactions.BaseTx{
Account: types.Address(issuer.ClassicAddress), Account: types.Address(issuer.ClassicAddress),
}, },
LimitAmount: types.IssuedCurrencyAmount{ LimitAmount: types.IssuedCurrencyAmount{
Currency: currency.ConvertStringToHex(currencyCode), Currency: currency.ConvertStringToHex(currencyCode),
Issuer: types.Address(holderWallet1.ClassicAddress), Issuer: types.Address(holderWallet1.ClassicAddress),
Value: "0", Value: "0",
}, },
} }
trustSet.SetClearFreezeFlag() trustSet.SetClearFreezeFlag()
trustSet.SetClearDeepFreezeFlag() trustSet.SetClearDeepFreezeFlag()
submitAndWait(client, trustSet, issuer) submitAndWait(client, trustSet, issuer)
// ----------------------------------------------------- // -----------------------------------------------------
// Sending payment from Holder 1 to Holder 2 (which should succeed), Holder 1 can decrease its balance // Sending payment from Holder 1 to Holder 2 (which should succeed), Holder 1 can decrease its balance
fmt.Println("⏳ Sending payment from Holder 1 to Holder 2 (which should succeed). Holder 1 can decrease its balance...") fmt.Println("⏳ Sending payment from Holder 1 to Holder 2 (which should succeed). Holder 1 can decrease its balance...")
payment = &transactions.Payment{ payment = &transactions.Payment{
BaseTx: transactions.BaseTx{ BaseTx: transactions.BaseTx{
Account: types.Address(holderWallet1.ClassicAddress), Account: types.Address(holderWallet1.ClassicAddress),
}, },
Destination: types.Address(holderWallet2.ClassicAddress), Destination: types.Address(holderWallet2.ClassicAddress),
Amount: types.IssuedCurrencyAmount{ Amount: types.IssuedCurrencyAmount{
Currency: currency.ConvertStringToHex(currencyCode), Currency: currency.ConvertStringToHex(currencyCode),
Issuer: types.Address(issuer.ClassicAddress), Issuer: types.Address(issuer.ClassicAddress),
Value: "10", Value: "10",
}, },
} }
submitAndWait(client, payment, holderWallet1) submitAndWait(client, payment, holderWallet1)
// ----------------------------------------------------- // -----------------------------------------------------
// Sending payment from Holder 2 to Holder 1 (which should succeed), Holder 1 can increase its balance // Sending payment from Holder 2 to Holder 1 (which should succeed), Holder 1 can increase its balance
fmt.Println("⏳ Sending payment from Holder 2 to Holder 1 (which should succeed). Holder 1 can increase its balance...") fmt.Println("⏳ Sending payment from Holder 2 to Holder 1 (which should succeed). Holder 1 can increase its balance...")
payment = &transactions.Payment{ payment = &transactions.Payment{
BaseTx: transactions.BaseTx{ BaseTx: transactions.BaseTx{
Account: types.Address(holderWallet2.ClassicAddress), Account: types.Address(holderWallet2.ClassicAddress),
}, },
Destination: types.Address(holderWallet1.ClassicAddress), Destination: types.Address(holderWallet1.ClassicAddress),
Amount: types.IssuedCurrencyAmount{ Amount: types.IssuedCurrencyAmount{
Currency: currency.ConvertStringToHex(currencyCode), Currency: currency.ConvertStringToHex(currencyCode),
Issuer: types.Address(issuer.ClassicAddress), Issuer: types.Address(issuer.ClassicAddress),
Value: "10", Value: "10",
}, },
} }
submitAndWait(client, payment, holderWallet2) submitAndWait(client, payment, holderWallet2)
} }
// getRpcClient returns a new rpc client // getRpcClient returns a new rpc client
func getRpcClient() *rpc.Client { func getRpcClient() *rpc.Client {
cfg, err := rpc.NewClientConfig( cfg, err := rpc.NewClientConfig(
// DeepFreeze only available on Devnet as of February 2025, change to testnet/mainnet once the amendment passes. // DeepFreeze only available on Devnet as of February 2025, change to testnet/mainnet once the amendment passes.
"https://s.devnet.rippletest.net:51234", "https://s.devnet.rippletest.net:51234",
rpc.WithFaucetProvider(faucet.NewDevnetFaucetProvider()), rpc.WithFaucetProvider(faucet.NewDevnetFaucetProvider()),
) )
if err != nil { if err != nil {
panic(err) 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 // 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) { 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) err := client.Autofill(&flattenedTx)
if err != nil { if err != nil {
fmt.Printf("❌ Error autofilling %s transaction: %s\n", txn.TxType(), err) fmt.Printf("❌ Error autofilling %s transaction: %s\n", txn.TxType(), err)
fmt.Println() fmt.Println()
return return
} }
txBlob, _, err := wallet.Sign(flattenedTx) txBlob, _, err := wallet.Sign(flattenedTx)
if err != nil { if err != nil {
fmt.Printf("❌ Error signing %s transaction: %s\n", txn.TxType(), err) fmt.Printf("❌ Error signing %s transaction: %s\n", txn.TxType(), err)
fmt.Println() fmt.Println()
return return
} }
response, err := client.SubmitTxBlobAndWait(txBlob, false) response, err := client.SubmitTxBlobAndWait(txBlob, false)
if err != nil { if err != nil {
fmt.Printf("❌ Error submitting %s transaction: %s\n", txn.TxType(), err) fmt.Printf("❌ Error submitting %s transaction: %s\n", txn.TxType(), err)
fmt.Println() fmt.Println()
return return
} }
fmt.Printf("✅ %s transaction submitted\n", txn.TxType()) fmt.Printf("✅ %s transaction submitted\n", txn.TxType())
fmt.Printf("🌐 Hash: %s\n", response.Hash.String()) fmt.Printf("🌐 Hash: %s\n", response.Hash.String())
fmt.Println() fmt.Println()
} }

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

@@ -1,357 +1,357 @@
package main package main
import ( import (
"fmt" "fmt"
"github.com/Peersyst/xrpl-go/pkg/crypto" "github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/currency" "github.com/Peersyst/xrpl-go/xrpl/currency"
"github.com/Peersyst/xrpl-go/xrpl/faucet" "github.com/Peersyst/xrpl-go/xrpl/faucet"
transactions "github.com/Peersyst/xrpl-go/xrpl/transaction" transactions "github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types" "github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet" "github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/xrpl/websocket" "github.com/Peersyst/xrpl-go/xrpl/websocket"
) )
const ( const (
currencyCode = "USDA" currencyCode = "USDA"
) )
type SubmittableTransaction interface { type SubmittableTransaction interface {
TxType() transactions.TxType TxType() transactions.TxType
Flatten() transactions.FlatTransaction // Ensures all transactions can be flattened Flatten() transactions.FlatTransaction // Ensures all transactions can be flattened
} }
func main() { func main() {
fmt.Println("⏳ Setting up client...") fmt.Println("⏳ Setting up client...")
client := getClient() client := getClient()
fmt.Println("Connecting to server...") fmt.Println("Connecting to server...")
if err := client.Connect(); err != nil { if err := client.Connect(); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("✅ Client configured!") fmt.Println("✅ Client configured!")
fmt.Println() fmt.Println()
fmt.Printf("Connection: %t", client.IsConnected()) fmt.Printf("Connection: %t", client.IsConnected())
fmt.Println() fmt.Println()
// Configure wallets // Configure wallets
// Issuer // Issuer
fmt.Println("⏳ Setting up issuer wallet...") fmt.Println("⏳ Setting up issuer wallet...")
issuer, err := wallet.New(crypto.ED25519()) issuer, err := wallet.New(crypto.ED25519())
if err != nil { if err != nil {
fmt.Printf("❌ Error creating issuer wallet: %s\n", err) fmt.Printf("❌ Error creating issuer wallet: %s\n", err)
return return
} }
err = client.FundWallet(&issuer) err = client.FundWallet(&issuer)
if err != nil { if err != nil {
fmt.Printf("❌ Error funding issuer wallet: %s\n", err) fmt.Printf("❌ Error funding issuer wallet: %s\n", err)
return return
} }
fmt.Printf("✅ Issuer wallet funded: %s\n", issuer.ClassicAddress) fmt.Printf("✅ Issuer wallet funded: %s\n", issuer.ClassicAddress)
// ----------------------------------------------------- // -----------------------------------------------------
// Holder 1 // Holder 1
fmt.Println("⏳ Setting up holder 1 wallet...") fmt.Println("⏳ Setting up holder 1 wallet...")
holderWallet1, err := wallet.New(crypto.ED25519()) holderWallet1, err := wallet.New(crypto.ED25519())
if err != nil { if err != nil {
fmt.Printf("❌ Error creating holder wallet 1: %s\n", err) fmt.Printf("❌ Error creating holder wallet 1: %s\n", err)
return return
} }
err = client.FundWallet(&holderWallet1) err = client.FundWallet(&holderWallet1)
if err != nil { if err != nil {
fmt.Printf("❌ Error funding holder wallet 1: %s\n", err) fmt.Printf("❌ Error funding holder wallet 1: %s\n", err)
return return
} }
fmt.Printf("✅ Holder wallet 1 funded: %s\n", holderWallet1.ClassicAddress) fmt.Printf("✅ Holder wallet 1 funded: %s\n", holderWallet1.ClassicAddress)
// ----------------------------------------------------- // -----------------------------------------------------
// Holder 2 // Holder 2
fmt.Println("⏳ Setting up holder 2 wallet...") fmt.Println("⏳ Setting up holder 2 wallet...")
holderWallet2, err := wallet.New(crypto.ED25519()) holderWallet2, err := wallet.New(crypto.ED25519())
if err != nil { if err != nil {
fmt.Printf("❌ Error creating holder wallet 2: %s\n", err) fmt.Printf("❌ Error creating holder wallet 2: %s\n", err)
return return
} }
err = client.FundWallet(&holderWallet2) err = client.FundWallet(&holderWallet2)
if err != nil { if err != nil {
fmt.Printf("❌ Error funding holder wallet 2: %s\n", err) fmt.Printf("❌ Error funding holder wallet 2: %s\n", err)
return return
} }
fmt.Printf("✅ Holder wallet 2 funded: %s\n", holderWallet2.ClassicAddress) fmt.Printf("✅ Holder wallet 2 funded: %s\n", holderWallet2.ClassicAddress)
fmt.Println() fmt.Println()
fmt.Println("✅ Wallets setup complete!") fmt.Println("✅ Wallets setup complete!")
fmt.Println() fmt.Println()
// ----------------------------------------------------- // -----------------------------------------------------
// Configuring Issuing account // Configuring Issuing account
fmt.Println("⏳ Configuring issuer address settings...") fmt.Println("⏳ Configuring issuer address settings...")
accountSet := &transactions.AccountSet{ accountSet := &transactions.AccountSet{
BaseTx: transactions.BaseTx{ BaseTx: transactions.BaseTx{
Account: types.Address(issuer.ClassicAddress), Account: types.Address(issuer.ClassicAddress),
}, },
Domain: types.Domain("697373756572"), // issuer Domain: types.Domain("697373756572"), // issuer
} }
accountSet.SetAsfDefaultRipple() accountSet.SetAsfDefaultRipple()
submitAndWait(client, accountSet, issuer) submitAndWait(client, accountSet, issuer)
// ----------------------------------------------------- // -----------------------------------------------------
// Trustline from the holder 1 to the issuer // Trustline from the holder 1 to the issuer
fmt.Println("⏳ Setting up trustline from holder 1 to the issuer...") fmt.Println("⏳ Setting up trustline from holder 1 to the issuer...")
trustSet := &transactions.TrustSet{ trustSet := &transactions.TrustSet{
BaseTx: transactions.BaseTx{ BaseTx: transactions.BaseTx{
Account: types.Address(holderWallet1.ClassicAddress), Account: types.Address(holderWallet1.ClassicAddress),
}, },
LimitAmount: types.IssuedCurrencyAmount{ LimitAmount: types.IssuedCurrencyAmount{
Currency: currency.ConvertStringToHex(currencyCode), Currency: currency.ConvertStringToHex(currencyCode),
Issuer: types.Address(issuer.ClassicAddress), Issuer: types.Address(issuer.ClassicAddress),
Value: "1000000000", Value: "1000000000",
}} }}
trustSet.SetSetNoRippleFlag() trustSet.SetSetNoRippleFlag()
submitAndWait(client, trustSet, holderWallet1) submitAndWait(client, trustSet, holderWallet1)
// ----------------------------------------------------- // -----------------------------------------------------
// Trustline from the holder 2 to the issuer // Trustline from the holder 2 to the issuer
fmt.Println("⏳ Setting up trustline from holder 2 to the issuer...") fmt.Println("⏳ Setting up trustline from holder 2 to the issuer...")
trustSet = &transactions.TrustSet{ trustSet = &transactions.TrustSet{
BaseTx: transactions.BaseTx{ BaseTx: transactions.BaseTx{
Account: types.Address(holderWallet2.ClassicAddress), Account: types.Address(holderWallet2.ClassicAddress),
}, },
LimitAmount: types.IssuedCurrencyAmount{ LimitAmount: types.IssuedCurrencyAmount{
Currency: currency.ConvertStringToHex(currencyCode), Currency: currency.ConvertStringToHex(currencyCode),
Issuer: types.Address(issuer.ClassicAddress), Issuer: types.Address(issuer.ClassicAddress),
Value: "1000000000", Value: "1000000000",
}, },
} }
trustSet.SetSetNoRippleFlag() trustSet.SetSetNoRippleFlag()
submitAndWait(client, trustSet, holderWallet2) submitAndWait(client, trustSet, holderWallet2)
// ----------------------------------------------------- // -----------------------------------------------------
// Minting to Holder 1 // Minting to Holder 1
fmt.Println("⏳ Minting to Holder 1...") fmt.Println("⏳ Minting to Holder 1...")
payment := &transactions.Payment{ payment := &transactions.Payment{
BaseTx: transactions.BaseTx{ BaseTx: transactions.BaseTx{
Account: types.Address(issuer.ClassicAddress), Account: types.Address(issuer.ClassicAddress),
}, },
Destination: types.Address(holderWallet1.ClassicAddress), Destination: types.Address(holderWallet1.ClassicAddress),
Amount: types.IssuedCurrencyAmount{ Amount: types.IssuedCurrencyAmount{
Currency: currency.ConvertStringToHex(currencyCode), Currency: currency.ConvertStringToHex(currencyCode),
Issuer: types.Address(issuer.ClassicAddress), Issuer: types.Address(issuer.ClassicAddress),
Value: "50000", Value: "50000",
}, },
} }
submitAndWait(client, payment, issuer) submitAndWait(client, payment, issuer)
// ----------------------------------------------------- // -----------------------------------------------------
// Minting to Holder 2 // Minting to Holder 2
fmt.Println("⏳ Minting to Holder 2...") fmt.Println("⏳ Minting to Holder 2...")
payment = &transactions.Payment{ payment = &transactions.Payment{
BaseTx: transactions.BaseTx{ BaseTx: transactions.BaseTx{
Account: types.Address(issuer.ClassicAddress), Account: types.Address(issuer.ClassicAddress),
}, },
Destination: types.Address(holderWallet2.ClassicAddress), Destination: types.Address(holderWallet2.ClassicAddress),
Amount: types.IssuedCurrencyAmount{ Amount: types.IssuedCurrencyAmount{
Currency: currency.ConvertStringToHex(currencyCode), Currency: currency.ConvertStringToHex(currencyCode),
Issuer: types.Address(issuer.ClassicAddress), Issuer: types.Address(issuer.ClassicAddress),
Value: "40000", Value: "40000",
}, },
} }
submitAndWait(client, payment, issuer) submitAndWait(client, payment, issuer)
// ----------------------------------------------------- // -----------------------------------------------------
// Sending payment from Holder 1 to Holder 2 // Sending payment from Holder 1 to Holder 2
fmt.Println("⏳ Sending payment from Holder 1 to Holder 2...") fmt.Println("⏳ Sending payment from Holder 1 to Holder 2...")
payment = &transactions.Payment{ payment = &transactions.Payment{
BaseTx: transactions.BaseTx{ BaseTx: transactions.BaseTx{
Account: types.Address(holderWallet1.ClassicAddress), Account: types.Address(holderWallet1.ClassicAddress),
}, },
Destination: types.Address(holderWallet2.ClassicAddress), Destination: types.Address(holderWallet2.ClassicAddress),
Amount: types.IssuedCurrencyAmount{ Amount: types.IssuedCurrencyAmount{
Currency: currency.ConvertStringToHex(currencyCode), Currency: currency.ConvertStringToHex(currencyCode),
Issuer: types.Address(issuer.ClassicAddress), Issuer: types.Address(issuer.ClassicAddress),
Value: "20", Value: "20",
}, },
} }
submitAndWait(client, payment, holderWallet1) submitAndWait(client, payment, holderWallet1)
// ----------------------------------------------------- // -----------------------------------------------------
// Freezing and Deep Freezing holder1 // Freezing and Deep Freezing holder1
fmt.Println("⏳ Freezing and Deep Freezing holder 1 trustline...") fmt.Println("⏳ Freezing and Deep Freezing holder 1 trustline...")
trustSet = &transactions.TrustSet{ trustSet = &transactions.TrustSet{
BaseTx: transactions.BaseTx{ BaseTx: transactions.BaseTx{
Account: types.Address(issuer.ClassicAddress), Account: types.Address(issuer.ClassicAddress),
}, },
LimitAmount: types.IssuedCurrencyAmount{ LimitAmount: types.IssuedCurrencyAmount{
Currency: currency.ConvertStringToHex(currencyCode), Currency: currency.ConvertStringToHex(currencyCode),
Issuer: types.Address(holderWallet1.ClassicAddress), Issuer: types.Address(holderWallet1.ClassicAddress),
Value: "0", Value: "0",
}, },
} }
trustSet.SetSetFreezeFlag() trustSet.SetSetFreezeFlag()
trustSet.SetSetDeepFreezeFlag() 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 // Sending payment from Holder 1 to Holder 2 (which should fail), Holder 1 can't decrease its balance
fmt.Println("⏳ Sending payment from Holder 1 to Holder 2 (which should fail). Holder 1 can't decrease its balance...") fmt.Println("⏳ Sending payment from Holder 1 to Holder 2 (which should fail). Holder 1 can't decrease its balance...")
payment = &transactions.Payment{ payment = &transactions.Payment{
BaseTx: transactions.BaseTx{ BaseTx: transactions.BaseTx{
Account: types.Address(holderWallet1.ClassicAddress), Account: types.Address(holderWallet1.ClassicAddress),
}, },
Destination: types.Address(holderWallet2.ClassicAddress), Destination: types.Address(holderWallet2.ClassicAddress),
Amount: types.IssuedCurrencyAmount{ Amount: types.IssuedCurrencyAmount{
Currency: currency.ConvertStringToHex(currencyCode), Currency: currency.ConvertStringToHex(currencyCode),
Issuer: types.Address(issuer.ClassicAddress), Issuer: types.Address(issuer.ClassicAddress),
Value: "10", Value: "10",
}, },
} }
submitAndWait(client, payment, holderWallet1) 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 // Sending payment from Holder 2 to Holder 1 (which should fail), Holder 1 can't increase its balance
fmt.Println("⏳ Sending payment from Holder 2 to Holder 1 (which should fail). Holder 1 can't increase its balance...") fmt.Println("⏳ Sending payment from Holder 2 to Holder 1 (which should fail). Holder 1 can't increase its balance...")
payment = &transactions.Payment{ payment = &transactions.Payment{
BaseTx: transactions.BaseTx{ BaseTx: transactions.BaseTx{
Account: types.Address(holderWallet2.ClassicAddress), Account: types.Address(holderWallet2.ClassicAddress),
}, },
Destination: types.Address(holderWallet1.ClassicAddress), Destination: types.Address(holderWallet1.ClassicAddress),
Amount: types.IssuedCurrencyAmount{ Amount: types.IssuedCurrencyAmount{
Currency: currency.ConvertStringToHex(currencyCode), Currency: currency.ConvertStringToHex(currencyCode),
Issuer: types.Address(issuer.ClassicAddress), Issuer: types.Address(issuer.ClassicAddress),
Value: "10", Value: "10",
}, },
} }
submitAndWait(client, payment, holderWallet2) submitAndWait(client, payment, holderWallet2)
// ------------------- SHOULD FAIL ⬇️ ------------------ // ------------------- SHOULD FAIL ⬇️ ------------------
// Creating OfferCreate transaction (which should fail), Holder 1 can't create an offer // Creating OfferCreate transaction (which should fail), Holder 1 can't create an offer
fmt.Println("⏳ Creating OfferCreate transaction (which should fail). Holder 1 can't create an offer...") fmt.Println("⏳ Creating OfferCreate transaction (which should fail). Holder 1 can't create an offer...")
offerCreate := &transactions.OfferCreate{ offerCreate := &transactions.OfferCreate{
BaseTx: transactions.BaseTx{ BaseTx: transactions.BaseTx{
Account: types.Address(holderWallet1.ClassicAddress), Account: types.Address(holderWallet1.ClassicAddress),
}, },
TakerPays: types.IssuedCurrencyAmount{ TakerPays: types.IssuedCurrencyAmount{
Currency: currency.ConvertStringToHex(currencyCode), Currency: currency.ConvertStringToHex(currencyCode),
Issuer: types.Address(issuer.ClassicAddress), Issuer: types.Address(issuer.ClassicAddress),
Value: "10", Value: "10",
}, },
TakerGets: types.XRPCurrencyAmount(10), TakerGets: types.XRPCurrencyAmount(10),
} }
submitAndWait(client, offerCreate, holderWallet1) submitAndWait(client, offerCreate, holderWallet1)
// ----------------------------------------------------- // -----------------------------------------------------
// Unfreezing and Deep Unfreezing holder 1 // Unfreezing and Deep Unfreezing holder 1
fmt.Println("⏳ Unfreezing and Deep Unfreezing holder 1 trustline...") fmt.Println("⏳ Unfreezing and Deep Unfreezing holder 1 trustline...")
trustSet = &transactions.TrustSet{ trustSet = &transactions.TrustSet{
BaseTx: transactions.BaseTx{ BaseTx: transactions.BaseTx{
Account: types.Address(issuer.ClassicAddress), Account: types.Address(issuer.ClassicAddress),
}, },
LimitAmount: types.IssuedCurrencyAmount{ LimitAmount: types.IssuedCurrencyAmount{
Currency: currency.ConvertStringToHex(currencyCode), Currency: currency.ConvertStringToHex(currencyCode),
Issuer: types.Address(holderWallet1.ClassicAddress), Issuer: types.Address(holderWallet1.ClassicAddress),
Value: "0", Value: "0",
}, },
} }
trustSet.SetClearFreezeFlag() trustSet.SetClearFreezeFlag()
trustSet.SetClearDeepFreezeFlag() trustSet.SetClearDeepFreezeFlag()
submitAndWait(client, trustSet, issuer) submitAndWait(client, trustSet, issuer)
// ----------------------------------------------------- // -----------------------------------------------------
// Sending payment from Holder 1 to Holder 2 (which should succeed), Holder 1 can decrease its balance // Sending payment from Holder 1 to Holder 2 (which should succeed), Holder 1 can decrease its balance
fmt.Println("⏳ Sending payment from Holder 1 to Holder 2 (which should succeed). Holder 1 can decrease its balance...") fmt.Println("⏳ Sending payment from Holder 1 to Holder 2 (which should succeed). Holder 1 can decrease its balance...")
payment = &transactions.Payment{ payment = &transactions.Payment{
BaseTx: transactions.BaseTx{ BaseTx: transactions.BaseTx{
Account: types.Address(holderWallet1.ClassicAddress), Account: types.Address(holderWallet1.ClassicAddress),
}, },
Destination: types.Address(holderWallet2.ClassicAddress), Destination: types.Address(holderWallet2.ClassicAddress),
Amount: types.IssuedCurrencyAmount{ Amount: types.IssuedCurrencyAmount{
Currency: currency.ConvertStringToHex(currencyCode), Currency: currency.ConvertStringToHex(currencyCode),
Issuer: types.Address(issuer.ClassicAddress), Issuer: types.Address(issuer.ClassicAddress),
Value: "10", Value: "10",
}, },
} }
submitAndWait(client, payment, holderWallet1) submitAndWait(client, payment, holderWallet1)
// ----------------------------------------------------- // -----------------------------------------------------
// Sending payment from Holder 2 to Holder 1 (which should succeed), Holder 1 can increase its balance // Sending payment from Holder 2 to Holder 1 (which should succeed), Holder 1 can increase its balance
fmt.Println("⏳ Sending payment from Holder 2 to Holder 1 (which should succeed). Holder 1 can increase its balance...") fmt.Println("⏳ Sending payment from Holder 2 to Holder 1 (which should succeed). Holder 1 can increase its balance...")
payment = &transactions.Payment{ payment = &transactions.Payment{
BaseTx: transactions.BaseTx{ BaseTx: transactions.BaseTx{
Account: types.Address(holderWallet2.ClassicAddress), Account: types.Address(holderWallet2.ClassicAddress),
}, },
Destination: types.Address(holderWallet1.ClassicAddress), Destination: types.Address(holderWallet1.ClassicAddress),
Amount: types.IssuedCurrencyAmount{ Amount: types.IssuedCurrencyAmount{
Currency: currency.ConvertStringToHex(currencyCode), Currency: currency.ConvertStringToHex(currencyCode),
Issuer: types.Address(issuer.ClassicAddress), Issuer: types.Address(issuer.ClassicAddress),
Value: "10", Value: "10",
}, },
} }
submitAndWait(client, payment, holderWallet2) submitAndWait(client, payment, holderWallet2)
} }
// getRpcClient returns a new rpc client // getRpcClient returns a new rpc client
func getClient() *websocket.Client { func getClient() *websocket.Client {
client := websocket.NewClient( client := websocket.NewClient(
websocket.NewClientConfig(). websocket.NewClientConfig().
WithHost("wss://s.devnet.rippletest.net:51233"). WithHost("wss://s.devnet.rippletest.net:51233").
WithFaucetProvider(faucet.NewDevnetFaucetProvider()), WithFaucetProvider(faucet.NewDevnetFaucetProvider()),
) )
return client return client
} }
// submitAndWait submits a transaction and waits for it to be included in a validated ledger // 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) { 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) err := client.Autofill(&flattenedTx)
if err != nil { if err != nil {
fmt.Printf("❌ Error autofilling %s transaction: %s\n", txn.TxType(), err) fmt.Printf("❌ Error autofilling %s transaction: %s\n", txn.TxType(), err)
fmt.Println() fmt.Println()
return return
} }
txBlob, _, err := wallet.Sign(flattenedTx) txBlob, _, err := wallet.Sign(flattenedTx)
if err != nil { if err != nil {
fmt.Printf("❌ Error signing %s transaction: %s\n", txn.TxType(), err) fmt.Printf("❌ Error signing %s transaction: %s\n", txn.TxType(), err)
fmt.Println() fmt.Println()
return return
} }
response, err := client.SubmitTxBlobAndWait(txBlob, false) response, err := client.SubmitTxBlobAndWait(txBlob, false)
if err != nil { if err != nil {
fmt.Printf("❌ Error submitting %s transaction: %s\n", txn.TxType(), err) fmt.Printf("❌ Error submitting %s transaction: %s\n", txn.TxType(), err)
fmt.Println() fmt.Println()
return return
} }
fmt.Printf("✅ %s transaction submitted\n", txn.TxType()) fmt.Printf("✅ %s transaction submitted\n", txn.TxType())
fmt.Printf("🌐 Hash: %s\n", response.Hash.String()) fmt.Printf("🌐 Hash: %s\n", response.Hash.String())
fmt.Println() fmt.Println()
} }

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

@@ -1,26 +1,26 @@
package main package main
import ( import (
"github.com/Peersyst/xrpl-go/xrpl/queries/utility" "github.com/Peersyst/xrpl-go/xrpl/queries/utility"
"github.com/Peersyst/xrpl-go/xrpl/rpc" "github.com/Peersyst/xrpl-go/xrpl/rpc"
) )
func main() { func main() {
// Define the network client configuration // Define the network client configuration
cfg, err := rpc.NewClientConfig("https://s.altnet.rippletest.net:51234/") cfg, err := rpc.NewClientConfig("https://s.altnet.rippletest.net:51234/")
if err != nil { if err != nil {
panic(err) panic(err)
} }
// Initiate the network client // Initiate the network client
client := rpc.NewClient(cfg) client := rpc.NewClient(cfg)
// Ping the network (used to avoid Go unused variable error, but useful to check connectivity) // Ping the network (used to avoid Go unused variable error, but useful to check connectivity)
_, err = client.Ping(&utility.PingRequest{}) _, err = client.Ping(&utility.PingRequest{})
if err != nil { if err != nil {
panic(err) panic(err)
} }
// ... custom code goes here // ... custom code goes here
} }

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

@@ -1,25 +1,25 @@
package main package main
import ( import (
"fmt" "fmt"
"github.com/Peersyst/xrpl-go/xrpl/websocket" "github.com/Peersyst/xrpl-go/xrpl/websocket"
) )
func main() { func main() {
// Define the network client // Define the network client
client := websocket.NewClient(websocket.NewClientConfig(). client := websocket.NewClient(websocket.NewClientConfig().
WithHost("wss://s.altnet.rippletest.net:51233")) WithHost("wss://s.altnet.rippletest.net:51233"))
// Disconnect the client when done. (Defer executes at the end of the function) // Disconnect the client when done. (Defer executes at the end of the function)
defer client.Disconnect() defer client.Disconnect()
// Connect to the network // Connect to the network
if err := client.Connect(); err != nil { if err := client.Connect(); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
// ... custom code goes here // ... custom code goes here
} }

94
_code-samples/get-started/go/get-acc-info/rpc/main.go
View File

@@ -1,59 +1,59 @@
package main package main
import ( import (
"fmt" "fmt"
"github.com/Peersyst/xrpl-go/pkg/crypto" "github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet" "github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/queries/account" "github.com/Peersyst/xrpl-go/xrpl/queries/account"
"github.com/Peersyst/xrpl-go/xrpl/queries/common" "github.com/Peersyst/xrpl-go/xrpl/queries/common"
"github.com/Peersyst/xrpl-go/xrpl/queries/ledger" "github.com/Peersyst/xrpl-go/xrpl/queries/ledger"
"github.com/Peersyst/xrpl-go/xrpl/rpc" "github.com/Peersyst/xrpl-go/xrpl/rpc"
"github.com/Peersyst/xrpl-go/xrpl/wallet" "github.com/Peersyst/xrpl-go/xrpl/wallet"
) )
func main() { func main() {
// Define the network client with a faucet provider // Define the network client with a faucet provider
cfg, err := rpc.NewClientConfig( cfg, err := rpc.NewClientConfig(
"https://s.altnet.rippletest.net:51234/", "https://s.altnet.rippletest.net:51234/",
rpc.WithFaucetProvider(faucet.NewTestnetFaucetProvider()), rpc.WithFaucetProvider(faucet.NewTestnetFaucetProvider()),
) )
if err != nil { if err != nil {
panic(err) panic(err)
} }
client := rpc.NewClient(cfg) client := rpc.NewClient(cfg)
// Create a new wallet // Create a new wallet
w, err := wallet.New(crypto.ED25519()) w, err := wallet.New(crypto.ED25519())
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("New wallet created:") fmt.Println("New wallet created:")
fmt.Println("Address:", w.ClassicAddress) fmt.Println("Address:", w.ClassicAddress)
// Fund the wallet with testnet XRP // Fund the wallet with testnet XRP
if err := client.FundWallet(&w); err != nil { if err := client.FundWallet(&w); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
// Get info from the ledger about the address we just funded // Get info from the ledger about the address we just funded
acc_info, err := client.GetAccountInfo(&account.InfoRequest{ acc_info, err := client.GetAccountInfo(&account.InfoRequest{
Account: w.GetAddress(), Account: w.GetAddress(),
}) })
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("Account Balance:", acc_info.AccountData.Balance) fmt.Println("Account Balance:", acc_info.AccountData.Balance)
fmt.Println("Account Sequence:", acc_info.AccountData.Sequence) fmt.Println("Account Sequence:", acc_info.AccountData.Sequence)
// Get info about the ledger // Get info about the ledger
ledger, err := client.GetLedger(&ledger.Request{LedgerIndex: common.Current}) ledger, err := client.GetLedger(&ledger.Request{LedgerIndex: common.Current})
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("Ledger Index:", ledger.Ledger.LedgerIndex) fmt.Println("Ledger Index:", ledger.Ledger.LedgerIndex)
} }

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

@@ -1,74 +1,74 @@
package main package main
import ( import (
"fmt" "fmt"
"github.com/Peersyst/xrpl-go/pkg/crypto" "github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet" "github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/queries/account" "github.com/Peersyst/xrpl-go/xrpl/queries/account"
"github.com/Peersyst/xrpl-go/xrpl/queries/common" "github.com/Peersyst/xrpl-go/xrpl/queries/common"
"github.com/Peersyst/xrpl-go/xrpl/queries/ledger" "github.com/Peersyst/xrpl-go/xrpl/queries/ledger"
"github.com/Peersyst/xrpl-go/xrpl/wallet" "github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/xrpl/websocket" "github.com/Peersyst/xrpl-go/xrpl/websocket"
) )
func main() { func main() {
// Define the network client with a faucet provider // Define the network client with a faucet provider
client := websocket.NewClient( client := websocket.NewClient(
websocket.NewClientConfig(). websocket.NewClientConfig().
WithHost("wss://s.altnet.rippletest.net:51233"). WithHost("wss://s.altnet.rippletest.net:51233").
WithFaucetProvider(faucet.NewTestnetFaucetProvider()), WithFaucetProvider(faucet.NewTestnetFaucetProvider()),
) )
// Disconnect the client when done. (Defer executes at the end of the function) // Disconnect the client when done. (Defer executes at the end of the function)
defer client.Disconnect() defer client.Disconnect()
// Connect to the network // Connect to the network
if err := client.Connect(); err != nil { if err := client.Connect(); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
if !client.IsConnected() { if !client.IsConnected() {
fmt.Println("❌ Failed to connect to testnet") fmt.Println("❌ Failed to connect to testnet")
return return
} }
fmt.Println("✅ Connected to testnet") fmt.Println("✅ Connected to testnet")
fmt.Println() fmt.Println()
// Create a new wallet // Create a new wallet
w, err := wallet.New(crypto.ED25519()) w, err := wallet.New(crypto.ED25519())
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("New wallet created:") fmt.Println("New wallet created:")
fmt.Println("Address:", w.ClassicAddress) fmt.Println("Address:", w.ClassicAddress)
// Fund the wallet with testnet XRP // Fund the wallet with testnet XRP
if err := client.FundWallet(&w); err != nil { if err := client.FundWallet(&w); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
// Get info from the ledger about the address we just funded // Get info from the ledger about the address we just funded
acc_info, err := client.GetAccountInfo(&account.InfoRequest{ acc_info, err := client.GetAccountInfo(&account.InfoRequest{
Account: w.GetAddress(), Account: w.GetAddress(),
}) })
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("Account Balance:", acc_info.AccountData.Balance) fmt.Println("Account Balance:", acc_info.AccountData.Balance)
fmt.Println("Account Sequence:", acc_info.AccountData.Sequence) fmt.Println("Account Sequence:", acc_info.AccountData.Sequence)
// Get info about the ledger // Get info about the ledger
ledger, err := client.GetLedger(&ledger.Request{LedgerIndex: common.Current}) ledger, err := client.GetLedger(&ledger.Request{LedgerIndex: common.Current})
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("Ledger Index:", ledger.Ledger.LedgerIndex) fmt.Println("Ledger Index:", ledger.Ledger.LedgerIndex)
} }

68
_code-samples/get-tx/go/main.go
View File

@@ -1,46 +1,46 @@
package main package main
import ( import (
"fmt" "fmt"
"github.com/Peersyst/xrpl-go/xrpl/queries/common" "github.com/Peersyst/xrpl-go/xrpl/queries/common"
"github.com/Peersyst/xrpl-go/xrpl/queries/ledger" "github.com/Peersyst/xrpl-go/xrpl/queries/ledger"
"github.com/Peersyst/xrpl-go/xrpl/queries/transactions" "github.com/Peersyst/xrpl-go/xrpl/queries/transactions"
"github.com/Peersyst/xrpl-go/xrpl/rpc" "github.com/Peersyst/xrpl-go/xrpl/rpc"
) )
func main() { func main() {
cfg, err := rpc.NewClientConfig( cfg, err := rpc.NewClientConfig(
"https://s.altnet.rippletest.net:51234/", "https://s.altnet.rippletest.net:51234/",
) )
if err != nil { if err != nil {
panic(err) panic(err)
} }
client := rpc.NewClient(cfg) client := rpc.NewClient(cfg)
// Get the latest validated ledger // Get the latest validated ledger
led, err := client.GetLedger(&ledger.Request{ led, err := client.GetLedger(&ledger.Request{
Transactions: true, Transactions: true,
LedgerIndex: common.Validated, LedgerIndex: common.Validated,
}) })
if err != nil { if err != nil {
panic(err) panic(err)
} }
fmt.Println("Latest validated ledger:", led) fmt.Println("Latest validated ledger:", led)
// Get the first transaction hash from the ledger // Get the first transaction hash from the ledger
if len(led.Ledger.Transactions) > 0 { if len(led.Ledger.Transactions) > 0 {
txHash := led.Ledger.Transactions[0].(string) // type assertion may be needed txHash := led.Ledger.Transactions[0].(string) // type assertion may be needed
// Query the transaction details // Query the transaction details
txResp, err := client.Request(&transactions.TxRequest{ txResp, err := client.Request(&transactions.TxRequest{
Transaction: txHash, Transaction: txHash,
}) })
if err != nil { if err != nil {
panic(err) panic(err)
} }
fmt.Println("First transaction in the ledger:") fmt.Println("First transaction in the ledger:")
fmt.Println(txResp) fmt.Println(txResp)
} }
} }

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

File diff suppressed because it is too large Load Diff

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

File diff suppressed because it is too large Load Diff

132
_code-samples/monitor-payments-websocket/go/monitor-incoming-payments.go
View File

@@ -7,15 +7,15 @@ package main
// install: go get github.com/gorilla/websocket // install: go get github.com/gorilla/websocket
import ( import (
"encoding/json" "encoding/json"
"flag" "flag"
"log" "log"
"net/url" "net/url"
"os" "os"
"os/signal" "os/signal"
"time" "time"
"github.com/gorilla/websocket" "github.com/gorilla/websocket"
) )
// websocket address // websocket address
@@ -23,75 +23,75 @@ var addr = flag.String("addr", "s.altnet.rippletest.net:51233", "http service ad
// Payload object // Payload object
type message struct { type message struct {
Command string `json:"command"` Command string `json:"command"`
Accounts []string `json:"accounts"` Accounts []string `json:"accounts"`
} }
func main() { func main() {
flag.Parse() flag.Parse()
log.SetFlags(0) log.SetFlags(0)
var m message var m message
// check for interrupts and cleanly close the connection // check for interrupts and cleanly close the connection
interrupt := make(chan os.Signal, 1) interrupt := make(chan os.Signal, 1)
signal.Notify(interrupt, os.Interrupt) signal.Notify(interrupt, os.Interrupt)
u := url.URL{Scheme: "ws", Host: *addr, Path: "/"} u := url.URL{Scheme: "ws", Host: *addr, Path: "/"}
log.Printf("connecting to %s", u.String()) log.Printf("connecting to %s", u.String())
// make the connection // make the connection
c, _, err := websocket.DefaultDialer.Dial(u.String(), nil) c, _, err := websocket.DefaultDialer.Dial(u.String(), nil)
if err != nil { if err != nil {
log.Fatal("dial:", err) log.Fatal("dial:", err)
} }
// on exit close // on exit close
defer c.Close() defer c.Close()
done := make(chan struct{}) done := make(chan struct{})
// send a subscribe command and a target XRPL account // send a subscribe command and a target XRPL account
m.Command = "subscribe" m.Command = "subscribe"
m.Accounts = append(m.Accounts, "rUCzEr6jrEyMpjhs4wSdQdz4g8Y382NxfM") m.Accounts = append(m.Accounts, "rUCzEr6jrEyMpjhs4wSdQdz4g8Y382NxfM")
// struct to JSON marshalling // struct to JSON marshalling
msg, _ := json.Marshal(m) msg, _ := json.Marshal(m)
// write to the websocket // write to the websocket
err = c.WriteMessage(websocket.TextMessage, []byte(string(msg))) err = c.WriteMessage(websocket.TextMessage, []byte(string(msg)))
if err != nil { if err != nil {
log.Println("write:", err) log.Println("write:", err)
return return
} }
// read from the websocket // read from the websocket
_, message, err := c.ReadMessage() _, message, err := c.ReadMessage()
if err != nil { if err != nil {
log.Println("read:", err) log.Println("read:", err)
return return
} }
// print the response from the XRP Ledger // print the response from the XRP Ledger
log.Printf("recv: %s", message) log.Printf("recv: %s", message)
// handle interrupt // handle interrupt
for { for {
select { select {
case <-done: case <-done:
return return
case <-interrupt: case <-interrupt:
log.Println("interrupt") log.Println("interrupt")
// Cleanly close the connection by sending a close message and then // Cleanly close the connection by sending a close message and then
// waiting (with timeout) for the server to close the connection. // waiting (with timeout) for the server to close the connection.
err := c.WriteMessage(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseNormalClosure, "")) err := c.WriteMessage(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseNormalClosure, ""))
if err != nil { if err != nil {
log.Println("write close:", err) log.Println("write close:", err)
return return
} }
select { select {
case <-done: case <-done:
case <-time.After(time.Second): case <-time.After(time.Second):
} }
return return
} }
} }
} }

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

@@ -1,166 +1,166 @@
package main package main
import ( import (
"encoding/hex" "encoding/hex"
"fmt" "fmt"
"maps" "maps"
"strings" "strings"
"github.com/Peersyst/xrpl-go/xrpl" "github.com/Peersyst/xrpl-go/xrpl"
"github.com/Peersyst/xrpl-go/xrpl/faucet" "github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/ledger-entry-types" "github.com/Peersyst/xrpl-go/xrpl/ledger-entry-types"
"github.com/Peersyst/xrpl-go/xrpl/rpc" "github.com/Peersyst/xrpl-go/xrpl/rpc"
"github.com/Peersyst/xrpl-go/xrpl/transaction" "github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types" "github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet" "github.com/Peersyst/xrpl-go/xrpl/wallet"
) )
func main() { func main() {
cfg, err := rpc.NewClientConfig( cfg, err := rpc.NewClientConfig(
"https://s.altnet.rippletest.net:51234/", "https://s.altnet.rippletest.net:51234/",
rpc.WithFaucetProvider(faucet.NewTestnetFaucetProvider()), rpc.WithFaucetProvider(faucet.NewTestnetFaucetProvider()),
) )
if err != nil { if err != nil {
panic(err) panic(err)
} }
client := rpc.NewClient(cfg) client := rpc.NewClient(cfg)
w1, err := wallet.FromSeed("sEdTtvLmJmrb7GaivhWoXRkvU4NDjVf", "") w1, err := wallet.FromSeed("sEdTtvLmJmrb7GaivhWoXRkvU4NDjVf", "")
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
w2, err := wallet.FromSeed("sEdSFiKMQp7RvYLgH7t7FEpwNRWv2Gr", "") w2, err := wallet.FromSeed("sEdSFiKMQp7RvYLgH7t7FEpwNRWv2Gr", "")
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
master, err := wallet.FromSeed("sEdTMm2yv8c8Rg8YHFHQA9TxVMFy1ze", "") master, err := wallet.FromSeed("sEdTMm2yv8c8Rg8YHFHQA9TxVMFy1ze", "")
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("⏳ Funding wallets...") fmt.Println("⏳ Funding wallets...")
if err := client.FundWallet(&w1); err != nil { if err := client.FundWallet(&w1); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("💸 Wallet 1 funded") fmt.Println("💸 Wallet 1 funded")
if err := client.FundWallet(&w2); err != nil { if err := client.FundWallet(&w2); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("💸 Wallet 2 funded") fmt.Println("💸 Wallet 2 funded")
if err := client.FundWallet(&master); err != nil { if err := client.FundWallet(&master); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("💸 Master wallet funded") fmt.Println("💸 Master wallet funded")
fmt.Println() fmt.Println()
fmt.Println("⏳ Setting up signer list...") fmt.Println("⏳ Setting up signer list...")
ss := &transaction.SignerListSet{ ss := &transaction.SignerListSet{
BaseTx: transaction.BaseTx{ BaseTx: transaction.BaseTx{
Account: master.GetAddress(), Account: master.GetAddress(),
}, },
SignerQuorum: uint32(2), SignerQuorum: uint32(2),
SignerEntries: []ledger.SignerEntryWrapper{ SignerEntries: []ledger.SignerEntryWrapper{
{ {
SignerEntry: ledger.SignerEntry{ SignerEntry: ledger.SignerEntry{
Account: w1.GetAddress(), Account: w1.GetAddress(),
SignerWeight: 1, SignerWeight: 1,
}, },
}, },
{ {
SignerEntry: ledger.SignerEntry{ SignerEntry: ledger.SignerEntry{
Account: w2.GetAddress(), Account: w2.GetAddress(),
SignerWeight: 1, SignerWeight: 1,
}, },
}, },
{ {
SignerEntry: ledger.SignerEntry{ SignerEntry: ledger.SignerEntry{
Account: "XVYRdEocC28DRx94ZFGP3qNJ1D5Ln7ecXFMd3vREB5Pesju", Account: "XVYRdEocC28DRx94ZFGP3qNJ1D5Ln7ecXFMd3vREB5Pesju",
SignerWeight: 1, SignerWeight: 1,
}, },
}, },
}, },
} }
flatSs := ss.Flatten() flatSs := ss.Flatten()
if err := client.Autofill(&flatSs); err != nil { if err := client.Autofill(&flatSs); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
blob, _, err := master.Sign(flatSs) blob, _, err := master.Sign(flatSs)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
res, err := client.SubmitTxBlobAndWait(blob, false) res, err := client.SubmitTxBlobAndWait(blob, false)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("✅ SignerListSet transaction submitted!") fmt.Println("✅ SignerListSet transaction submitted!")
fmt.Printf("🌐 Hash: %s\n", res.Hash.String()) fmt.Printf("🌐 Hash: %s\n", res.Hash.String())
fmt.Println() fmt.Println()
fmt.Println("⏳ Setting up AccountSet multisign transaction...") fmt.Println("⏳ Setting up AccountSet multisign transaction...")
as := &transaction.AccountSet{ as := &transaction.AccountSet{
BaseTx: transaction.BaseTx{ BaseTx: transaction.BaseTx{
Account: master.GetAddress(), Account: master.GetAddress(),
}, },
Domain: types.Domain(strings.ToUpper(hex.EncodeToString([]byte("example.com")))), Domain: types.Domain(strings.ToUpper(hex.EncodeToString([]byte("example.com")))),
} }
flatAs := as.Flatten() flatAs := as.Flatten()
if err := client.AutofillMultisigned(&flatAs, 2); err != nil { if err := client.AutofillMultisigned(&flatAs, 2); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
w1As := maps.Clone(flatAs) w1As := maps.Clone(flatAs)
blob1, _, err := w1.Multisign(w1As) blob1, _, err := w1.Multisign(w1As)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
w2As := maps.Clone(flatAs) w2As := maps.Clone(flatAs)
blob2, _, err := w2.Multisign(w2As) blob2, _, err := w2.Multisign(w2As)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
blob, err = xrpl.Multisign(blob1, blob2) blob, err = xrpl.Multisign(blob1, blob2)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
mRes, err := client.SubmitMultisigned(blob, false) mRes, err := client.SubmitMultisigned(blob, false)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("✅ Multisigned transaction submitted!") fmt.Println("✅ Multisigned transaction submitted!")
fmt.Printf("🌐 Result: %s\n", mRes.EngineResult) fmt.Printf("🌐 Result: %s\n", mRes.EngineResult)
} }

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

@@ -1,181 +1,181 @@
package main package main
import ( import (
"encoding/hex" "encoding/hex"
"fmt" "fmt"
"maps" "maps"
"strings" "strings"
"github.com/Peersyst/xrpl-go/xrpl" "github.com/Peersyst/xrpl-go/xrpl"
"github.com/Peersyst/xrpl-go/xrpl/faucet" "github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/ledger-entry-types" "github.com/Peersyst/xrpl-go/xrpl/ledger-entry-types"
"github.com/Peersyst/xrpl-go/xrpl/transaction" "github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types" "github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet" "github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/xrpl/websocket" "github.com/Peersyst/xrpl-go/xrpl/websocket"
) )
func main() { func main() {
fmt.Println("⏳ Connecting to testnet...") fmt.Println("⏳ Connecting to testnet...")
client := websocket.NewClient( client := websocket.NewClient(
websocket.NewClientConfig(). websocket.NewClientConfig().
WithHost("wss://s.altnet.rippletest.net:51233"). WithHost("wss://s.altnet.rippletest.net:51233").
WithFaucetProvider(faucet.NewTestnetFaucetProvider()), WithFaucetProvider(faucet.NewTestnetFaucetProvider()),
) )
defer client.Disconnect() defer client.Disconnect()
if err := client.Connect(); err != nil { if err := client.Connect(); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
if !client.IsConnected() { if !client.IsConnected() {
fmt.Println("❌ Failed to connect to testnet") fmt.Println("❌ Failed to connect to testnet")
return return
} }
fmt.Println("✅ Connected to testnet") fmt.Println("✅ Connected to testnet")
fmt.Println() fmt.Println()
w1, err := wallet.FromSeed("sEdTtvLmJmrb7GaivhWoXRkvU4NDjVf", "") w1, err := wallet.FromSeed("sEdTtvLmJmrb7GaivhWoXRkvU4NDjVf", "")
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
w2, err := wallet.FromSeed("sEdSFiKMQp7RvYLgH7t7FEpwNRWv2Gr", "") w2, err := wallet.FromSeed("sEdSFiKMQp7RvYLgH7t7FEpwNRWv2Gr", "")
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
master, err := wallet.FromSeed("sEdTMm2yv8c8Rg8YHFHQA9TxVMFy1ze", "") master, err := wallet.FromSeed("sEdTMm2yv8c8Rg8YHFHQA9TxVMFy1ze", "")
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("⏳ Funding wallets...") fmt.Println("⏳ Funding wallets...")
if err := client.FundWallet(&w1); err != nil { if err := client.FundWallet(&w1); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("💸 Wallet 1 funded") fmt.Println("💸 Wallet 1 funded")
if err := client.FundWallet(&w2); err != nil { if err := client.FundWallet(&w2); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("💸 Wallet 2 funded") fmt.Println("💸 Wallet 2 funded")
if err := client.FundWallet(&master); err != nil { if err := client.FundWallet(&master); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("💸 Master wallet funded") fmt.Println("💸 Master wallet funded")
fmt.Println() fmt.Println()
fmt.Println("⏳ Setting up signer list...") fmt.Println("⏳ Setting up signer list...")
ss := &transaction.SignerListSet{ ss := &transaction.SignerListSet{
BaseTx: transaction.BaseTx{ BaseTx: transaction.BaseTx{
Account: master.GetAddress(), Account: master.GetAddress(),
}, },
SignerQuorum: uint32(2), SignerQuorum: uint32(2),
SignerEntries: []ledger.SignerEntryWrapper{ SignerEntries: []ledger.SignerEntryWrapper{
{ {
SignerEntry: ledger.SignerEntry{ SignerEntry: ledger.SignerEntry{
Account: w1.GetAddress(), Account: w1.GetAddress(),
SignerWeight: 1, SignerWeight: 1,
}, },
}, },
{ {
SignerEntry: ledger.SignerEntry{ SignerEntry: ledger.SignerEntry{
Account: w2.GetAddress(), Account: w2.GetAddress(),
SignerWeight: 1, SignerWeight: 1,
}, },
}, },
{ {
SignerEntry: ledger.SignerEntry{ SignerEntry: ledger.SignerEntry{
Account: "XVYRdEocC28DRx94ZFGP3qNJ1D5Ln7ecXFMd3vREB5Pesju", Account: "XVYRdEocC28DRx94ZFGP3qNJ1D5Ln7ecXFMd3vREB5Pesju",
SignerWeight: 1, SignerWeight: 1,
}, },
}, },
}, },
} }
fmt.Println("⏳ Flattening transaction...") fmt.Println("⏳ Flattening transaction...")
flatSs := ss.Flatten() flatSs := ss.Flatten()
fmt.Println("⏳ Autofilling transaction...") fmt.Println("⏳ Autofilling transaction...")
if err := client.Autofill(&flatSs); err != nil { if err := client.Autofill(&flatSs); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("⏳ Signing transaction...") fmt.Println("⏳ Signing transaction...")
blob, _, err := master.Sign(flatSs) blob, _, err := master.Sign(flatSs)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("⏳ Submitting transaction...") fmt.Println("⏳ Submitting transaction...")
res, err := client.SubmitTxBlobAndWait(blob, false) res, err := client.SubmitTxBlobAndWait(blob, false)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("✅ SignerListSet transaction submitted!") fmt.Println("✅ SignerListSet transaction submitted!")
fmt.Printf("🌐 Hash: %s\n", res.Hash.String()) fmt.Printf("🌐 Hash: %s\n", res.Hash.String())
fmt.Println() fmt.Println()
fmt.Println("⏳ Setting up AccountSet multisign transaction...") fmt.Println("⏳ Setting up AccountSet multisign transaction...")
as := &transaction.AccountSet{ as := &transaction.AccountSet{
BaseTx: transaction.BaseTx{ BaseTx: transaction.BaseTx{
Account: master.GetAddress(), Account: master.GetAddress(),
}, },
Domain: types.Domain(strings.ToUpper(hex.EncodeToString([]byte("example.com")))), Domain: types.Domain(strings.ToUpper(hex.EncodeToString([]byte("example.com")))),
} }
flatAs := as.Flatten() flatAs := as.Flatten()
if err := client.AutofillMultisigned(&flatAs, 2); err != nil { if err := client.AutofillMultisigned(&flatAs, 2); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
w1As := maps.Clone(flatAs) w1As := maps.Clone(flatAs)
blob1, _, err := w1.Multisign(w1As) blob1, _, err := w1.Multisign(w1As)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
w2As := maps.Clone(flatAs) w2As := maps.Clone(flatAs)
blob2, _, err := w2.Multisign(w2As) blob2, _, err := w2.Multisign(w2As)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
blob, err = xrpl.Multisign(blob1, blob2) blob, err = xrpl.Multisign(blob1, blob2)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
mRes, err := client.SubmitMultisigned(blob, false) mRes, err := client.SubmitMultisigned(blob, false)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("✅ Multisigned transaction submitted!") fmt.Println("✅ Multisigned transaction submitted!")
fmt.Printf("🌐 Result: %s\n", mRes.EngineResult) fmt.Printf("🌐 Result: %s\n", mRes.EngineResult)
} }

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

@@ -1,128 +1,128 @@
package main package main
import ( import (
"fmt" "fmt"
"github.com/Peersyst/xrpl-go/pkg/crypto" "github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet" "github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/rpc" "github.com/Peersyst/xrpl-go/xrpl/rpc"
"github.com/Peersyst/xrpl-go/xrpl/rpc/types" "github.com/Peersyst/xrpl-go/xrpl/rpc/types"
"github.com/Peersyst/xrpl-go/xrpl/transaction" "github.com/Peersyst/xrpl-go/xrpl/transaction"
txnTypes "github.com/Peersyst/xrpl-go/xrpl/transaction/types" txnTypes "github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet" "github.com/Peersyst/xrpl-go/xrpl/wallet"
) )
func main() { func main() {
// Initialize the RPC client configuration // Initialize the RPC client configuration
cfg, err := rpc.NewClientConfig( cfg, err := rpc.NewClientConfig(
"https://s.devnet.rippletest.net:51234/", "https://s.devnet.rippletest.net:51234/",
rpc.WithFaucetProvider(faucet.NewDevnetFaucetProvider()), rpc.WithFaucetProvider(faucet.NewDevnetFaucetProvider()),
) )
if err != nil { if err != nil {
panic(err) panic(err)
} }
// Create the RPC client // Create the RPC client
client := rpc.NewClient(cfg) client := rpc.NewClient(cfg)
// Step 1: Fund wallets // Step 1: Fund wallets
fmt.Println("⏳ Funding wallets...") fmt.Println("⏳ Funding wallets...")
// Create and fund the NFT minter wallet // Create and fund the NFT minter wallet
nftMinter, err := wallet.New(crypto.ED25519()) nftMinter, err := wallet.New(crypto.ED25519())
if err != nil { if err != nil {
fmt.Println("❌ Error creating NFT minter wallet:", err) fmt.Println("❌ Error creating NFT minter wallet:", err)
return return
} }
if err := client.FundWallet(&nftMinter); err != nil { if err := client.FundWallet(&nftMinter); err != nil {
fmt.Println("❌ Error funding NFT minter wallet:", err) fmt.Println("❌ Error funding NFT minter wallet:", err)
return return
} }
fmt.Println("💸 NFT minter wallet funded!") fmt.Println("💸 NFT minter wallet funded!")
// Create and fund the NFT buyer wallet // Create and fund the NFT buyer wallet
nftBuyer, err := wallet.New(crypto.ED25519()) nftBuyer, err := wallet.New(crypto.ED25519())
if err != nil { if err != nil {
fmt.Println("❌ Error creating NFT buyer wallet:", err) fmt.Println("❌ Error creating NFT buyer wallet:", err)
return return
} }
if err := client.FundWallet(&nftBuyer); err != nil { if err := client.FundWallet(&nftBuyer); err != nil {
fmt.Println("❌ Error funding NFT buyer wallet:", err) fmt.Println("❌ Error funding NFT buyer wallet:", err)
return return
} }
fmt.Println("💸 NFT buyer wallet funded!") fmt.Println("💸 NFT buyer wallet funded!")
fmt.Println() fmt.Println()
// Step 2: Mint an NFT // Step 2: Mint an NFT
fmt.Println("⏳ Minting NFT...") fmt.Println("⏳ Minting NFT...")
nftMint := transaction.NFTokenMint{ nftMint := transaction.NFTokenMint{
BaseTx: transaction.BaseTx{ BaseTx: transaction.BaseTx{
Account: nftMinter.ClassicAddress, Account: nftMinter.ClassicAddress,
TransactionType: transaction.NFTokenMintTx, TransactionType: transaction.NFTokenMintTx,
}, },
Destination: nftBuyer.ClassicAddress, Destination: nftBuyer.ClassicAddress,
Amount: txnTypes.XRPCurrencyAmount(1000000), // 1 XRP Amount: txnTypes.XRPCurrencyAmount(1000000), // 1 XRP
NFTokenTaxon: 0, NFTokenTaxon: 0,
URI: txnTypes.NFTokenURI("68747470733A2F2F676F6F676C652E636F6D"), // https://google.com URI: txnTypes.NFTokenURI("68747470733A2F2F676F6F676C652E636F6D"), // https://google.com
} }
nftMint.SetTransferableFlag() nftMint.SetTransferableFlag()
responseMint, err := client.SubmitTxAndWait(nftMint.Flatten(), &types.SubmitOptions{ responseMint, err := client.SubmitTxAndWait(nftMint.Flatten(), &types.SubmitOptions{
Autofill: true, Autofill: true,
Wallet: &nftMinter, Wallet: &nftMinter,
}) })
if err != nil { if err != nil {
fmt.Println("❌ Error minting NFT:", err) fmt.Println("❌ Error minting NFT:", err)
return return
} }
if !responseMint.Validated { if !responseMint.Validated {
fmt.Println("❌ NFTokenMint txn is not in a validated ledger", responseMint) fmt.Println("❌ NFTokenMint txn is not in a validated ledger", responseMint)
return return
} }
fmt.Println("✅ NFT minted successfully! - 🌎 Hash: ", responseMint.Hash) fmt.Println("✅ NFT minted successfully! - 🌎 Hash: ", responseMint.Hash)
fmt.Println() fmt.Println()
// Step 3: Retrieve the NFT token offer ID // Step 3: Retrieve the NFT token offer ID
fmt.Println("⏳ Retrieving NFT offer ID...") fmt.Println("⏳ Retrieving NFT offer ID...")
metaMap, ok := responseMint.Meta.(map[string]any) metaMap, ok := responseMint.Meta.(map[string]any)
if !ok { if !ok {
fmt.Println("❌ Meta is not a map[string]any") fmt.Println("❌ Meta is not a map[string]any")
return return
} }
offerID, ok := metaMap["offer_id"].(string) offerID, ok := metaMap["offer_id"].(string)
if !ok { if !ok {
fmt.Println("❌ offer_id not found or not a string") fmt.Println("❌ offer_id not found or not a string")
return return
} }
fmt.Println("🌎 offer_id:", offerID) fmt.Println("🌎 offer_id:", offerID)
fmt.Println() fmt.Println()
// Step 4: Accept the NFT offer // Step 4: Accept the NFT offer
fmt.Println("⏳ Accepting NFT offer...") fmt.Println("⏳ Accepting NFT offer...")
nftAccept := transaction.NFTokenAcceptOffer{ nftAccept := transaction.NFTokenAcceptOffer{
BaseTx: transaction.BaseTx{ BaseTx: transaction.BaseTx{
Account: nftBuyer.ClassicAddress, Account: nftBuyer.ClassicAddress,
TransactionType: transaction.NFTokenAcceptOfferTx, TransactionType: transaction.NFTokenAcceptOfferTx,
}, },
NFTokenSellOffer: txnTypes.Hash256(offerID), NFTokenSellOffer: txnTypes.Hash256(offerID),
} }
response, err := client.SubmitTxAndWait(nftAccept.Flatten(), &types.SubmitOptions{ response, err := client.SubmitTxAndWait(nftAccept.Flatten(), &types.SubmitOptions{
Autofill: true, Autofill: true,
Wallet: &nftBuyer, Wallet: &nftBuyer,
}) })
if err != nil { if err != nil {
fmt.Println("❌ Error accepting NFT offer:", err) fmt.Println("❌ Error accepting NFT offer:", err)
return return
} }
if !response.Validated { if !response.Validated {
fmt.Println("❌ NFTokenAcceptOffer txn is not in a validated ledger", response) fmt.Println("❌ NFTokenAcceptOffer txn is not in a validated ledger", response)
return return
} }
fmt.Println("✅ NFT offer accepted successfully! - 🌎 Hash: ", response.Hash) fmt.Println("✅ NFT offer accepted successfully! - 🌎 Hash: ", response.Hash)
} }

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

@@ -1,133 +1,133 @@
package main package main
import ( import (
"fmt" "fmt"
"github.com/Peersyst/xrpl-go/pkg/crypto" "github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet" "github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/transaction" "github.com/Peersyst/xrpl-go/xrpl/transaction"
txnTypes "github.com/Peersyst/xrpl-go/xrpl/transaction/types" txnTypes "github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet" "github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/xrpl/websocket" "github.com/Peersyst/xrpl-go/xrpl/websocket"
"github.com/Peersyst/xrpl-go/xrpl/websocket/types" "github.com/Peersyst/xrpl-go/xrpl/websocket/types"
) )
func main() { func main() {
// Connect to the XRPL devnet // Connect to the XRPL devnet
fmt.Println("⏳ Connecting to devnet...") fmt.Println("⏳ Connecting to devnet...")
client := websocket.NewClient( client := websocket.NewClient(
websocket.NewClientConfig(). websocket.NewClientConfig().
WithHost("wss://s.devnet.rippletest.net:51233"). WithHost("wss://s.devnet.rippletest.net:51233").
WithFaucetProvider(faucet.NewDevnetFaucetProvider()), WithFaucetProvider(faucet.NewDevnetFaucetProvider()),
) )
defer client.Disconnect() defer client.Disconnect()
if err := client.Connect(); err != nil { if err := client.Connect(); err != nil {
fmt.Println("❌ Error connecting to devnet:", err) fmt.Println("❌ Error connecting to devnet:", err)
return return
} }
if !client.IsConnected() { if !client.IsConnected() {
fmt.Println("❌ Failed to connect to devnet") fmt.Println("❌ Failed to connect to devnet")
return return
} }
fmt.Println("✅ Connected to devnet") fmt.Println("✅ Connected to devnet")
fmt.Println() fmt.Println()
// Fund wallets // Fund wallets
fmt.Println("⏳ Funding wallets...") fmt.Println("⏳ Funding wallets...")
// Create and fund the NFT minter wallet // Create and fund the NFT minter wallet
nftMinter, err := wallet.New(crypto.ED25519()) nftMinter, err := wallet.New(crypto.ED25519())
if err != nil { if err != nil {
fmt.Println("❌ Error creating NFT minter wallet:", err) fmt.Println("❌ Error creating NFT minter wallet:", err)
return return
} }
if err := client.FundWallet(&nftMinter); err != nil { if err := client.FundWallet(&nftMinter); err != nil {
fmt.Println("❌ Error funding NFT minter wallet:", err) fmt.Println("❌ Error funding NFT minter wallet:", err)
return return
} }
fmt.Println("💸 NFT minter wallet funded!") fmt.Println("💸 NFT minter wallet funded!")
// Create and fund the NFT buyer wallet // Create and fund the NFT buyer wallet
nftBuyer, err := wallet.New(crypto.ED25519()) nftBuyer, err := wallet.New(crypto.ED25519())
if err != nil { if err != nil {
fmt.Println("❌ Error creating NFT buyer wallet:", err) fmt.Println("❌ Error creating NFT buyer wallet:", err)
return return
} }
if err := client.FundWallet(&nftBuyer); err != nil { if err := client.FundWallet(&nftBuyer); err != nil {
fmt.Println("❌ Error funding NFT buyer wallet:", err) fmt.Println("❌ Error funding NFT buyer wallet:", err)
return return
} }
fmt.Println("💸 NFT buyer wallet funded!") fmt.Println("💸 NFT buyer wallet funded!")
fmt.Println() fmt.Println()
// Mint an NFT // Mint an NFT
fmt.Println("⏳ Minting NFT...") fmt.Println("⏳ Minting NFT...")
nftMint := transaction.NFTokenMint{ nftMint := transaction.NFTokenMint{
BaseTx: transaction.BaseTx{ BaseTx: transaction.BaseTx{
Account: nftMinter.ClassicAddress, Account: nftMinter.ClassicAddress,
TransactionType: transaction.NFTokenMintTx, TransactionType: transaction.NFTokenMintTx,
}, },
Destination: nftBuyer.ClassicAddress, Destination: nftBuyer.ClassicAddress,
Amount: txnTypes.XRPCurrencyAmount(1000000), // 1 XRP Amount: txnTypes.XRPCurrencyAmount(1000000), // 1 XRP
NFTokenTaxon: 0, NFTokenTaxon: 0,
URI: txnTypes.NFTokenURI("68747470733A2F2F676F6F676C652E636F6D"), // https://google.com URI: txnTypes.NFTokenURI("68747470733A2F2F676F6F676C652E636F6D"), // https://google.com
} }
nftMint.SetTransferableFlag() nftMint.SetTransferableFlag()
responseMint, err := client.SubmitTxAndWait(nftMint.Flatten(), &types.SubmitOptions{ responseMint, err := client.SubmitTxAndWait(nftMint.Flatten(), &types.SubmitOptions{
Autofill: true, Autofill: true,
Wallet: &nftMinter, Wallet: &nftMinter,
}) })
if err != nil { if err != nil {
fmt.Println("❌ Error minting NFT:", err) fmt.Println("❌ Error minting NFT:", err)
return return
} }
if !responseMint.Validated { if !responseMint.Validated {
fmt.Println("❌ NFTokenMint transaction is not in a validated ledger:", responseMint) fmt.Println("❌ NFTokenMint transaction is not in a validated ledger:", responseMint)
return return
} }
fmt.Println("✅ NFT minted successfully! - 🌎 Hash:", responseMint.Hash) fmt.Println("✅ NFT minted successfully! - 🌎 Hash:", responseMint.Hash)
fmt.Println() fmt.Println()
// Extract the NFT token offer ID from the transaction metadata // Extract the NFT token offer ID from the transaction metadata
fmt.Println("⏳ Extracting offer ID...") fmt.Println("⏳ Extracting offer ID...")
metaMap, ok := responseMint.Meta.(map[string]any) metaMap, ok := responseMint.Meta.(map[string]any)
if !ok { if !ok {
fmt.Println("❌ Meta is not a map[string]any") fmt.Println("❌ Meta is not a map[string]any")
return return
} }
offerID, ok := metaMap["offer_id"].(string) offerID, ok := metaMap["offer_id"].(string)
if !ok { if !ok {
fmt.Println("❌ offer_id not found or not a string") fmt.Println("❌ offer_id not found or not a string")
return return
} }
fmt.Println("🌎 offer_id:", offerID) fmt.Println("🌎 offer_id:", offerID)
fmt.Println() fmt.Println()
// Accept the NFT offer // Accept the NFT offer
fmt.Println("⏳ Accepting NFT offer...") fmt.Println("⏳ Accepting NFT offer...")
nftAccept := transaction.NFTokenAcceptOffer{ nftAccept := transaction.NFTokenAcceptOffer{
BaseTx: transaction.BaseTx{ BaseTx: transaction.BaseTx{
Account: nftBuyer.ClassicAddress, Account: nftBuyer.ClassicAddress,
TransactionType: transaction.NFTokenAcceptOfferTx, TransactionType: transaction.NFTokenAcceptOfferTx,
}, },
NFTokenSellOffer: txnTypes.Hash256(offerID), NFTokenSellOffer: txnTypes.Hash256(offerID),
} }
response, err := client.SubmitTxAndWait(nftAccept.Flatten(), &types.SubmitOptions{ response, err := client.SubmitTxAndWait(nftAccept.Flatten(), &types.SubmitOptions{
Autofill: true, Autofill: true,
Wallet: &nftBuyer, Wallet: &nftBuyer,
}) })
if err != nil { if err != nil {
fmt.Println("❌ Error accepting NFT offer:", err) fmt.Println("❌ Error accepting NFT offer:", err)
return return
} }
if !response.Validated { if !response.Validated {
fmt.Println("❌ NFTokenAcceptOffer transaction is not in a validated ledger:", response) fmt.Println("❌ NFTokenAcceptOffer transaction is not in a validated ledger:", response)
return return
} }
fmt.Println("✅ NFT offer accepted successfully! - 🌎 Hash:", response.Hash) fmt.Println("✅ NFT offer accepted successfully! - 🌎 Hash:", response.Hash)
} }

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

@@ -1,114 +1,114 @@
package main package main
import ( import (
"fmt" "fmt"
"github.com/Peersyst/xrpl-go/pkg/crypto" "github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet" "github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/rpc" "github.com/Peersyst/xrpl-go/xrpl/rpc"
"github.com/Peersyst/xrpl-go/xrpl/rpc/types" "github.com/Peersyst/xrpl-go/xrpl/rpc/types"
"github.com/Peersyst/xrpl-go/xrpl/transaction" "github.com/Peersyst/xrpl-go/xrpl/transaction"
txnTypes "github.com/Peersyst/xrpl-go/xrpl/transaction/types" txnTypes "github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet" "github.com/Peersyst/xrpl-go/xrpl/wallet"
) )
func main() { func main() {
// Initialize the RPC client configuration // Initialize the RPC client configuration
cfg, err := rpc.NewClientConfig( cfg, err := rpc.NewClientConfig(
"https://s.devnet.rippletest.net:51234/", "https://s.devnet.rippletest.net:51234/",
rpc.WithFaucetProvider(faucet.NewDevnetFaucetProvider()), rpc.WithFaucetProvider(faucet.NewDevnetFaucetProvider()),
) )
if err != nil { if err != nil {
panic(err) panic(err)
} }
// Create the RPC client // Create the RPC client
client := rpc.NewClient(cfg) client := rpc.NewClient(cfg)
// Step 1: Fund wallets // Step 1: Fund wallets
fmt.Println("⏳ Funding wallets...") fmt.Println("⏳ Funding wallets...")
// Create and fund the NFT minter wallet // Create and fund the NFT minter wallet
nftMinter, err := wallet.New(crypto.ED25519()) nftMinter, err := wallet.New(crypto.ED25519())
if err != nil { if err != nil {
fmt.Println("❌ Error creating NFT minter wallet:", err) fmt.Println("❌ Error creating NFT minter wallet:", err)
return return
} }
if err := client.FundWallet(&nftMinter); err != nil { if err := client.FundWallet(&nftMinter); err != nil {
fmt.Println("❌ Error funding NFT minter wallet:", err) fmt.Println("❌ Error funding NFT minter wallet:", err)
return return
} }
fmt.Println("💸 NFT minter wallet funded!") fmt.Println("💸 NFT minter wallet funded!")
fmt.Println() fmt.Println()
// Step 2: Mint an NFT // Step 2: Mint an NFT
fmt.Println("⏳ Minting NFT...") fmt.Println("⏳ Minting NFT...")
nftMint := transaction.NFTokenMint{ nftMint := transaction.NFTokenMint{
BaseTx: transaction.BaseTx{ BaseTx: transaction.BaseTx{
Account: nftMinter.ClassicAddress, Account: nftMinter.ClassicAddress,
TransactionType: transaction.NFTokenMintTx, TransactionType: transaction.NFTokenMintTx,
}, },
NFTokenTaxon: 0, NFTokenTaxon: 0,
URI: txnTypes.NFTokenURI("68747470733A2F2F676F6F676C652E636F6D"), // https://google.com URI: txnTypes.NFTokenURI("68747470733A2F2F676F6F676C652E636F6D"), // https://google.com
} }
nftMint.SetTransferableFlag() nftMint.SetTransferableFlag()
responseMint, err := client.SubmitTxAndWait(nftMint.Flatten(), &types.SubmitOptions{ responseMint, err := client.SubmitTxAndWait(nftMint.Flatten(), &types.SubmitOptions{
Autofill: true, Autofill: true,
Wallet: &nftMinter, Wallet: &nftMinter,
}) })
if err != nil { if err != nil {
fmt.Println("❌ Error minting NFT:", err) fmt.Println("❌ Error minting NFT:", err)
return return
} }
if !responseMint.Validated { if !responseMint.Validated {
fmt.Println("❌ NFTokenMint txn is not in a validated ledger", responseMint) fmt.Println("❌ NFTokenMint txn is not in a validated ledger", responseMint)
return return
} }
fmt.Println("✅ NFT minted successfully! - 🌎 Hash: ", responseMint.Hash) fmt.Println("✅ NFT minted successfully! - 🌎 Hash: ", responseMint.Hash)
fmt.Println() fmt.Println()
// Step 3: Retrieve the token ID // Step 3: Retrieve the token ID
fmt.Println("⏳ Retrieving NFT ID...") fmt.Println("⏳ Retrieving NFT ID...")
metaMap, ok := responseMint.Meta.(map[string]any) metaMap, ok := responseMint.Meta.(map[string]any)
if !ok { if !ok {
fmt.Println("❌ Meta is not a map[string]any") fmt.Println("❌ Meta is not a map[string]any")
return return
} }
nftokenID, ok := metaMap["nftoken_id"].(string) nftokenID, ok := metaMap["nftoken_id"].(string)
if !ok { if !ok {
fmt.Println("❌ nftoken_id not found or not a string") fmt.Println("❌ nftoken_id not found or not a string")
return return
} }
fmt.Println("🌎 nftoken_id:", nftokenID) fmt.Println("🌎 nftoken_id:", nftokenID)
fmt.Println() fmt.Println()
// Step 4: Burn the NFT // Step 4: Burn the NFT
fmt.Println("⏳ Burn the NFT...") fmt.Println("⏳ Burn the NFT...")
nftBurn := transaction.NFTokenBurn{ nftBurn := transaction.NFTokenBurn{
BaseTx: transaction.BaseTx{ BaseTx: transaction.BaseTx{
Account: nftMinter.ClassicAddress, Account: nftMinter.ClassicAddress,
TransactionType: transaction.NFTokenAcceptOfferTx, TransactionType: transaction.NFTokenAcceptOfferTx,
}, },
NFTokenID: txnTypes.NFTokenID(nftokenID), NFTokenID: txnTypes.NFTokenID(nftokenID),
} }
responseBurn, err := client.SubmitTxAndWait(nftBurn.Flatten(), &types.SubmitOptions{ responseBurn, err := client.SubmitTxAndWait(nftBurn.Flatten(), &types.SubmitOptions{
Autofill: true, Autofill: true,
Wallet: &nftMinter, Wallet: &nftMinter,
}) })
if err != nil { if err != nil {
fmt.Println("❌ Error burning NFT:", err) fmt.Println("❌ Error burning NFT:", err)
return return
} }
if !responseBurn.Validated { if !responseBurn.Validated {
fmt.Println("❌ NFTokenBurn transactiob is not in a validated ledger", responseBurn) fmt.Println("❌ NFTokenBurn transactiob is not in a validated ledger", responseBurn)
return return
} }
fmt.Println("✅ NFT burned successfully! - 🌎 Hash: ", responseBurn.Hash) fmt.Println("✅ NFT burned successfully! - 🌎 Hash: ", responseBurn.Hash)
} }

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

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

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

@@ -1,163 +1,163 @@
package main package main
import ( import (
"fmt" "fmt"
"github.com/Peersyst/xrpl-go/pkg/crypto" "github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet" "github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/rpc" "github.com/Peersyst/xrpl-go/xrpl/rpc"
"github.com/Peersyst/xrpl-go/xrpl/rpc/types" "github.com/Peersyst/xrpl-go/xrpl/rpc/types"
"github.com/Peersyst/xrpl-go/xrpl/transaction" "github.com/Peersyst/xrpl-go/xrpl/transaction"
txnTypes "github.com/Peersyst/xrpl-go/xrpl/transaction/types" txnTypes "github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet" "github.com/Peersyst/xrpl-go/xrpl/wallet"
) )
func main() { func main() {
// Initialize the RPC client configuration // Initialize the RPC client configuration
cfg, err := rpc.NewClientConfig( cfg, err := rpc.NewClientConfig(
"https://s.devnet.rippletest.net:51234/", "https://s.devnet.rippletest.net:51234/",
rpc.WithFaucetProvider(faucet.NewDevnetFaucetProvider()), rpc.WithFaucetProvider(faucet.NewDevnetFaucetProvider()),
) )
if err != nil { if err != nil {
panic(err) panic(err)
} }
// Create the RPC client // Create the RPC client
client := rpc.NewClient(cfg) client := rpc.NewClient(cfg)
// Step 1: Fund wallet // Step 1: Fund wallet
fmt.Println("⏳ Funding wallet...") fmt.Println("⏳ Funding wallet...")
// Create and fund the NFT minter wallet // Create and fund the NFT minter wallet
nftMinter, err := wallet.New(crypto.ED25519()) nftMinter, err := wallet.New(crypto.ED25519())
if err != nil { if err != nil {
fmt.Println("❌ Error creating NFT minter wallet:", err) fmt.Println("❌ Error creating NFT minter wallet:", err)
return return
} }
if err := client.FundWallet(&nftMinter); err != nil { if err := client.FundWallet(&nftMinter); err != nil {
fmt.Println("❌ Error funding NFT minter wallet:", err) fmt.Println("❌ Error funding NFT minter wallet:", err)
return return
} }
fmt.Println("💸 NFT minter wallet funded!") fmt.Println("💸 NFT minter wallet funded!")
// Step 2: Mint two NFTs // Step 2: Mint two NFTs
fmt.Println("⏳ Minting first NFT...") fmt.Println("⏳ Minting first NFT...")
nftMint := transaction.NFTokenMint{ nftMint := transaction.NFTokenMint{
BaseTx: transaction.BaseTx{ BaseTx: transaction.BaseTx{
Account: nftMinter.ClassicAddress, Account: nftMinter.ClassicAddress,
TransactionType: transaction.NFTokenMintTx, TransactionType: transaction.NFTokenMintTx,
}, },
NFTokenTaxon: 0, NFTokenTaxon: 0,
URI: txnTypes.NFTokenURI("68747470733A2F2F676F6F676C652E636F6D"), // https://google.com URI: txnTypes.NFTokenURI("68747470733A2F2F676F6F676C652E636F6D"), // https://google.com
} }
nftMint.SetTransferableFlag() nftMint.SetTransferableFlag()
responseMint, err := client.SubmitTxAndWait(nftMint.Flatten(), &types.SubmitOptions{ responseMint, err := client.SubmitTxAndWait(nftMint.Flatten(), &types.SubmitOptions{
Autofill: true, Autofill: true,
Wallet: &nftMinter, Wallet: &nftMinter,
}) })
if err != nil { if err != nil {
fmt.Println("❌ Error minting first NFT:", err) fmt.Println("❌ Error minting first NFT:", err)
return return
} }
if !responseMint.Validated { if !responseMint.Validated {
fmt.Println("❌ First NFTokenMint transaction is not in a validated ledger", responseMint) fmt.Println("❌ First NFTokenMint transaction is not in a validated ledger", responseMint)
return return
} }
fmt.Println("✅ First NFT minted successfully! - 🌎 Hash: ", responseMint.Hash) fmt.Println("✅ First NFT minted successfully! - 🌎 Hash: ", responseMint.Hash)
fmt.Println() fmt.Println()
// Step 3: Retrieve the NFT token ID // Step 3: Retrieve the NFT token ID
fmt.Println("⏳ Retrieving NFT ID...") fmt.Println("⏳ Retrieving NFT ID...")
metaMap, ok := responseMint.Meta.(map[string]any) metaMap, ok := responseMint.Meta.(map[string]any)
if !ok { if !ok {
fmt.Println("❌ Meta is not a map[string]any") fmt.Println("❌ Meta is not a map[string]any")
return return
} }
nftokenID1, ok := metaMap["nftoken_id"].(string) nftokenID1, ok := metaMap["nftoken_id"].(string)
if !ok { if !ok {
fmt.Println("❌ nftoken_id not found or not a string") fmt.Println("❌ nftoken_id not found or not a string")
return return
} }
fmt.Println("🌎 nftoken_id:", nftokenID1) fmt.Println("🌎 nftoken_id:", nftokenID1)
fmt.Println() fmt.Println()
// ------ // ------
fmt.Println("⏳ Minting second NFT...") fmt.Println("⏳ Minting second NFT...")
nftMint2 := transaction.NFTokenMint{ nftMint2 := transaction.NFTokenMint{
BaseTx: transaction.BaseTx{ BaseTx: transaction.BaseTx{
Account: nftMinter.ClassicAddress, Account: nftMinter.ClassicAddress,
TransactionType: transaction.NFTokenMintTx, TransactionType: transaction.NFTokenMintTx,
}, },
NFTokenTaxon: 0, NFTokenTaxon: 0,
URI: txnTypes.NFTokenURI("68747470733A2F2F676F6F676C652E636F6D"), // https://google.com URI: txnTypes.NFTokenURI("68747470733A2F2F676F6F676C652E636F6D"), // https://google.com
} }
nftMint2.SetTransferableFlag() nftMint2.SetTransferableFlag()
responseMint2, err := client.SubmitTxAndWait(nftMint2.Flatten(), &types.SubmitOptions{ responseMint2, err := client.SubmitTxAndWait(nftMint2.Flatten(), &types.SubmitOptions{
Autofill: true, Autofill: true,
Wallet: &nftMinter, Wallet: &nftMinter,
}) })
if err != nil { if err != nil {
fmt.Println("❌ Error minting second NFT:", err) fmt.Println("❌ Error minting second NFT:", err)
return return
} }
if !responseMint.Validated { if !responseMint.Validated {
fmt.Println("❌ Second NFTokenMint transaction is not in a validated ledger", responseMint) fmt.Println("❌ Second NFTokenMint transaction is not in a validated ledger", responseMint)
return return
} }
fmt.Println("✅ Second NFT minted successfully! - 🌎 Hash: ", responseMint.Hash) fmt.Println("✅ Second NFT minted successfully! - 🌎 Hash: ", responseMint.Hash)
fmt.Println() fmt.Println()
// Step 3: Retrieve the second NFT token ID // Step 3: Retrieve the second NFT token ID
fmt.Println("⏳ Retrieving second NFT ID...") fmt.Println("⏳ Retrieving second NFT ID...")
metaMap2, ok := responseMint2.Meta.(map[string]any) metaMap2, ok := responseMint2.Meta.(map[string]any)
if !ok { if !ok {
fmt.Println("❌ Meta is not a map[string]any") fmt.Println("❌ Meta is not a map[string]any")
return return
} }
nftokenID2, ok := metaMap2["nftoken_id"].(string) nftokenID2, ok := metaMap2["nftoken_id"].(string)
if !ok { if !ok {
fmt.Println("❌ nftoken_id not found or not a string") fmt.Println("❌ nftoken_id not found or not a string")
return return
} }
fmt.Println("🌎 nftoken_id:", nftokenID2) fmt.Println("🌎 nftoken_id:", nftokenID2)
fmt.Println() fmt.Println()
// Step 4: Cancel the NFT offers // Step 4: Cancel the NFT offers
fmt.Println("⏳ Canceling NFT offers...") fmt.Println("⏳ Canceling NFT offers...")
nftCancel := transaction.NFTokenCancelOffer{ nftCancel := transaction.NFTokenCancelOffer{
BaseTx: transaction.BaseTx{ BaseTx: transaction.BaseTx{
Account: nftMinter.ClassicAddress, Account: nftMinter.ClassicAddress,
TransactionType: transaction.NFTokenAcceptOfferTx, TransactionType: transaction.NFTokenAcceptOfferTx,
}, },
NFTokenOffers: []txnTypes.NFTokenID{ NFTokenOffers: []txnTypes.NFTokenID{
txnTypes.NFTokenID(nftokenID1), txnTypes.NFTokenID(nftokenID1),
txnTypes.NFTokenID(nftokenID2), txnTypes.NFTokenID(nftokenID2),
}, },
} }
response, err := client.SubmitTxAndWait(nftCancel.Flatten(), &types.SubmitOptions{ response, err := client.SubmitTxAndWait(nftCancel.Flatten(), &types.SubmitOptions{
Autofill: true, Autofill: true,
Wallet: &nftMinter, Wallet: &nftMinter,
}) })
if err != nil { if err != nil {
fmt.Println("❌ Error canceling NFT offers:", err) fmt.Println("❌ Error canceling NFT offers:", err)
return return
} }
if !response.Validated { if !response.Validated {
fmt.Println("❌ NFTokenCancelOffer transaction is not in a validated ledger", response) fmt.Println("❌ NFTokenCancelOffer transaction is not in a validated ledger", response)
return return
} }
fmt.Println("✅ NFT offers canceled successfully! - 🌎 Hash: ", response.Hash) fmt.Println("✅ NFT offers canceled successfully! - 🌎 Hash: ", response.Hash)
} }

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

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

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

@@ -1,107 +1,107 @@
package main package main
import ( import (
"fmt" "fmt"
"github.com/Peersyst/xrpl-go/pkg/crypto" "github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet" "github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/rpc" "github.com/Peersyst/xrpl-go/xrpl/rpc"
"github.com/Peersyst/xrpl-go/xrpl/rpc/types" "github.com/Peersyst/xrpl-go/xrpl/rpc/types"
"github.com/Peersyst/xrpl-go/xrpl/transaction" "github.com/Peersyst/xrpl-go/xrpl/transaction"
txnTypes "github.com/Peersyst/xrpl-go/xrpl/transaction/types" txnTypes "github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet" "github.com/Peersyst/xrpl-go/xrpl/wallet"
) )
func main() { func main() {
cfg, err := rpc.NewClientConfig( cfg, err := rpc.NewClientConfig(
"https://s.devnet.rippletest.net:51234/", "https://s.devnet.rippletest.net:51234/",
rpc.WithFaucetProvider(faucet.NewDevnetFaucetProvider()), rpc.WithFaucetProvider(faucet.NewDevnetFaucetProvider()),
) )
if err != nil { if err != nil {
panic(err) panic(err)
} }
client := rpc.NewClient(cfg) client := rpc.NewClient(cfg)
fmt.Println() fmt.Println()
fmt.Println("⏳ Funding wallet...") fmt.Println("⏳ Funding wallet...")
// Create and fund the nft wallet // Create and fund the nft wallet
nftWallet, err := wallet.New(crypto.ED25519()) nftWallet, err := wallet.New(crypto.ED25519())
if err != nil { if err != nil {
fmt.Println("❌ Error creating nft wallet:", err) fmt.Println("❌ Error creating nft wallet:", err)
return return
} }
if err := client.FundWallet(&nftWallet); err != nil { if err := client.FundWallet(&nftWallet); err != nil {
fmt.Println("❌ Error funding nft wallet:", err) fmt.Println("❌ Error funding nft wallet:", err)
return return
} }
fmt.Println("💸 NFT wallet funded! - #️⃣: ", nftWallet.ClassicAddress) fmt.Println("💸 NFT wallet funded! - #️⃣: ", nftWallet.ClassicAddress)
fmt.Println() fmt.Println()
// Mint NFT // Mint NFT
nftMint := transaction.NFTokenMint{ nftMint := transaction.NFTokenMint{
BaseTx: transaction.BaseTx{ BaseTx: transaction.BaseTx{
Account: nftWallet.ClassicAddress, Account: nftWallet.ClassicAddress,
TransactionType: transaction.NFTokenMintTx, TransactionType: transaction.NFTokenMintTx,
}, },
NFTokenTaxon: 0, NFTokenTaxon: 0,
URI: txnTypes.NFTokenURI("68747470733A2F2F676F6F676C652E636F6D"), // https://google.com URI: txnTypes.NFTokenURI("68747470733A2F2F676F6F676C652E636F6D"), // https://google.com
} }
nftMint.SetMutableFlag() nftMint.SetMutableFlag()
nftMint.SetTransferableFlag() nftMint.SetTransferableFlag()
responseMint, err := client.SubmitTxAndWait(nftMint.Flatten(), &types.SubmitOptions{ responseMint, err := client.SubmitTxAndWait(nftMint.Flatten(), &types.SubmitOptions{
Autofill: true, Autofill: true,
Wallet: &nftWallet, Wallet: &nftWallet,
}) })
if err != nil { if err != nil {
fmt.Println("❌ Error minting NFT:", err) fmt.Println("❌ Error minting NFT:", err)
return return
} }
if !responseMint.Validated { if !responseMint.Validated {
fmt.Println("❌ NFTokenMint txn is not in a validated ledger", responseMint) fmt.Println("❌ NFTokenMint txn is not in a validated ledger", responseMint)
return return
} }
fmt.Println("✅ NFT minted successfully! - 🌎 Hash: ", responseMint.Hash) fmt.Println("✅ NFT minted successfully! - 🌎 Hash: ", responseMint.Hash)
fmt.Println() fmt.Println()
metaMap, ok := responseMint.Meta.(map[string]any) metaMap, ok := responseMint.Meta.(map[string]any)
if !ok { if !ok {
fmt.Println("❌ Meta is not a map[string]any") fmt.Println("❌ Meta is not a map[string]any")
return return
} }
nftokenID, ok := metaMap["nftoken_id"].(string) nftokenID, ok := metaMap["nftoken_id"].(string)
if !ok { if !ok {
fmt.Println("❌ nftoken_id not found or not a string") fmt.Println("❌ nftoken_id not found or not a string")
return return
} }
fmt.Println("🌎 nftoken_id:", nftokenID) fmt.Println("🌎 nftoken_id:", nftokenID)
fmt.Println() fmt.Println()
// Update NFT // Update NFT
nftModify := transaction.NFTokenModify{ nftModify := transaction.NFTokenModify{
BaseTx: transaction.BaseTx{ BaseTx: transaction.BaseTx{
Account: nftWallet.ClassicAddress, Account: nftWallet.ClassicAddress,
TransactionType: transaction.NFTokenModifyTx, TransactionType: transaction.NFTokenModifyTx,
}, },
URI: "68747470733A2F2F7961686F6F2E636F6D", // https://yahoo.com URI: "68747470733A2F2F7961686F6F2E636F6D", // https://yahoo.com
NFTokenID: txnTypes.NFTokenID(nftokenID), NFTokenID: txnTypes.NFTokenID(nftokenID),
} }
// nftoken_id // nftoken_id
responseModify, err := client.SubmitTxAndWait(nftModify.Flatten(), &types.SubmitOptions{ responseModify, err := client.SubmitTxAndWait(nftModify.Flatten(), &types.SubmitOptions{
Autofill: true, Autofill: true,
Wallet: &nftWallet, Wallet: &nftWallet,
}) })
if err != nil { if err != nil {
fmt.Println("❌ Error modifying NFT:", err) fmt.Println("❌ Error modifying NFT:", err)
return return
} }
if !responseModify.Validated { if !responseModify.Validated {
fmt.Println("❌ NFTokenModify txn is not in a validated ledger", responseModify) fmt.Println("❌ NFTokenModify txn is not in a validated ledger", responseModify)
return return
} }
fmt.Println("✅ NFT URI modified successfully! - 🌎 Hash: ", responseModify.Hash) fmt.Println("✅ NFT URI modified successfully! - 🌎 Hash: ", responseModify.Hash)
} }

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

@@ -1,117 +1,117 @@
package main package main
import ( import (
"fmt" "fmt"
"github.com/Peersyst/xrpl-go/pkg/crypto" "github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet" "github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/transaction" "github.com/Peersyst/xrpl-go/xrpl/transaction"
txnTypes "github.com/Peersyst/xrpl-go/xrpl/transaction/types" txnTypes "github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet" "github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/xrpl/websocket" "github.com/Peersyst/xrpl-go/xrpl/websocket"
"github.com/Peersyst/xrpl-go/xrpl/websocket/types" "github.com/Peersyst/xrpl-go/xrpl/websocket/types"
) )
func main() { func main() {
fmt.Println("⏳ Connecting to devnet...") fmt.Println("⏳ Connecting to devnet...")
client := websocket.NewClient( client := websocket.NewClient(
websocket.NewClientConfig(). websocket.NewClientConfig().
WithHost("wss://s.devnet.rippletest.net:51233"). WithHost("wss://s.devnet.rippletest.net:51233").
WithFaucetProvider(faucet.NewDevnetFaucetProvider()), WithFaucetProvider(faucet.NewDevnetFaucetProvider()),
) )
defer client.Disconnect() defer client.Disconnect()
if err := client.Connect(); err != nil { if err := client.Connect(); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
if !client.IsConnected() { if !client.IsConnected() {
fmt.Println("❌ Failed to connect to devnet") fmt.Println("❌ Failed to connect to devnet")
return return
} }
fmt.Println("✅ Connected to devnet") fmt.Println("✅ Connected to devnet")
fmt.Println() fmt.Println()
// Create and fund the nft wallet // Create and fund the nft wallet
fmt.Println("⏳ Funding wallet...") fmt.Println("⏳ Funding wallet...")
nftWallet, err := wallet.New(crypto.ED25519()) nftWallet, err := wallet.New(crypto.ED25519())
if err != nil { if err != nil {
fmt.Println("❌ Error creating nft wallet:", err) fmt.Println("❌ Error creating nft wallet:", err)
return return
} }
if err := client.FundWallet(&nftWallet); err != nil { if err := client.FundWallet(&nftWallet); err != nil {
fmt.Println("❌ Error funding nft wallet:", err) fmt.Println("❌ Error funding nft wallet:", err)
return return
} }
fmt.Println("💸 NFT wallet funded!") fmt.Println("💸 NFT wallet funded!")
fmt.Println() fmt.Println()
// Mint NFT // Mint NFT
nftMint := transaction.NFTokenMint{ nftMint := transaction.NFTokenMint{
BaseTx: transaction.BaseTx{ BaseTx: transaction.BaseTx{
Account: nftWallet.ClassicAddress, Account: nftWallet.ClassicAddress,
TransactionType: transaction.NFTokenMintTx, TransactionType: transaction.NFTokenMintTx,
}, },
NFTokenTaxon: 0, NFTokenTaxon: 0,
URI: txnTypes.NFTokenURI("68747470733A2F2F676F6F676C652E636F6D"), // https://google.com URI: txnTypes.NFTokenURI("68747470733A2F2F676F6F676C652E636F6D"), // https://google.com
} }
nftMint.SetMutableFlag() nftMint.SetMutableFlag()
nftMint.SetTransferableFlag() nftMint.SetTransferableFlag()
responseMint, err := client.SubmitTxAndWait(nftMint.Flatten(), &types.SubmitOptions{ responseMint, err := client.SubmitTxAndWait(nftMint.Flatten(), &types.SubmitOptions{
Autofill: true, Autofill: true,
Wallet: &nftWallet, Wallet: &nftWallet,
}) })
if err != nil { if err != nil {
fmt.Println("❌ Error minting NFT:", err) fmt.Println("❌ Error minting NFT:", err)
return return
} }
if !responseMint.Validated { if !responseMint.Validated {
fmt.Println("❌ NFTokenMint txn is not in a validated ledger", responseMint) fmt.Println("❌ NFTokenMint txn is not in a validated ledger", responseMint)
return return
} }
fmt.Println("✅ NFT minted successfully! - 🌎 Hash: ", responseMint.Hash) fmt.Println("✅ NFT minted successfully! - 🌎 Hash: ", responseMint.Hash)
fmt.Println() fmt.Println()
metaMap, ok := responseMint.Meta.(map[string]any) metaMap, ok := responseMint.Meta.(map[string]any)
if !ok { if !ok {
fmt.Println("❌ Meta is not a map[string]any") fmt.Println("❌ Meta is not a map[string]any")
return return
} }
nftokenID, ok := metaMap["nftoken_id"].(string) nftokenID, ok := metaMap["nftoken_id"].(string)
if !ok { if !ok {
fmt.Println("❌ nftoken_id not found or not a string") fmt.Println("❌ nftoken_id not found or not a string")
return return
} }
fmt.Println("🌎 nftoken_id:", nftokenID) fmt.Println("🌎 nftoken_id:", nftokenID)
fmt.Println() fmt.Println()
// Update NFT // Update NFT
nftModify := transaction.NFTokenModify{ nftModify := transaction.NFTokenModify{
BaseTx: transaction.BaseTx{ BaseTx: transaction.BaseTx{
Account: nftWallet.ClassicAddress, Account: nftWallet.ClassicAddress,
TransactionType: transaction.NFTokenModifyTx, TransactionType: transaction.NFTokenModifyTx,
}, },
URI: "68747470733A2F2F7961686F6F2E636F6D", // https://yahoo.com URI: "68747470733A2F2F7961686F6F2E636F6D", // https://yahoo.com
NFTokenID: txnTypes.NFTokenID(nftokenID), NFTokenID: txnTypes.NFTokenID(nftokenID),
} }
responseModify, err := client.SubmitTxAndWait(nftModify.Flatten(), &types.SubmitOptions{ responseModify, err := client.SubmitTxAndWait(nftModify.Flatten(), &types.SubmitOptions{
Autofill: true, Autofill: true,
Wallet: &nftWallet, Wallet: &nftWallet,
}) })
if err != nil { if err != nil {
fmt.Println("❌ Error modifying NFT:", err) fmt.Println("❌ Error modifying NFT:", err)
return return
} }
if !responseModify.Validated { if !responseModify.Validated {
fmt.Println("❌ NFTokenModify txn is not in a validated ledger", responseModify) fmt.Println("❌ NFTokenModify txn is not in a validated ledger", responseModify)
return return
} }
fmt.Println("✅ NFT URI modified successfully! - 🌎 Hash: ", responseModify.Hash) fmt.Println("✅ NFT URI modified successfully! - 🌎 Hash: ", responseModify.Hash)
} }

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

@@ -1,168 +1,168 @@
package main package main
import ( import (
"fmt" "fmt"
"time" "time"
"github.com/Peersyst/xrpl-go/pkg/crypto" "github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet" "github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/rpc" "github.com/Peersyst/xrpl-go/xrpl/rpc"
"github.com/Peersyst/xrpl-go/xrpl/transaction" "github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types" "github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet" "github.com/Peersyst/xrpl-go/xrpl/wallet"
) )
func main() { func main() {
cfg, err := rpc.NewClientConfig( cfg, err := rpc.NewClientConfig(
"https://s.altnet.rippletest.net:51234/", "https://s.altnet.rippletest.net:51234/",
rpc.WithFaucetProvider(faucet.NewTestnetFaucetProvider()), rpc.WithFaucetProvider(faucet.NewTestnetFaucetProvider()),
) )
if err != nil { if err != nil {
panic(err) panic(err)
} }
client := rpc.NewClient(cfg) client := rpc.NewClient(cfg)
fmt.Println("⏳ Funding wallets...") fmt.Println("⏳ Funding wallets...")
w1, err := wallet.New(crypto.ED25519()) w1, err := wallet.New(crypto.ED25519())
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
w2, err := wallet.New(crypto.ED25519()) w2, err := wallet.New(crypto.ED25519())
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
if err := client.FundWallet(&w1); err != nil { if err := client.FundWallet(&w1); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("💸 Wallet 1 funded") fmt.Println("💸 Wallet 1 funded")
if err := client.FundWallet(&w2); err != nil { if err := client.FundWallet(&w2); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("💸 Wallet 2 funded") fmt.Println("💸 Wallet 2 funded")
fmt.Println() fmt.Println()
time.Sleep(5 * time.Second) time.Sleep(5 * time.Second)
fmt.Println("⏳ Sending TrustSet transaction...") fmt.Println("⏳ Sending TrustSet transaction...")
ts := &transaction.TrustSet{ ts := &transaction.TrustSet{
BaseTx: transaction.BaseTx{ BaseTx: transaction.BaseTx{
Account: w2.ClassicAddress, Account: w2.ClassicAddress,
}, },
LimitAmount: types.IssuedCurrencyAmount{ LimitAmount: types.IssuedCurrencyAmount{
Currency: "FOO", Currency: "FOO",
Issuer: w1.ClassicAddress, Issuer: w1.ClassicAddress,
Value: "10000000000", Value: "10000000000",
}, },
} }
flatTs := ts.Flatten() flatTs := ts.Flatten()
err = client.Autofill(&flatTs) err = client.Autofill(&flatTs)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
blob, _, err := w2.Sign(flatTs) blob, _, err := w2.Sign(flatTs)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
res, err := client.SubmitTxBlobAndWait(blob, false) res, err := client.SubmitTxBlobAndWait(blob, false)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("✅ TrustSet transaction submitted!") fmt.Println("✅ TrustSet transaction submitted!")
fmt.Printf("🌐 Hash: %s\n", res.Hash.String()) fmt.Printf("🌐 Hash: %s\n", res.Hash.String())
fmt.Printf("🌐 Validated: %t\n", res.Validated) fmt.Printf("🌐 Validated: %t\n", res.Validated)
fmt.Println() fmt.Println()
fmt.Println("⏳ Issuing tokens for wallet 2...") fmt.Println("⏳ Issuing tokens for wallet 2...")
p := &transaction.Payment{ p := &transaction.Payment{
BaseTx: transaction.BaseTx{ BaseTx: transaction.BaseTx{
Account: w1.GetAddress(), Account: w1.GetAddress(),
}, },
Amount: types.IssuedCurrencyAmount{ Amount: types.IssuedCurrencyAmount{
Currency: "FOO", Currency: "FOO",
Issuer: w1.GetAddress(), Issuer: w1.GetAddress(),
Value: "50", Value: "50",
}, },
Destination: w2.GetAddress(), Destination: w2.GetAddress(),
} }
flatP := p.Flatten() flatP := p.Flatten()
err = client.Autofill(&flatP) err = client.Autofill(&flatP)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
blob, _, err = w1.Sign(flatP) blob, _, err = w1.Sign(flatP)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
res, err = client.SubmitTxBlobAndWait(blob, false) res, err = client.SubmitTxBlobAndWait(blob, false)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("✅ Payment transaction submitted!") fmt.Println("✅ Payment transaction submitted!")
fmt.Printf("🌐 Hash: %s\n", res.Hash.String()) fmt.Printf("🌐 Hash: %s\n", res.Hash.String())
fmt.Printf("🌐 Validated: %t\n", res.Validated) fmt.Printf("🌐 Validated: %t\n", res.Validated)
fmt.Println() fmt.Println()
fmt.Println("⏳ Submitting Partial Payment transaction...") fmt.Println("⏳ Submitting Partial Payment transaction...")
pp := &transaction.Payment{ pp := &transaction.Payment{
BaseTx: transaction.BaseTx{ BaseTx: transaction.BaseTx{
Account: w2.GetAddress(), Account: w2.GetAddress(),
}, },
Amount: types.IssuedCurrencyAmount{ Amount: types.IssuedCurrencyAmount{
Currency: "FOO", Currency: "FOO",
Issuer: w1.GetAddress(), Issuer: w1.GetAddress(),
Value: "10", Value: "10",
}, },
Destination: w1.GetAddress(), Destination: w1.GetAddress(),
} }
pp.SetPartialPaymentFlag() pp.SetPartialPaymentFlag()
flatPP := pp.Flatten() flatPP := pp.Flatten()
err = client.Autofill(&flatPP) err = client.Autofill(&flatPP)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
blob, _, err = w2.Sign(flatPP) blob, _, err = w2.Sign(flatPP)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
res, err = client.SubmitTxBlobAndWait(blob, false) res, err = client.SubmitTxBlobAndWait(blob, false)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("✅ Partial Payment transaction submitted!") fmt.Println("✅ Partial Payment transaction submitted!")
fmt.Printf("🌐 Hash: %s\n", res.Hash.String()) fmt.Printf("🌐 Hash: %s\n", res.Hash.String())
fmt.Printf("🌐 Validated: %t\n", res.Validated) fmt.Printf("🌐 Validated: %t\n", res.Validated)
fmt.Println() fmt.Println()
} }

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

@@ -1,179 +1,179 @@
package main package main
import ( import (
"fmt" "fmt"
"time" "time"
"github.com/Peersyst/xrpl-go/pkg/crypto" "github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet" "github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/transaction" "github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types" "github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet" "github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/xrpl/websocket" "github.com/Peersyst/xrpl-go/xrpl/websocket"
) )
func main() { func main() {
fmt.Println("⏳ Connecting to testnet...") fmt.Println("⏳ Connecting to testnet...")
client := websocket.NewClient( client := websocket.NewClient(
websocket.NewClientConfig(). websocket.NewClientConfig().
WithHost("wss://s.altnet.rippletest.net:51233"). WithHost("wss://s.altnet.rippletest.net:51233").
WithFaucetProvider(faucet.NewTestnetFaucetProvider()), WithFaucetProvider(faucet.NewTestnetFaucetProvider()),
) )
defer client.Disconnect() defer client.Disconnect()
if err := client.Connect(); err != nil { if err := client.Connect(); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
if !client.IsConnected() { if !client.IsConnected() {
fmt.Println("❌ Failed to connect to testnet") fmt.Println("❌ Failed to connect to testnet")
return return
} }
fmt.Println("✅ Connected to testnet") fmt.Println("✅ Connected to testnet")
fmt.Println() fmt.Println()
fmt.Println("⏳ Funding wallets...") fmt.Println("⏳ Funding wallets...")
w1, err := wallet.New(crypto.ED25519()) w1, err := wallet.New(crypto.ED25519())
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
w2, err := wallet.New(crypto.ED25519()) w2, err := wallet.New(crypto.ED25519())
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
if err := client.FundWallet(&w1); err != nil { if err := client.FundWallet(&w1); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("💸 Wallet 1 funded") fmt.Println("💸 Wallet 1 funded")
if err := client.FundWallet(&w2); err != nil { if err := client.FundWallet(&w2); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("💸 Wallet 2 funded") fmt.Println("💸 Wallet 2 funded")
fmt.Println() fmt.Println()
time.Sleep(5 * time.Second) time.Sleep(5 * time.Second)
fmt.Println("⏳ Sending TrustSet transaction...") fmt.Println("⏳ Sending TrustSet transaction...")
ts := &transaction.TrustSet{ ts := &transaction.TrustSet{
BaseTx: transaction.BaseTx{ BaseTx: transaction.BaseTx{
Account: w2.ClassicAddress, Account: w2.ClassicAddress,
}, },
LimitAmount: types.IssuedCurrencyAmount{ LimitAmount: types.IssuedCurrencyAmount{
Currency: "FOO", Currency: "FOO",
Issuer: w1.ClassicAddress, Issuer: w1.ClassicAddress,
Value: "10000000000", Value: "10000000000",
}, },
} }
flatTs := ts.Flatten() flatTs := ts.Flatten()
err = client.Autofill(&flatTs) err = client.Autofill(&flatTs)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
blob, _, err := w2.Sign(flatTs) blob, _, err := w2.Sign(flatTs)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
res, err := client.SubmitTxBlobAndWait(blob, false) res, err := client.SubmitTxBlobAndWait(blob, false)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("✅ TrustSet transaction submitted!") fmt.Println("✅ TrustSet transaction submitted!")
fmt.Printf("🌐 Hash: %s\n", res.Hash.String()) fmt.Printf("🌐 Hash: %s\n", res.Hash.String())
fmt.Printf("🌐 Validated: %t\n", res.Validated) fmt.Printf("🌐 Validated: %t\n", res.Validated)
fmt.Println() fmt.Println()
fmt.Println("⏳ Issuing tokens for wallet 2...") fmt.Println("⏳ Issuing tokens for wallet 2...")
p := &transaction.Payment{ p := &transaction.Payment{
BaseTx: transaction.BaseTx{ BaseTx: transaction.BaseTx{
Account: w1.GetAddress(), Account: w1.GetAddress(),
}, },
Amount: types.IssuedCurrencyAmount{ Amount: types.IssuedCurrencyAmount{
Currency: "FOO", Currency: "FOO",
Issuer: w1.GetAddress(), Issuer: w1.GetAddress(),
Value: "50", Value: "50",
}, },
Destination: w2.GetAddress(), Destination: w2.GetAddress(),
} }
flatP := p.Flatten() flatP := p.Flatten()
err = client.Autofill(&flatP) err = client.Autofill(&flatP)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
blob, _, err = w1.Sign(flatP) blob, _, err = w1.Sign(flatP)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
res, err = client.SubmitTxBlobAndWait(blob, false) res, err = client.SubmitTxBlobAndWait(blob, false)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("✅ Payment transaction submitted!") fmt.Println("✅ Payment transaction submitted!")
fmt.Printf("🌐 Hash: %s\n", res.Hash.String()) fmt.Printf("🌐 Hash: %s\n", res.Hash.String())
fmt.Printf("🌐 Validated: %t\n", res.Validated) fmt.Printf("🌐 Validated: %t\n", res.Validated)
fmt.Println() fmt.Println()
fmt.Println("⏳ Submitting Partial Payment transaction...") fmt.Println("⏳ Submitting Partial Payment transaction...")
pp := &transaction.Payment{ pp := &transaction.Payment{
BaseTx: transaction.BaseTx{ BaseTx: transaction.BaseTx{
Account: w2.GetAddress(), Account: w2.GetAddress(),
}, },
Amount: types.IssuedCurrencyAmount{ Amount: types.IssuedCurrencyAmount{
Currency: "FOO", Currency: "FOO",
Issuer: w1.GetAddress(), Issuer: w1.GetAddress(),
Value: "10", Value: "10",
}, },
Destination: w1.GetAddress(), Destination: w1.GetAddress(),
} }
pp.SetPartialPaymentFlag() pp.SetPartialPaymentFlag()
flatPP := pp.Flatten() flatPP := pp.Flatten()
err = client.Autofill(&flatPP) err = client.Autofill(&flatPP)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
blob, _, err = w2.Sign(flatPP) blob, _, err = w2.Sign(flatPP)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
res, err = client.SubmitTxBlobAndWait(blob, false) res, err = client.SubmitTxBlobAndWait(blob, false)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("✅ Partial Payment transaction submitted!") fmt.Println("✅ Partial Payment transaction submitted!")
fmt.Printf("🌐 Hash: %s\n", res.Hash.String()) fmt.Printf("🌐 Hash: %s\n", res.Hash.String())
fmt.Printf("🌐 Validated: %t\n", res.Validated) fmt.Printf("🌐 Validated: %t\n", res.Validated)
fmt.Println() fmt.Println()
} }

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

@@ -1,111 +1,111 @@
package main package main
import ( import (
"fmt" "fmt"
"github.com/Peersyst/xrpl-go/pkg/crypto" "github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet" "github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/queries/path" "github.com/Peersyst/xrpl-go/xrpl/queries/path"
"github.com/Peersyst/xrpl-go/xrpl/rpc" "github.com/Peersyst/xrpl-go/xrpl/rpc"
"github.com/Peersyst/xrpl-go/xrpl/transaction" "github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types" "github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet" "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 ( const (
DestinationAccount = types.Address("rKT4JX4cCof6LcDYRz8o3rGRu7qxzZ2Zwj") DestinationAccount = types.Address("rKT4JX4cCof6LcDYRz8o3rGRu7qxzZ2Zwj")
) )
var ( var (
DestinationAmount = types.IssuedCurrencyAmount{ DestinationAmount = types.IssuedCurrencyAmount{
Issuer: "rVnYNK9yuxBz4uP8zC8LEFokM2nqH3poc", Issuer: "rVnYNK9yuxBz4uP8zC8LEFokM2nqH3poc",
Currency: "USD", Currency: "USD",
Value: "0.001", Value: "0.001",
} }
) )
func main() { func main() {
cfg, err := rpc.NewClientConfig( cfg, err := rpc.NewClientConfig(
"https://s.altnet.rippletest.net:51234/", "https://s.altnet.rippletest.net:51234/",
rpc.WithFaucetProvider(faucet.NewTestnetFaucetProvider()), rpc.WithFaucetProvider(faucet.NewTestnetFaucetProvider()),
) )
if err != nil { if err != nil {
panic(err) panic(err)
} }
client := rpc.NewClient(cfg) client := rpc.NewClient(cfg)
wallet, err := wallet.New(crypto.ED25519()) wallet, err := wallet.New(crypto.ED25519())
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("⏳ Funding wallet...") fmt.Println("⏳ Funding wallet...")
if err := client.FundWallet(&wallet); err != nil { if err := client.FundWallet(&wallet); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("💸 Wallet funded") fmt.Println("💸 Wallet funded")
fmt.Println() fmt.Println()
fmt.Println("⏳ Getting paths...") fmt.Println("⏳ Getting paths...")
res, err := client.GetRipplePathFind(&path.RipplePathFindRequest{ res, err := client.GetRipplePathFind(&path.RipplePathFindRequest{
SourceAccount: wallet.GetAddress(), SourceAccount: wallet.GetAddress(),
SourceCurrencies: []pathtypes.RipplePathFindCurrency{ SourceCurrencies: []pathtypes.RipplePathFindCurrency{
{ {
Currency: "XRP", Currency: "XRP",
}, },
}, },
DestinationAccount: DestinationAccount, DestinationAccount: DestinationAccount,
DestinationAmount: DestinationAmount, DestinationAmount: DestinationAmount,
}) })
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Printf("🌐 Computed paths: %d\n", len(res.Alternatives)) fmt.Printf("🌐 Computed paths: %d\n", len(res.Alternatives))
fmt.Println() fmt.Println()
if len(res.Alternatives) == 0 { if len(res.Alternatives) == 0 {
fmt.Println("❌ No alternatives found") fmt.Println("❌ No alternatives found")
return return
} }
fmt.Println("⏳ Submitting Payment through path: ", res.Alternatives[0].PathsComputed) fmt.Println("⏳ Submitting Payment through path: ", res.Alternatives[0].PathsComputed)
p := &transaction.Payment{ p := &transaction.Payment{
BaseTx: transaction.BaseTx{ BaseTx: transaction.BaseTx{
Account: wallet.GetAddress(), Account: wallet.GetAddress(),
}, },
Destination: DestinationAccount, Destination: DestinationAccount,
Amount: DestinationAmount, Amount: DestinationAmount,
Paths: res.Alternatives[0].PathsComputed, Paths: res.Alternatives[0].PathsComputed,
} }
flatP := p.Flatten() flatP := p.Flatten()
if err := client.Autofill(&flatP); err != nil { if err := client.Autofill(&flatP); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
blob, hash, err := wallet.Sign(flatP) blob, hash, err := wallet.Sign(flatP)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
txRes, err := client.SubmitTxBlobAndWait(blob, false) txRes, err := client.SubmitTxBlobAndWait(blob, false)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("✅ Payment submitted") fmt.Println("✅ Payment submitted")
fmt.Printf("🌐 Hash: %s\n", hash) fmt.Printf("🌐 Hash: %s\n", hash)
fmt.Printf("🌐 Validated: %t\n", txRes.Validated) fmt.Printf("🌐 Validated: %t\n", txRes.Validated)
} }

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

@@ -1,122 +1,122 @@
package main package main
import ( import (
"fmt" "fmt"
"github.com/Peersyst/xrpl-go/pkg/crypto" "github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet" "github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/queries/path" "github.com/Peersyst/xrpl-go/xrpl/queries/path"
"github.com/Peersyst/xrpl-go/xrpl/transaction" "github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types" "github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet" "github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/xrpl/websocket" "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 ( const (
DestinationAccount = types.Address("rKT4JX4cCof6LcDYRz8o3rGRu7qxzZ2Zwj") DestinationAccount = types.Address("rKT4JX4cCof6LcDYRz8o3rGRu7qxzZ2Zwj")
) )
var ( var (
DestinationAmount = types.IssuedCurrencyAmount{ DestinationAmount = types.IssuedCurrencyAmount{
Issuer: "rVnYNK9yuxBz4uP8zC8LEFokM2nqH3poc", Issuer: "rVnYNK9yuxBz4uP8zC8LEFokM2nqH3poc",
Currency: "USD", Currency: "USD",
Value: "0.001", Value: "0.001",
} }
) )
func main() { func main() {
fmt.Println("⏳ Connecting to testnet...") fmt.Println("⏳ Connecting to testnet...")
client := websocket.NewClient( client := websocket.NewClient(
websocket.NewClientConfig(). websocket.NewClientConfig().
WithHost("wss://s.altnet.rippletest.net:51233"). WithHost("wss://s.altnet.rippletest.net:51233").
WithFaucetProvider(faucet.NewTestnetFaucetProvider()), WithFaucetProvider(faucet.NewTestnetFaucetProvider()),
) )
defer client.Disconnect() defer client.Disconnect()
if err := client.Connect(); err != nil { if err := client.Connect(); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
if !client.IsConnected() { if !client.IsConnected() {
fmt.Println("❌ Failed to connect to testnet") fmt.Println("❌ Failed to connect to testnet")
return return
} }
fmt.Println("✅ Connected to testnet") fmt.Println("✅ Connected to testnet")
fmt.Println() fmt.Println()
wallet, err := wallet.New(crypto.ED25519()) wallet, err := wallet.New(crypto.ED25519())
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("⏳ Funding wallet...") fmt.Println("⏳ Funding wallet...")
if err := client.FundWallet(&wallet); err != nil { if err := client.FundWallet(&wallet); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("💸 Wallet funded") fmt.Println("💸 Wallet funded")
fmt.Println() fmt.Println()
fmt.Println("⏳ Getting paths...") fmt.Println("⏳ Getting paths...")
res, err := client.GetRipplePathFind(&path.RipplePathFindRequest{ res, err := client.GetRipplePathFind(&path.RipplePathFindRequest{
SourceAccount: wallet.GetAddress(), SourceAccount: wallet.GetAddress(),
SourceCurrencies: []pathtypes.RipplePathFindCurrency{ SourceCurrencies: []pathtypes.RipplePathFindCurrency{
{ {
Currency: "XRP", Currency: "XRP",
}, },
}, },
DestinationAccount: DestinationAccount, DestinationAccount: DestinationAccount,
DestinationAmount: DestinationAmount, DestinationAmount: DestinationAmount,
}) })
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Printf("🌐 Computed paths: %d\n", len(res.Alternatives)) fmt.Printf("🌐 Computed paths: %d\n", len(res.Alternatives))
fmt.Println() fmt.Println()
if len(res.Alternatives) == 0 { if len(res.Alternatives) == 0 {
fmt.Println("❌ No alternatives found") fmt.Println("❌ No alternatives found")
return return
} }
fmt.Println("⏳ Submitting Payment through path: ", res.Alternatives[0].PathsComputed) fmt.Println("⏳ Submitting Payment through path: ", res.Alternatives[0].PathsComputed)
p := &transaction.Payment{ p := &transaction.Payment{
BaseTx: transaction.BaseTx{ BaseTx: transaction.BaseTx{
Account: wallet.GetAddress(), Account: wallet.GetAddress(),
}, },
Destination: DestinationAccount, Destination: DestinationAccount,
Amount: DestinationAmount, Amount: DestinationAmount,
Paths: res.Alternatives[0].PathsComputed, Paths: res.Alternatives[0].PathsComputed,
} }
flatP := p.Flatten() flatP := p.Flatten()
if err := client.Autofill(&flatP); err != nil { if err := client.Autofill(&flatP); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
blob, hash, err := wallet.Sign(flatP) blob, hash, err := wallet.Sign(flatP)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
txRes, err := client.SubmitTxBlobAndWait(blob, false) txRes, err := client.SubmitTxBlobAndWait(blob, false)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("✅ Payment submitted") fmt.Println("✅ Payment submitted")
fmt.Printf("🌐 Hash: %s\n", hash) fmt.Printf("🌐 Hash: %s\n", hash)
fmt.Printf("🌐 Validated: %t\n", txRes.Validated) fmt.Printf("🌐 Validated: %t\n", txRes.Validated)
} }

58
_code-samples/secure-signing/go/main.go
View File

@@ -1,42 +1,42 @@
package main package main
import ( import (
"fmt" "fmt"
"github.com/Peersyst/xrpl-go/pkg/crypto" "github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/transaction" "github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types" "github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet" "github.com/Peersyst/xrpl-go/xrpl/wallet"
) )
func main() { func main() {
w, err := wallet.New(crypto.ED25519()) w, err := wallet.New(crypto.ED25519())
if err != nil { if err != nil {
panic(err) panic(err)
} }
p := &transaction.Payment{ p := &transaction.Payment{
BaseTx: transaction.BaseTx{ BaseTx: transaction.BaseTx{
Account: types.Address(w.GetAddress()), Account: types.Address(w.GetAddress()),
Fee: types.XRPCurrencyAmount(13), Fee: types.XRPCurrencyAmount(13),
Sequence: 1, Sequence: 1,
Flags: 2147483648, Flags: 2147483648,
LastLedgerSequence: 7835923, LastLedgerSequence: 7835923,
}, },
Destination: "rPT1Sjq2YGrBMTttX4GZHjKu9dyfzbpAYe", Destination: "rPT1Sjq2YGrBMTttX4GZHjKu9dyfzbpAYe",
Amount: types.XRPCurrencyAmount(10000), Amount: types.XRPCurrencyAmount(10000),
DeliverMax: 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) signedTx, txHash, err := w.Sign(flattenedTx)
if err != nil { if err != nil {
panic(err) panic(err)
} }
fmt.Println("Transaction signed successfully:", signedTx) fmt.Println("Transaction signed successfully:", signedTx)
fmt.Println("Transaction hash:", txHash) fmt.Println("Transaction hash:", txHash)
} }

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

@@ -1,115 +1,115 @@
package main package main
import ( import (
"encoding/hex" "encoding/hex"
"fmt" "fmt"
"strconv" "strconv"
"github.com/Peersyst/xrpl-go/xrpl/currency" "github.com/Peersyst/xrpl-go/xrpl/currency"
"github.com/Peersyst/xrpl-go/xrpl/faucet" "github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/rpc" "github.com/Peersyst/xrpl-go/xrpl/rpc"
transactions "github.com/Peersyst/xrpl-go/xrpl/transaction" transactions "github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types" "github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet" "github.com/Peersyst/xrpl-go/xrpl/wallet"
) )
func main() { func main() {
w, err := wallet.FromSeed("sEdSMVV4dJ1JbdBxmakRR4Puu3XVZz2", "") w, err := wallet.FromSeed("sEdSMVV4dJ1JbdBxmakRR4Puu3XVZz2", "")
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
receiverWallet, err := wallet.FromSeed("sEd7d8Ci9nevdLCeUMctF3uGXp9WQqJ", "") receiverWallet, err := wallet.FromSeed("sEd7d8Ci9nevdLCeUMctF3uGXp9WQqJ", "")
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
cfg, err := rpc.NewClientConfig( cfg, err := rpc.NewClientConfig(
"https://s.altnet.rippletest.net:51234/", "https://s.altnet.rippletest.net:51234/",
rpc.WithFaucetProvider(faucet.NewTestnetFaucetProvider()), rpc.WithFaucetProvider(faucet.NewTestnetFaucetProvider()),
) )
if err != nil { if err != nil {
panic(err) 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" { if err != nil || balance == "0" {
fmt.Println("⏳ Funding wallet...") fmt.Println("⏳ Funding wallet...")
err = client.FundWallet(&w) err = client.FundWallet(&w)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("💸 Wallet funded") 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") amount, err := currency.XrpToDrops("1")
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
amountUint, err := strconv.ParseUint(amount, 10, 64) amountUint, err := strconv.ParseUint(amount, 10, 64)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("⏳ Sending payment...") fmt.Println("⏳ Sending payment...")
payment := transactions.Payment{ payment := transactions.Payment{
BaseTx: transactions.BaseTx{ BaseTx: transactions.BaseTx{
Account: types.Address(w.GetAddress()), Account: types.Address(w.GetAddress()),
Memos: []types.MemoWrapper{ Memos: []types.MemoWrapper{
{ {
Memo: types.Memo{ Memo: types.Memo{
MemoData: hex.EncodeToString([]byte("Hello, World!")), MemoData: hex.EncodeToString([]byte("Hello, World!")),
MemoFormat: hex.EncodeToString([]byte("plain")), MemoFormat: hex.EncodeToString([]byte("plain")),
MemoType: hex.EncodeToString([]byte("message")), MemoType: hex.EncodeToString([]byte("message")),
}, },
}, },
{ {
Memo: types.Memo{ Memo: types.Memo{
MemoData: hex.EncodeToString([]byte("Hello, World 2!")), MemoData: hex.EncodeToString([]byte("Hello, World 2!")),
MemoFormat: hex.EncodeToString([]byte("text/plain")), MemoFormat: hex.EncodeToString([]byte("text/plain")),
MemoType: hex.EncodeToString([]byte("message2")), MemoType: hex.EncodeToString([]byte("message2")),
}, },
}, },
}, },
}, },
Destination: types.Address(receiverWallet.GetAddress()), Destination: types.Address(receiverWallet.GetAddress()),
Amount: types.XRPCurrencyAmount(amountUint), Amount: types.XRPCurrencyAmount(amountUint),
} }
flatTx := payment.Flatten() flatTx := payment.Flatten()
err = client.Autofill(&flatTx) err = client.Autofill(&flatTx)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
txBlob, _, err := w.Sign(flatTx) txBlob, _, err := w.Sign(flatTx)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
response, err := client.SubmitTxBlobAndWait(txBlob, true) response, err := client.SubmitTxBlobAndWait(txBlob, true)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("✅ Payment submitted") fmt.Println("✅ Payment submitted")
fmt.Printf("🌐 Hash: %s\n", response.Hash.String()) fmt.Printf("🌐 Hash: %s\n", response.Hash.String())
fmt.Printf("🌐 Validated: %t\n", response.Validated) fmt.Printf("🌐 Validated: %t\n", response.Validated)
} }

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

@@ -1,121 +1,121 @@
package main package main
import ( import (
"encoding/hex" "encoding/hex"
"fmt" "fmt"
"strconv" "strconv"
"github.com/Peersyst/xrpl-go/xrpl/currency" "github.com/Peersyst/xrpl-go/xrpl/currency"
"github.com/Peersyst/xrpl-go/xrpl/faucet" "github.com/Peersyst/xrpl-go/xrpl/faucet"
transactions "github.com/Peersyst/xrpl-go/xrpl/transaction" transactions "github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types" "github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet" "github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/xrpl/websocket" "github.com/Peersyst/xrpl-go/xrpl/websocket"
) )
func main() { func main() {
w, err := wallet.FromSeed("sEdSMVV4dJ1JbdBxmakRR4Puu3XVZz2", "") w, err := wallet.FromSeed("sEdSMVV4dJ1JbdBxmakRR4Puu3XVZz2", "")
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
receiverWallet, err := wallet.FromSeed("sEd7d8Ci9nevdLCeUMctF3uGXp9WQqJ", "") receiverWallet, err := wallet.FromSeed("sEd7d8Ci9nevdLCeUMctF3uGXp9WQqJ", "")
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
client := websocket.NewClient( client := websocket.NewClient(
websocket.NewClientConfig(). websocket.NewClientConfig().
WithHost("wss://s.altnet.rippletest.net:51233"). WithHost("wss://s.altnet.rippletest.net:51233").
WithFaucetProvider(faucet.NewTestnetFaucetProvider()), WithFaucetProvider(faucet.NewTestnetFaucetProvider()),
) )
defer client.Disconnect() defer client.Disconnect()
fmt.Println("⏳ Connecting to server...") fmt.Println("⏳ Connecting to server...")
if err := client.Connect(); err != nil { if err := client.Connect(); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("✅ Connected to server") fmt.Println("✅ Connected to server")
fmt.Println() fmt.Println()
balance, err := client.GetXrpBalance(w.GetAddress()) balance, err := client.GetXrpBalance(w.GetAddress())
if err != nil || balance == "0" { if err != nil || balance == "0" {
fmt.Println("⏳ Funding wallet...") fmt.Println("⏳ Funding wallet...")
err = client.FundWallet(&w) err = client.FundWallet(&w)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("💸 Wallet funded") 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") amount, err := currency.XrpToDrops("1")
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
amountUint, err := strconv.ParseUint(amount, 10, 64) amountUint, err := strconv.ParseUint(amount, 10, 64)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("⏳ Sending payment...") fmt.Println("⏳ Sending payment...")
payment := transactions.Payment{ payment := transactions.Payment{
BaseTx: transactions.BaseTx{ BaseTx: transactions.BaseTx{
Account: types.Address(w.GetAddress()), Account: types.Address(w.GetAddress()),
Memos: []types.MemoWrapper{ Memos: []types.MemoWrapper{
{ {
Memo: types.Memo{ Memo: types.Memo{
MemoData: hex.EncodeToString([]byte("Hello, World!")), MemoData: hex.EncodeToString([]byte("Hello, World!")),
MemoFormat: hex.EncodeToString([]byte("plain")), MemoFormat: hex.EncodeToString([]byte("plain")),
MemoType: hex.EncodeToString([]byte("message")), MemoType: hex.EncodeToString([]byte("message")),
}, },
}, },
{ {
Memo: types.Memo{ Memo: types.Memo{
MemoData: hex.EncodeToString([]byte("Hello, World 2!")), MemoData: hex.EncodeToString([]byte("Hello, World 2!")),
MemoFormat: hex.EncodeToString([]byte("text/plain")), MemoFormat: hex.EncodeToString([]byte("text/plain")),
MemoType: hex.EncodeToString([]byte("message2")), MemoType: hex.EncodeToString([]byte("message2")),
}, },
}, },
}, },
}, },
Destination: types.Address(receiverWallet.GetAddress()), Destination: types.Address(receiverWallet.GetAddress()),
Amount: types.XRPCurrencyAmount(amountUint), Amount: types.XRPCurrencyAmount(amountUint),
} }
flatTx := payment.Flatten() flatTx := payment.Flatten()
err = client.Autofill(&flatTx) err = client.Autofill(&flatTx)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
txBlob, _, err := w.Sign(flatTx) txBlob, _, err := w.Sign(flatTx)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
response, err := client.SubmitTxBlobAndWait(txBlob, true) response, err := client.SubmitTxBlobAndWait(txBlob, true)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("✅ Payment submitted") fmt.Println("✅ Payment submitted")
fmt.Printf("🌐 Hash: %s\n", response.Hash.String()) fmt.Printf("🌐 Hash: %s\n", response.Hash.String())
fmt.Printf("🌐 Validated: %t\n", response.Validated) fmt.Printf("🌐 Validated: %t\n", response.Validated)
} }

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

@@ -1,111 +1,111 @@
package main package main
import ( import (
"fmt" "fmt"
"strconv" "strconv"
"github.com/Peersyst/xrpl-go/xrpl/currency" "github.com/Peersyst/xrpl-go/xrpl/currency"
"github.com/Peersyst/xrpl-go/xrpl/faucet" "github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/rpc" "github.com/Peersyst/xrpl-go/xrpl/rpc"
"github.com/Peersyst/xrpl-go/xrpl/transaction" "github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types" "github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet" "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 ( const (
WalletSeed = "sn3nxiW7v8KXzPzAqzyHXbSSKNuN9" WalletSeed = "sn3nxiW7v8KXzPzAqzyHXbSSKNuN9"
) )
func main() { func main() {
cfg, err := rpc.NewClientConfig( cfg, err := rpc.NewClientConfig(
"https://s.altnet.rippletest.net:51234/", "https://s.altnet.rippletest.net:51234/",
rpc.WithMaxFeeXRP(5.0), rpc.WithMaxFeeXRP(5.0),
rpc.WithFeeCushion(1.5), rpc.WithFeeCushion(1.5),
rpc.WithFaucetProvider(faucet.NewTestnetFaucetProvider()), rpc.WithFaucetProvider(faucet.NewTestnetFaucetProvider()),
) )
if err != nil { if err != nil {
panic(err) panic(err)
} }
client := rpc.NewClient(cfg) client := rpc.NewClient(cfg)
w, err := wallet.FromSeed(WalletSeed, "") w, err := wallet.FromSeed(WalletSeed, "")
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("⏳ Funding wallet...") fmt.Println("⏳ Funding wallet...")
if err := client.FundWallet(&w); err != nil { if err := client.FundWallet(&w); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("💸 Wallet funded") fmt.Println("💸 Wallet funded")
fmt.Println() fmt.Println()
xrpAmount, err := currency.XrpToDrops("1") xrpAmount, err := currency.XrpToDrops("1")
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
xrpAmountInt, err := strconv.ParseInt(xrpAmount, 10, 64) xrpAmountInt, err := strconv.ParseInt(xrpAmount, 10, 64)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("⏳ Sending 1 XRP to rPT1Sjq2YGrBMTttX4GZHjKu9dyfzbpAYe...") fmt.Println("⏳ Sending 1 XRP to rPT1Sjq2YGrBMTttX4GZHjKu9dyfzbpAYe...")
p := &transaction.Payment{ p := &transaction.Payment{
BaseTx: transaction.BaseTx{ BaseTx: transaction.BaseTx{
Account: types.Address(w.GetAddress()), Account: types.Address(w.GetAddress()),
}, },
Destination: "rPT1Sjq2YGrBMTttX4GZHjKu9dyfzbpAYe", Destination: "rPT1Sjq2YGrBMTttX4GZHjKu9dyfzbpAYe",
Amount: types.XRPCurrencyAmount(xrpAmountInt), Amount: types.XRPCurrencyAmount(xrpAmountInt),
DeliverMax: types.XRPCurrencyAmount(xrpAmountInt), DeliverMax: types.XRPCurrencyAmount(xrpAmountInt),
} }
flattenedTx := p.Flatten() flattenedTx := p.Flatten()
if err := client.Autofill(&flattenedTx); err != nil { if err := client.Autofill(&flattenedTx); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
txBlob, _, err := w.Sign(flattenedTx) txBlob, _, err := w.Sign(flattenedTx)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
res, err := client.SubmitTxBlobAndWait(txBlob, false) res, err := client.SubmitTxBlobAndWait(txBlob, false)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("✅ Payment submitted") fmt.Println("✅ Payment submitted")
fmt.Printf("🌐 Hash: %s\n", res.Hash) fmt.Printf("🌐 Hash: %s\n", res.Hash)
fmt.Printf("🌐 Validated: %t\n", res.Validated) fmt.Printf("🌐 Validated: %t\n", res.Validated)
fmt.Println() fmt.Println()
fmt.Println("⏳ Using SubmitTxAndWait with wallet") fmt.Println("⏳ Using SubmitTxAndWait with wallet")
fmt.Println() fmt.Println()
flattenedTx2 := p.Flatten() flattenedTx2 := p.Flatten()
resp, err := client.SubmitTxAndWait(flattenedTx2, &rpctypes.SubmitOptions{ resp, err := client.SubmitTxAndWait(flattenedTx2, &rpctypes.SubmitOptions{
Autofill: true, Autofill: true,
Wallet: &w, Wallet: &w,
}) })
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("✅ Payment submitted via SubmitTxAndWait") fmt.Println("✅ Payment submitted via SubmitTxAndWait")
fmt.Printf("🌐 Hash: %s\n", resp.Hash) fmt.Printf("🌐 Hash: %s\n", resp.Hash)
fmt.Printf("🌐 Validated: %t\n", resp.Validated) fmt.Printf("🌐 Validated: %t\n", resp.Validated)
} }

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

@@ -1,35 +1,35 @@
package main package main
import ( import (
"fmt" "fmt"
"strconv" "strconv"
"github.com/Peersyst/xrpl-go/xrpl/currency" "github.com/Peersyst/xrpl-go/xrpl/currency"
"github.com/Peersyst/xrpl-go/xrpl/faucet" "github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/queries/transactions" "github.com/Peersyst/xrpl-go/xrpl/queries/transactions"
"github.com/Peersyst/xrpl-go/xrpl/transaction" "github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types" "github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet" "github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/xrpl/websocket" "github.com/Peersyst/xrpl-go/xrpl/websocket"
wstypes "github.com/Peersyst/xrpl-go/xrpl/websocket/types" wstypes "github.com/Peersyst/xrpl-go/xrpl/websocket/types"
) )
func main() { func main() {
client := websocket.NewClient( client := websocket.NewClient(
websocket.NewClientConfig(). websocket.NewClientConfig().
WithHost("wss://s.altnet.rippletest.net:51233"). WithHost("wss://s.altnet.rippletest.net:51233").
WithFaucetProvider(faucet.NewTestnetFaucetProvider()), WithFaucetProvider(faucet.NewTestnetFaucetProvider()),
) )
defer client.Disconnect() defer client.Disconnect()
if err := client.Connect(); err != nil { if err := client.Connect(); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
if !client.IsConnected() { if !client.IsConnected() {
fmt.Println("❌ Failed to connect to testnet") fmt.Println("❌ Failed to connect to testnet")
return return
} }
fmt.Println("✅ Connected to testnet") fmt.Println("✅ Connected to testnet")
@@ -39,15 +39,15 @@ fmt.Println()
const WalletSeed = "sEd7zwWAu7vXMCBkkzokJHEXiKw2B2s" const WalletSeed = "sEd7zwWAu7vXMCBkkzokJHEXiKw2B2s"
w, err := wallet.FromSeed(WalletSeed, "") w, err := wallet.FromSeed(WalletSeed, "")
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
// Funding the wallet // Funding the wallet
fmt.Println("⏳ Funding wallet...") fmt.Println("⏳ Funding wallet...")
if err := client.FundWallet(&w); err != nil { if err := client.FundWallet(&w); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("💸 Wallet funded") fmt.Println("💸 Wallet funded")
@@ -55,56 +55,56 @@ fmt.Println()
xrpAmount, err := currency.XrpToDrops("1") xrpAmount, err := currency.XrpToDrops("1")
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
xrpAmountInt, err := strconv.ParseInt(xrpAmount, 10, 64) xrpAmountInt, err := strconv.ParseInt(xrpAmount, 10, 64)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
// Prepare a payment transaction // Prepare a payment transaction
p := &transaction.Payment{ p := &transaction.Payment{
BaseTx: transaction.BaseTx{ BaseTx: transaction.BaseTx{
Account: types.Address(w.GetAddress()), Account: types.Address(w.GetAddress()),
}, },
Destination: "rPT1Sjq2YGrBMTttX4GZHjKu9dyfzbpAYe", Destination: "rPT1Sjq2YGrBMTttX4GZHjKu9dyfzbpAYe",
Amount: types.XRPCurrencyAmount(xrpAmountInt), Amount: types.XRPCurrencyAmount(xrpAmountInt),
DeliverMax: types.XRPCurrencyAmount(xrpAmountInt), DeliverMax: types.XRPCurrencyAmount(xrpAmountInt),
} }
flattenedTx := p.Flatten() flattenedTx := p.Flatten()
if err := client.Autofill(&flattenedTx); err != nil { if err := client.Autofill(&flattenedTx); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
// Sign the transaction using the wallet // Sign the transaction using the wallet
txBlob, _, err := w.Sign(flattenedTx) txBlob, _, err := w.Sign(flattenedTx)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
// Submit the transaction and wait for the result // Submit the transaction and wait for the result
res_blob, err := client.SubmitTxBlobAndWait(txBlob, false) res_blob, err := client.SubmitTxBlobAndWait(txBlob, false)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
// Example with SubmitTxAndWait // Example with SubmitTxAndWait
flattenedTx2 := p.Flatten() flattenedTx2 := p.Flatten()
res_flat, err := client.SubmitTxAndWait(flattenedTx2, &wstypes.SubmitOptions{ res_flat, err := client.SubmitTxAndWait(flattenedTx2, &wstypes.SubmitOptions{
Autofill: true, Autofill: true,
Wallet: &w, Wallet: &w,
}) })
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
// Wait for validation ------------------------------------------------------- // Wait for validation -------------------------------------------------------
// SubmitTxBlobAndWait() handles this automatically, but it can take 4-7s. // 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("🌐 Hash: %s\n", res_blob.Hash)
fmt.Printf("🌐 Meta: %t\n", res_blob.Meta) fmt.Printf("🌐 Meta: %t\n", res_blob.Meta)
res, _ := client.Request(&transactions.TxRequest{ res, _ := client.Request(&transactions.TxRequest{
Transaction: res_flat.Hash.String(), Transaction: res_flat.Hash.String(),
}) })
fmt.Printf("🌐 Result: %s\n", res.Result) fmt.Printf("🌐 Result: %s\n", res.Result)
} }

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

@@ -1,131 +1,131 @@
package main package main
import ( import (
"fmt" "fmt"
"github.com/Peersyst/xrpl-go/pkg/crypto" "github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet" "github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/rpc" "github.com/Peersyst/xrpl-go/xrpl/rpc"
"github.com/Peersyst/xrpl-go/xrpl/transaction" "github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types" "github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet" "github.com/Peersyst/xrpl-go/xrpl/wallet"
) )
func main() { func main() {
cfg, err := rpc.NewClientConfig( cfg, err := rpc.NewClientConfig(
"https://s.altnet.rippletest.net:51234/", "https://s.altnet.rippletest.net:51234/",
rpc.WithFaucetProvider(faucet.NewTestnetFaucetProvider()), rpc.WithFaucetProvider(faucet.NewTestnetFaucetProvider()),
) )
if err != nil { if err != nil {
panic(err) panic(err)
} }
client := rpc.NewClient(cfg) client := rpc.NewClient(cfg)
w1, err := wallet.New(crypto.ED25519()) w1, err := wallet.New(crypto.ED25519())
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
w2, err := wallet.New(crypto.ED25519()) w2, err := wallet.New(crypto.ED25519())
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
regularKeyWallet, err := wallet.New(crypto.ED25519()) regularKeyWallet, err := wallet.New(crypto.ED25519())
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("⏳ Funding wallets...") fmt.Println("⏳ Funding wallets...")
if err := client.FundWallet(&w1); err != nil { if err := client.FundWallet(&w1); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("💸 Wallet 1 funded") fmt.Println("💸 Wallet 1 funded")
if err := client.FundWallet(&w2); err != nil { if err := client.FundWallet(&w2); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("💸 Wallet 2 funded") fmt.Println("💸 Wallet 2 funded")
if err := client.FundWallet(&regularKeyWallet); err != nil { if err := client.FundWallet(&regularKeyWallet); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("💸 Regular key wallet funded") fmt.Println("💸 Regular key wallet funded")
fmt.Println() fmt.Println()
fmt.Println("⏳ Setting regular key...") fmt.Println("⏳ Setting regular key...")
rk := &transaction.SetRegularKey{ rk := &transaction.SetRegularKey{
BaseTx: transaction.BaseTx{ BaseTx: transaction.BaseTx{
Account: w1.GetAddress(), Account: w1.GetAddress(),
}, },
RegularKey: regularKeyWallet.GetAddress(), RegularKey: regularKeyWallet.GetAddress(),
} }
flatRk := rk.Flatten() flatRk := rk.Flatten()
err = client.Autofill(&flatRk) err = client.Autofill(&flatRk)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
blob, _, err := w1.Sign(flatRk) blob, _, err := w1.Sign(flatRk)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
res, err := client.SubmitTxBlobAndWait(blob, false) res, err := client.SubmitTxBlobAndWait(blob, false)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("✅ SetRegularKey transaction submitted") fmt.Println("✅ SetRegularKey transaction submitted")
fmt.Printf("🌐 Hash: %s\n", res.Hash) fmt.Printf("🌐 Hash: %s\n", res.Hash)
fmt.Printf("🌐 Validated: %t\n", res.Validated) fmt.Printf("🌐 Validated: %t\n", res.Validated)
fmt.Println() fmt.Println()
fmt.Println("⏳ Checking if regular key is set...") fmt.Println("⏳ Checking if regular key is set...")
p := &transaction.Payment{ p := &transaction.Payment{
BaseTx: transaction.BaseTx{ BaseTx: transaction.BaseTx{
Account: w1.GetAddress(), Account: w1.GetAddress(),
}, },
Destination: w2.GetAddress(), Destination: w2.GetAddress(),
Amount: types.XRPCurrencyAmount(10000), Amount: types.XRPCurrencyAmount(10000),
} }
flatP := p.Flatten() flatP := p.Flatten()
err = client.Autofill(&flatP) err = client.Autofill(&flatP)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
blob, _, err = regularKeyWallet.Sign(flatP) blob, _, err = regularKeyWallet.Sign(flatP)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
res, err = client.SubmitTxBlobAndWait(blob, false) res, err = client.SubmitTxBlobAndWait(blob, false)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("✅ Payment transaction submitted") fmt.Println("✅ Payment transaction submitted")
fmt.Printf("🌐 Hash: %s\n", res.Hash) fmt.Printf("🌐 Hash: %s\n", res.Hash)
fmt.Printf("🌐 Validated: %t\n", res.Validated) fmt.Printf("🌐 Validated: %t\n", res.Validated)
} }

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

@@ -1,142 +1,142 @@
package main package main
import ( import (
"fmt" "fmt"
"github.com/Peersyst/xrpl-go/pkg/crypto" "github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet" "github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/transaction" "github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/transaction/types" "github.com/Peersyst/xrpl-go/xrpl/transaction/types"
"github.com/Peersyst/xrpl-go/xrpl/wallet" "github.com/Peersyst/xrpl-go/xrpl/wallet"
"github.com/Peersyst/xrpl-go/xrpl/websocket" "github.com/Peersyst/xrpl-go/xrpl/websocket"
) )
func main() { func main() {
fmt.Println("⏳ Connecting to testnet...") fmt.Println("⏳ Connecting to testnet...")
client := websocket.NewClient( client := websocket.NewClient(
websocket.NewClientConfig(). websocket.NewClientConfig().
WithHost("wss://s.altnet.rippletest.net:51233"). WithHost("wss://s.altnet.rippletest.net:51233").
WithFaucetProvider(faucet.NewTestnetFaucetProvider()), WithFaucetProvider(faucet.NewTestnetFaucetProvider()),
) )
defer client.Disconnect() defer client.Disconnect()
if err := client.Connect(); err != nil { if err := client.Connect(); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
if !client.IsConnected() { if !client.IsConnected() {
fmt.Println("❌ Failed to connect to testnet") fmt.Println("❌ Failed to connect to testnet")
return return
} }
fmt.Println("✅ Connected to testnet") fmt.Println("✅ Connected to testnet")
fmt.Println() fmt.Println()
w1, err := wallet.New(crypto.ED25519()) w1, err := wallet.New(crypto.ED25519())
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
w2, err := wallet.New(crypto.ED25519()) w2, err := wallet.New(crypto.ED25519())
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
regularKeyWallet, err := wallet.New(crypto.ED25519()) regularKeyWallet, err := wallet.New(crypto.ED25519())
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("⏳ Funding wallets...") fmt.Println("⏳ Funding wallets...")
if err := client.FundWallet(&w1); err != nil { if err := client.FundWallet(&w1); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("💸 Wallet 1 funded") fmt.Println("💸 Wallet 1 funded")
if err := client.FundWallet(&w2); err != nil { if err := client.FundWallet(&w2); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("💸 Wallet 2 funded") fmt.Println("💸 Wallet 2 funded")
if err := client.FundWallet(&regularKeyWallet); err != nil { if err := client.FundWallet(&regularKeyWallet); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("💸 Regular key wallet funded") fmt.Println("💸 Regular key wallet funded")
fmt.Println() fmt.Println()
fmt.Println("⏳ Setting regular key...") fmt.Println("⏳ Setting regular key...")
rk := &transaction.SetRegularKey{ rk := &transaction.SetRegularKey{
BaseTx: transaction.BaseTx{ BaseTx: transaction.BaseTx{
Account: w1.GetAddress(), Account: w1.GetAddress(),
}, },
RegularKey: regularKeyWallet.GetAddress(), RegularKey: regularKeyWallet.GetAddress(),
} }
flatRk := rk.Flatten() flatRk := rk.Flatten()
err = client.Autofill(&flatRk) err = client.Autofill(&flatRk)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
blob, _, err := w1.Sign(flatRk) blob, _, err := w1.Sign(flatRk)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
res, err := client.SubmitTxBlobAndWait(blob, false) res, err := client.SubmitTxBlobAndWait(blob, false)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("✅ SetRegularKey transaction submitted") fmt.Println("✅ SetRegularKey transaction submitted")
fmt.Printf("🌐 Hash: %s\n", res.Hash) fmt.Printf("🌐 Hash: %s\n", res.Hash)
fmt.Printf("🌐 Validated: %t\n", res.Validated) fmt.Printf("🌐 Validated: %t\n", res.Validated)
fmt.Println() fmt.Println()
fmt.Println("⏳ Checking if regular key is set...") fmt.Println("⏳ Checking if regular key is set...")
p := &transaction.Payment{ p := &transaction.Payment{
BaseTx: transaction.BaseTx{ BaseTx: transaction.BaseTx{
Account: w1.GetAddress(), Account: w1.GetAddress(),
}, },
Destination: w2.GetAddress(), Destination: w2.GetAddress(),
Amount: types.XRPCurrencyAmount(10000), Amount: types.XRPCurrencyAmount(10000),
} }
flatP := p.Flatten() flatP := p.Flatten()
err = client.Autofill(&flatP) err = client.Autofill(&flatP)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
blob, _, err = regularKeyWallet.Sign(flatP) blob, _, err = regularKeyWallet.Sign(flatP)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
res, err = client.SubmitTxBlobAndWait(blob, false) res, err = client.SubmitTxBlobAndWait(blob, false)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("✅ Payment transaction submitted") fmt.Println("✅ Payment transaction submitted")
fmt.Printf("🌐 Hash: %s\n", res.Hash) fmt.Printf("🌐 Hash: %s\n", res.Hash)
fmt.Printf("🌐 Validated: %t\n", res.Validated) fmt.Printf("🌐 Validated: %t\n", res.Validated)
} }

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

@@ -1,134 +1,134 @@
package main package main
import ( import (
"encoding/json" "encoding/json"
"fmt" "fmt"
"github.com/Peersyst/xrpl-go/pkg/crypto" "github.com/Peersyst/xrpl-go/pkg/crypto"
"github.com/Peersyst/xrpl-go/xrpl/faucet" "github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/queries/account" "github.com/Peersyst/xrpl-go/xrpl/queries/account"
"github.com/Peersyst/xrpl-go/xrpl/rpc" "github.com/Peersyst/xrpl-go/xrpl/rpc"
"github.com/Peersyst/xrpl-go/xrpl/transaction" "github.com/Peersyst/xrpl-go/xrpl/transaction"
"github.com/Peersyst/xrpl-go/xrpl/wallet" "github.com/Peersyst/xrpl-go/xrpl/wallet"
) )
func main() { func main() {
cfg, err := rpc.NewClientConfig( cfg, err := rpc.NewClientConfig(
"https://s.altnet.rippletest.net:51234/", "https://s.altnet.rippletest.net:51234/",
rpc.WithFaucetProvider(faucet.NewTestnetFaucetProvider()), rpc.WithFaucetProvider(faucet.NewTestnetFaucetProvider()),
) )
if err != nil { if err != nil {
panic(err) panic(err)
} }
client := rpc.NewClient(cfg) client := rpc.NewClient(cfg)
w, err := wallet.New(crypto.ED25519()) w, err := wallet.New(crypto.ED25519())
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("⏳ Funding wallet...") fmt.Println("⏳ Funding wallet...")
if err := client.FundWallet(&w); err != nil { if err := client.FundWallet(&w); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("💸 Wallet funded") fmt.Println("💸 Wallet funded")
fmt.Println() fmt.Println()
info, err := client.GetAccountInfo(&account.InfoRequest{ info, err := client.GetAccountInfo(&account.InfoRequest{
Account: w.GetAddress(), Account: w.GetAddress(),
}) })
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("🌐 Current wallet sequence:", info.AccountData.Sequence) fmt.Println("🌐 Current wallet sequence:", info.AccountData.Sequence)
fmt.Println() fmt.Println()
fmt.Println("⏳ Submitting TicketCreate transaction...") fmt.Println("⏳ Submitting TicketCreate transaction...")
tc := &transaction.TicketCreate{ tc := &transaction.TicketCreate{
BaseTx: transaction.BaseTx{ BaseTx: transaction.BaseTx{
Account: w.GetAddress(), Account: w.GetAddress(),
Sequence: info.AccountData.Sequence, Sequence: info.AccountData.Sequence,
}, },
TicketCount: 10, TicketCount: 10,
} }
flatTc := tc.Flatten() flatTc := tc.Flatten()
if err := client.Autofill(&flatTc); err != nil { if err := client.Autofill(&flatTc); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
blob, _, err := w.Sign(flatTc) blob, _, err := w.Sign(flatTc)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
res, err := client.SubmitTxBlobAndWait(blob, false) res, err := client.SubmitTxBlobAndWait(blob, false)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("✅ TicketCreate transaction submitted") fmt.Println("✅ TicketCreate transaction submitted")
fmt.Printf("🌐 Hash: %s\n", res.Hash) fmt.Printf("🌐 Hash: %s\n", res.Hash)
fmt.Printf("🌐 Validated: %t\n", res.Validated) fmt.Printf("🌐 Validated: %t\n", res.Validated)
fmt.Println() fmt.Println()
objects, err := client.GetAccountObjects(&account.ObjectsRequest{ objects, err := client.GetAccountObjects(&account.ObjectsRequest{
Account: w.GetAddress(), Account: w.GetAddress(),
}) })
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return 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() seq, err := objects.AccountObjects[0]["TicketSequence"].(json.Number).Int64()
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("⏳ Submitting AccountSet transaction...") fmt.Println("⏳ Submitting AccountSet transaction...")
as := &transaction.AccountSet{ as := &transaction.AccountSet{
BaseTx: transaction.BaseTx{ BaseTx: transaction.BaseTx{
Account: w.GetAddress(), Account: w.GetAddress(),
Sequence: 0, Sequence: 0,
TicketSequence: uint32(seq), TicketSequence: uint32(seq),
}, },
} }
flatAs := as.Flatten() flatAs := as.Flatten()
if err := client.Autofill(&flatAs); err != nil { if err := client.Autofill(&flatAs); err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
flatAs["Sequence"] = uint32(0) flatAs["Sequence"] = uint32(0)
blob, _, err = w.Sign(flatAs) blob, _, err = w.Sign(flatAs)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
res, err = client.SubmitTxBlobAndWait(blob, false) res, err = client.SubmitTxBlobAndWait(blob, false)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
return return
} }
fmt.Println("✅ AccountSet transaction submitted") fmt.Println("✅ AccountSet transaction submitted")
fmt.Printf("🌐 Hash: %s\n", res.Hash) fmt.Printf("🌐 Hash: %s\n", res.Hash)
fmt.Printf("🌐 Validated: %t\n", res.Validated) fmt.Printf("🌐 Validated: %t\n", res.Validated)
} }