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

chore(sample-docs): unify error handling with panic(err).

Browse Source
This commit is contained in:
banasa44
2025-08-25 12:44:07 +02:00
committed by akcodez
parent 1f3e1ee670
commit 3855ea8065
41 changed files with 402 additions and 809 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -40,30 +40,25 @@ func main() {
// Create and fund wallets
userWallet, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Println(err)
return
panic(err)
}
user2Wallet, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Println(err)
return
panic(err)
}
receiverWallet, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Funding wallets...")
if err := client.FundWallet(&userWallet); err != nil {
fmt.Println(err)
return
panic(err)
}
if err := client.FundWallet(&user2Wallet); err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Wallets funded")
@@ -105,8 +100,7 @@ func main() {
flattenedBatchTx := batchTx.Flatten()
fmt.Println("Autofilling flattened batch transaction...")
if err := client.Autofill(&flattenedBatchTx); err != nil {
fmt.Println("Autofill error:", err)
return
panic(err)
}
fmt.Println("Signing batch transaction...")
@@ -115,8 +109,7 @@ func main() {
Wallet: &userWallet,
})
if err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Batch transaction submitted")
@@ -165,14 +158,12 @@ func main() {
flattenedMultiBatchTx := multiBatchTx.Flatten()
fmt.Println("Autofilling flattened multi batch transaction...")
if err := client.AutofillMultisigned(&flattenedMultiBatchTx, 1); err != nil {
fmt.Println("Autofill error:", err)
return
panic(err)
}
fmt.Println("Signing multi batch transaction...")
if err := wallet.SignMultiBatch(user2Wallet, &flattenedMultiBatchTx, nil); err != nil {
fmt.Println("Signing error:", err)
return
panic(err)
}
response, err = client.SubmitTxAndWait(flattenedMultiBatchTx, &types.SubmitOptions{
@@ -180,8 +171,7 @@ func main() {
Wallet: &userWallet,
})
if err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Multisig Batch transaction submitted")

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

@@ -36,36 +36,30 @@ func main() {
defer client.Disconnect()
if err := client.Connect(); err != nil {
fmt.Println(err)
return
panic(err)
}
// Create and fund wallets
userWallet, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Println(err)
return
panic(err)
}
user2Wallet, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Println(err)
return
panic(err)
}
receiverWallet, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Funding wallets...")
if err := client.FundWallet(&userWallet); err != nil {
fmt.Println(err)
return
panic(err)
}
if err := client.FundWallet(&user2Wallet); err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Wallets funded")
@@ -107,8 +101,7 @@ func main() {
flattenedBatchTx := batchTx.Flatten()
fmt.Println("Autofilling flattened batch transaction...")
if err := client.Autofill(&flattenedBatchTx); err != nil {
fmt.Println("Autofill error:", err)
return
panic(err)
}
fmt.Println("Signing batch transaction...")
@@ -117,8 +110,7 @@ func main() {
Wallet: &userWallet,
})
if err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Batch transaction submitted")
@@ -167,14 +159,12 @@ func main() {
flattenedMultiBatchTx := multiBatchTx.Flatten()
fmt.Println("Autofilling flattened multi batch transaction...")
if err := client.AutofillMultisigned(&flattenedMultiBatchTx, 1); err != nil {
fmt.Println("Autofill error:", err)
return
panic(err)
}
fmt.Println("Signing multi batch transaction...")
if err := wallet.SignMultiBatch(user2Wallet, &flattenedMultiBatchTx, nil); err != nil {
fmt.Println("Signing error:", err)
return
panic(err)
}
response, err = client.SubmitTxAndWait(flattenedMultiBatchTx, &types.SubmitOptions{
@@ -182,8 +172,7 @@ func main() {
Wallet: &userWallet,
})
if err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Multisig Batch transaction submitted")

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

@@ -25,26 +25,22 @@ func main() {
w, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Println(err)
return
panic(err)
}
receiverWallet, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Setting up wallets...")
if err := client.FundWallet(&w); err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Sender wallet funded!")
if err := client.FundWallet(&receiverWallet); err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Receiver wallet funded!")
@@ -68,20 +64,17 @@ func main() {
flatCc := cc.Flatten()
if err := client.Autofill(&flatCc); err != nil {
fmt.Println(err)
return
panic(err)
}
blob, _, err := w.Sign(flatCc)
if err != nil {
fmt.Println(err)
return
panic(err)
}
res, err := client.SubmitTxBlobAndWait(blob, false)
if err != nil {
fmt.Println(err)
return
panic(err)
}
if !res.Validated {
@@ -140,20 +133,17 @@ func main() {
flatCheckCash := checkCash.Flatten()
if err := client.Autofill(&flatCheckCash); err != nil {
fmt.Println(err)
return
panic(err)
}
blob, _, err = receiverWallet.Sign(flatCheckCash)
if err != nil {
fmt.Println(err)
return
panic(err)
}
res, err = client.SubmitTxBlobAndWait(blob, false)
if err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Check cashed out!")

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

@@ -22,8 +22,7 @@ func main() {
defer client.Disconnect()
if err := client.Connect(); err != nil {
fmt.Println(err)
return
panic(err)
}
if !client.IsConnected() {
@@ -36,26 +35,22 @@ func main() {
w, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Println(err)
return
panic(err)
}
receiverWallet, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Setting up wallets...")
if err := client.FundWallet(&w); err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Sender wallet funded!")
if err := client.FundWallet(&receiverWallet); err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Receiver wallet funded!")
@@ -79,20 +74,18 @@ func main() {
flatCc := cc.Flatten()
if err := client.Autofill(&flatCc); err != nil {
fmt.Println(err)
return
panic(err)
}
blob, _, err := w.Sign(flatCc)
if err != nil {
fmt.Println(err)
return
panic(err)
}
res, err := client.SubmitTxBlobAndWait(blob, false)
if err != nil {
fmt.Println(err)
return
panic(err)
}
if !res.Validated {
@@ -151,20 +144,17 @@ func main() {
flatCheckCash := checkCash.Flatten()
if err := client.Autofill(&flatCheckCash); err != nil {
fmt.Println(err)
return
panic(err)
}
blob, _, err = receiverWallet.Sign(flatCheckCash)
if err != nil {
fmt.Println(err)
return
panic(err)
}
res, err = client.SubmitTxBlobAndWait(blob, false)
if err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Check cashed out!")

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

@@ -35,25 +35,21 @@ func main() {
fmt.Println("Setting up wallets...")
coldWallet, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Printf("Error creating cold wallet: %s\n", err)
return
panic(err)
}
err = client.FundWallet(&coldWallet)
if err != nil {
fmt.Printf("Error funding cold wallet: %s\n", err)
return
panic(err)
}
fmt.Println("Cold wallet funded!")
hotWallet, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Printf("Error creating hot wallet: %s\n", err)
return
panic(err)
}
err = client.FundWallet(&hotWallet)
if err != nil {
fmt.Printf("Error funding hot wallet: %s\n", err)
return
panic(err)
}
fmt.Println("Hot wallet funded!")
fmt.Println()
@@ -85,20 +81,17 @@ func main() {
err = client.Autofill(&flattenedTx)
if err != nil {
fmt.Printf("Error autofilling transaction: %s\n", err)
return
panic(err)
}
txBlob, _, err := coldWallet.Sign(flattenedTx)
if err != nil {
fmt.Printf("Error signing transaction: %s\n", err)
return
panic(err)
}
response, err := client.SubmitTxBlobAndWait(txBlob, false)
if err != nil {
fmt.Printf("Error submitting transaction: %s\n", err)
return
panic(err)
}
if !response.Validated {
@@ -130,20 +123,17 @@ func main() {
flattenedTx = hotColdTrustSet.Flatten()
err = client.Autofill(&flattenedTx)
if err != nil {
fmt.Printf("Error autofilling transaction: %s\n", err)
return
panic(err)
}
txBlob, _, err = hotWallet.Sign(flattenedTx)
if err != nil {
fmt.Printf("Error signing transaction: %s\n", err)
return
panic(err)
}
response, err = client.SubmitTxBlobAndWait(txBlob, false)
if err != nil {
fmt.Printf("Error submitting transaction: %s\n", err)
return
panic(err)
}
if !response.Validated {
@@ -177,20 +167,17 @@ func main() {
flattenedTx = coldToHotPayment.Flatten()
err = client.Autofill(&flattenedTx)
if err != nil {
fmt.Printf("Error autofilling transaction: %s\n", err)
return
panic(err)
}
txBlob, _, err = coldWallet.Sign(flattenedTx)
if err != nil {
fmt.Printf("Error signing transaction: %s\n", err)
return
panic(err)
}
response, err = client.SubmitTxBlobAndWait(txBlob, false)
if err != nil {
fmt.Printf("Error submitting transaction: %s\n", err)
return
panic(err)
}
if !response.Validated {
@@ -223,20 +210,17 @@ func main() {
flattenedTx = coldWalletClawback.Flatten()
err = client.Autofill(&flattenedTx)
if err != nil {
fmt.Printf("Error autofilling transaction: %s\n", err)
return
panic(err)
}
txBlob, _, err = coldWallet.Sign(flattenedTx)
if err != nil {
fmt.Printf("Error signing transaction: %s\n", err)
return
panic(err)
}
response, err = client.SubmitTxBlobAndWait(txBlob, false)
if err != nil {
fmt.Printf("Error submitting transaction: %s\n", err)
return
panic(err)
}
if !response.Validated {

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

@@ -30,8 +30,7 @@ func main() {
fmt.Println("Connecting to server...")
if err := client.Connect(); err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Connection: ", client.IsConnected())
@@ -42,25 +41,21 @@ func main() {
fmt.Println("Setting up wallets...")
coldWallet, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Printf("Error creating cold wallet: %s\n", err)
return
panic(err)
}
err = client.FundWallet(&coldWallet)
if err != nil {
fmt.Printf("Error funding cold wallet: %s\n", err)
return
panic(err)
}
fmt.Println("Cold wallet funded!")
hotWallet, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Printf("Error creating hot wallet: %s\n", err)
return
panic(err)
}
err = client.FundWallet(&hotWallet)
if err != nil {
fmt.Printf("Error funding hot wallet: %s\n", err)
return
panic(err)
}
fmt.Println("Hot wallet funded!")
fmt.Println()
@@ -92,20 +87,17 @@ func main() {
err = client.Autofill(&flattenedTx)
if err != nil {
fmt.Printf("Error autofilling transaction: %s\n", err)
return
panic(err)
}
txBlob, _, err := coldWallet.Sign(flattenedTx)
if err != nil {
fmt.Printf("Error signing transaction: %s\n", err)
return
panic(err)
}
response, err := client.SubmitTxBlobAndWait(txBlob, false)
if err != nil {
fmt.Printf("Error submitting transaction: %s\n", err)
return
panic(err)
}
if !response.Validated {
@@ -137,20 +129,17 @@ func main() {
flattenedTx = hotColdTrustSet.Flatten()
err = client.Autofill(&flattenedTx)
if err != nil {
fmt.Printf("Error autofilling transaction: %s\n", err)
return
panic(err)
}
txBlob, _, err = hotWallet.Sign(flattenedTx)
if err != nil {
fmt.Printf("Error signing transaction: %s\n", err)
return
panic(err)
}
response, err = client.SubmitTxBlobAndWait(txBlob, false)
if err != nil {
fmt.Printf("Error submitting transaction: %s\n", err)
return
panic(err)
}
if !response.Validated {
@@ -184,20 +173,17 @@ func main() {
flattenedTx = coldToHotPayment.Flatten()
err = client.Autofill(&flattenedTx)
if err != nil {
fmt.Printf("Error autofilling transaction: %s\n", err)
return
panic(err)
}
txBlob, _, err = coldWallet.Sign(flattenedTx)
if err != nil {
fmt.Printf("Error signing transaction: %s\n", err)
return
panic(err)
}
response, err = client.SubmitTxBlobAndWait(txBlob, false)
if err != nil {
fmt.Printf("Error submitting transaction: %s\n", err)
return
panic(err)
}
if !response.Validated {
@@ -230,20 +216,17 @@ func main() {
flattenedTx = coldWalletClawback.Flatten()
err = client.Autofill(&flattenedTx)
if err != nil {
fmt.Printf("Error autofilling transaction: %s\n", err)
return
panic(err)
}
txBlob, _, err = coldWallet.Sign(flattenedTx)
if err != nil {
fmt.Printf("Error signing transaction: %s\n", err)
return
panic(err)
}
response, err = client.SubmitTxBlobAndWait(txBlob, false)
if err != nil {
fmt.Printf("Error submitting transaction: %s\n", err)
return
panic(err)
}
if !response.Validated {

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

@@ -23,14 +23,12 @@ func main() {
fmt.Println("Setting up credential issuer wallet...")
issuer, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Printf("Error creating issuer wallet: %s\n", err)
return
panic(err)
}
err = client.FundWallet(&issuer)
if err != nil {
fmt.Printf("Error funding issuer wallet: %s\n", err)
return
panic(err)
}
fmt.Printf("Issuer wallet funded: %s\n", issuer.ClassicAddress)
@@ -40,14 +38,12 @@ func main() {
fmt.Println("Setting up Subject wallet...")
subjectWallet, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Printf("Error creating subject wallet: %s\n", err)
return
panic(err)
}
err = client.FundWallet(&subjectWallet)
if err != nil {
fmt.Printf("Error funding subject wallet: %s\n", err)
return
panic(err)
}
fmt.Printf("Subject wallet funded: %s\n", subjectWallet.ClassicAddress)
@@ -60,8 +56,7 @@ func main() {
credentialType := types.CredentialType("6D795F63726564656E7469616C")
if err != nil {
fmt.Printf("Error converting expiration to ripple time: %s\n", err)
return
panic(err)
}
txn := &transaction.CredentialCreate{

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

@@ -20,8 +20,7 @@ func main() {
client := clients.GetDevnetWebsocketClient()
fmt.Println("Connecting to server...")
if err := client.Connect(); err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Client configured!")
@@ -36,14 +35,12 @@ func main() {
fmt.Println("Setting up credential issuer wallet...")
issuer, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Printf("Error creating issuer wallet: %s\n", err)
return
panic(err)
}
err = client.FundWallet(&issuer)
if err != nil {
fmt.Printf("Error funding issuer wallet: %s\n", err)
return
panic(err)
}
fmt.Printf("Issuer wallet funded: %s\n", issuer.ClassicAddress)
@@ -53,14 +50,12 @@ func main() {
fmt.Println("Setting up Subject wallet...")
subjectWallet, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Printf("Error creating subject wallet: %s\n", err)
return
panic(err)
}
err = client.FundWallet(&subjectWallet)
if err != nil {
fmt.Printf("Error funding subject wallet: %s\n", err)
return
panic(err)
}
fmt.Printf("Subject wallet funded: %s\n", subjectWallet.ClassicAddress)
@@ -73,8 +68,7 @@ func main() {
credentialType := types.CredentialType("6D795F63726564656E7469616C")
if err != nil {
fmt.Printf("Error converting expiration to ripple time: %s\n", err)
return
panic(err)
}
txn := &transaction.CredentialCreate{

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

@@ -26,24 +26,20 @@ func main() {
// Create and fund wallets
delegatorWallet, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Println(err)
return
panic(err)
}
delegateeWallet, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Funding wallets...")
if err := client.FundWallet(&delegatorWallet); err != nil {
fmt.Println(err)
return
panic(err)
}
if err := client.FundWallet(&delegateeWallet); err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Wallets funded")
@@ -82,8 +78,7 @@ func main() {
Wallet: &delegatorWallet,
})
if err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("DelegateSet transaction submitted")
@@ -107,8 +102,7 @@ func main() {
Wallet: &delegateeWallet,
})
if err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Delegated payment submitted")

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

@@ -21,31 +21,26 @@ func main() {
defer client.Disconnect()
if err := client.Connect(); err != nil {
fmt.Println(err)
return
panic(err)
}
// Create and fund wallets
delegatorWallet, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Println(err)
return
panic(err)
}
delegateeWallet, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Funding wallets...")
if err := client.FundWallet(&delegatorWallet); err != nil {
fmt.Println(err)
return
panic(err)
}
if err := client.FundWallet(&delegateeWallet); err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Wallets funded")
@@ -81,20 +76,17 @@ func main() {
// Submit DelegateSet transaction
flattenedTx := delegateSetTx.Flatten()
if err := client.Autofill(&flattenedTx); err != nil {
fmt.Println(err)
return
panic(err)
}
txBlob, _, err := delegatorWallet.Sign(flattenedTx)
if err != nil {
fmt.Println(err)
return
panic(err)
}
response, err := client.SubmitTxBlobAndWait(txBlob, false)
if err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("DelegateSet transaction submitted")
@@ -115,20 +107,17 @@ func main() {
// Submit delegated payment
flatDelegatedPayment := delegatedPaymentTx.Flatten()
if err := client.Autofill(&flatDelegatedPayment); err != nil {
fmt.Println(err)
return
panic(err)
}
txBlob2, _, err := delegateeWallet.Sign(flatDelegatedPayment)
if err != nil {
fmt.Println(err)
return
panic(err)
}
response2, err := client.SubmitTxBlobAndWait(txBlob2, false)
if err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Delegated payment submitted")

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

@@ -24,14 +24,12 @@ func main() {
fmt.Println("Setting up credential issuer wallet...")
issuer, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Printf("Error creating credential issuer wallet: %s\n", err)
return
panic(err)
}
err = client.FundWallet(&issuer)
if err != nil {
fmt.Printf("Error funding credential issuer wallet: %s\n", err)
return
panic(err)
}
fmt.Printf("Credential issuer wallet funded: %s\n", issuer.ClassicAddress)
@@ -41,14 +39,12 @@ func main() {
fmt.Println("Setting up holder 1 wallet...")
holderWallet1, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Printf("Error creating holder 1 wallet: %s\n", err)
return
panic(err)
}
err = client.FundWallet(&holderWallet1)
if err != nil {
fmt.Printf("Error funding holder 1 wallet: %s\n", err)
return
panic(err)
}
fmt.Printf("Holder 1 wallet funded: %s\n", holderWallet1.ClassicAddress)
@@ -73,8 +69,7 @@ func main() {
expiration, err := rippletime.IsoTimeToRippleTime(time.Now().Add(time.Hour * 24).Format(time.RFC3339))
if err != nil {
fmt.Printf("Error converting expiration to ripple time: %s\n", err)
return
panic(err)
}
credentialType := types.CredentialType("6D795F63726564656E7469616C") // my_credential
@@ -142,8 +137,7 @@ func main() {
objectsResponse, err := client.GetAccountObjects(objectsRequest)
if err != nil {
fmt.Printf("Error getting the credential ID: %s\n", err)
return
panic(err)
}
// Check if we have any credential objects

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

@@ -22,8 +22,7 @@ func main() {
client := clients.GetDevnetWebsocketClient()
fmt.Println("Connecting to server...")
if err := client.Connect(); err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Client configured!")
@@ -38,14 +37,12 @@ func main() {
fmt.Println("Setting up credential issuer wallet...")
issuer, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Printf("Error creating credential issuer wallet: %s\n", err)
return
panic(err)
}
err = client.FundWallet(&issuer)
if err != nil {
fmt.Printf("Error funding credential issuer wallet: %s\n", err)
return
panic(err)
}
fmt.Printf("Credential issuer wallet funded: %s\n", issuer.ClassicAddress)
@@ -55,14 +52,12 @@ func main() {
fmt.Println("Setting up holder 1 wallet...")
holderWallet1, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Printf("Error creating holder 1 wallet: %s\n", err)
return
panic(err)
}
err = client.FundWallet(&holderWallet1)
if err != nil {
fmt.Printf("Error funding holder 1 wallet: %s\n", err)
return
panic(err)
}
fmt.Printf("Holder 1 wallet funded: %s\n", holderWallet1.ClassicAddress)
@@ -87,8 +82,7 @@ func main() {
expiration, err := rippletime.IsoTimeToRippleTime(time.Now().Add(time.Hour * 24).Format(time.RFC3339))
if err != nil {
fmt.Printf("Error converting expiration to ripple time: %s\n", err)
return
panic(err)
}
credentialType := types.CredentialType("6D795F63726564656E7469616C") // my_credential
@@ -156,8 +150,7 @@ func main() {
objectsResponse, err := client.GetAccountObjects(objectsRequest)
if err != nil {
fmt.Printf("Error getting the credential ID: %s\n", err)
return
panic(err)
}
// Check if we have any credential objects

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

@@ -30,14 +30,12 @@ func main() {
fmt.Println("Setting up issuer wallet...")
issuer, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Printf("Error creating issuer wallet: %s\n", err)
return
panic(err)
}
err = client.FundWallet(&issuer)
if err != nil {
fmt.Printf("Error funding issuer wallet: %s\n", err)
return
panic(err)
}
fmt.Printf("Issuer wallet funded: %s\n", issuer.ClassicAddress)
@@ -47,14 +45,12 @@ func main() {
fmt.Println("Setting up holder 1 wallet...")
holderWallet1, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Printf("Error creating holder wallet 1: %s\n", err)
return
panic(err)
}
err = client.FundWallet(&holderWallet1)
if err != nil {
fmt.Printf("Error funding holder wallet 1: %s\n", err)
return
panic(err)
}
fmt.Printf("Holder wallet 1 funded: %s\n", holderWallet1.ClassicAddress)
@@ -64,14 +60,12 @@ func main() {
fmt.Println("Setting up holder 2 wallet...")
holderWallet2, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Printf("Error creating holder wallet 2: %s\n", err)
return
panic(err)
}
err = client.FundWallet(&holderWallet2)
if err != nil {
fmt.Printf("Error funding holder wallet 2: %s\n", err)
return
panic(err)
}
fmt.Printf("Holder wallet 2 funded: %s\n", holderWallet2.ClassicAddress)
fmt.Println()
@@ -322,23 +316,17 @@ func submitAndWait(client *rpc.Client, txn SubmittableTransaction, wallet wallet
err := client.Autofill(&flattenedTx)
if err != nil {
fmt.Printf("Error autofilling %s transaction: %s\n", txn.TxType(), err)
fmt.Println()
return
panic(err)
}
txBlob, _, err := wallet.Sign(flattenedTx)
if err != nil {
fmt.Printf("Error signing %s transaction: %s\n", txn.TxType(), err)
fmt.Println()
return
panic(err)
}
response, err := client.SubmitTxBlobAndWait(txBlob, false)
if err != nil {
fmt.Printf("Error submitting %s transaction: %s\n", txn.TxType(), err)
fmt.Println()
return
panic(err)
}
fmt.Printf("%s transaction submitted\n", txn.TxType())

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

@@ -27,8 +27,7 @@ func main() {
client := getClient()
fmt.Println("Connecting to server...")
if err := client.Connect(); err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Client configured!")
@@ -43,14 +42,12 @@ func main() {
fmt.Println("Setting up issuer wallet...")
issuer, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Printf("Error creating issuer wallet: %s\n", err)
return
panic(err)
}
err = client.FundWallet(&issuer)
if err != nil {
fmt.Printf("Error funding issuer wallet: %s\n", err)
return
panic(err)
}
fmt.Printf("Issuer wallet funded: %s\n", issuer.ClassicAddress)
@@ -60,14 +57,12 @@ func main() {
fmt.Println("Setting up holder 1 wallet...")
holderWallet1, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Printf("Error creating holder wallet 1: %s\n", err)
return
panic(err)
}
err = client.FundWallet(&holderWallet1)
if err != nil {
fmt.Printf("Error funding holder wallet 1: %s\n", err)
return
panic(err)
}
fmt.Printf("Holder wallet 1 funded: %s\n", holderWallet1.ClassicAddress)
@@ -77,14 +72,12 @@ func main() {
fmt.Println("Setting up holder 2 wallet...")
holderWallet2, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Printf("Error creating holder wallet 2: %s\n", err)
return
panic(err)
}
err = client.FundWallet(&holderWallet2)
if err != nil {
fmt.Printf("Error funding holder wallet 2: %s\n", err)
return
panic(err)
}
fmt.Printf("Holder wallet 2 funded: %s\n", holderWallet2.ClassicAddress)
fmt.Println()
@@ -332,23 +325,17 @@ func submitAndWait(client *websocket.Client, txn SubmittableTransaction, wallet
err := client.Autofill(&flattenedTx)
if err != nil {
fmt.Printf("Error autofilling %s transaction: %s\n", txn.TxType(), err)
fmt.Println()
return
panic(err)
}
txBlob, _, err := wallet.Sign(flattenedTx)
if err != nil {
fmt.Printf("Error signing %s transaction: %s\n", txn.TxType(), err)
fmt.Println()
return
panic(err)
}
response, err := client.SubmitTxBlobAndWait(txBlob, false)
if err != nil {
fmt.Printf("Error submitting %s transaction: %s\n", txn.TxType(), err)
fmt.Println()
return
panic(err)
}
fmt.Printf("%s transaction submitted\n", txn.TxType())

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

@@ -1,8 +1,6 @@
package main
import (
"fmt"
"github.com/Peersyst/xrpl-go/xrpl/faucet"
"github.com/Peersyst/xrpl-go/xrpl/websocket"
)
@@ -20,8 +18,7 @@ func main() {
// Connect to the network
if err := client.Connect(); err != nil {
fmt.Println(err)
return
panic(err)
}
// ... custom code goes here

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

@@ -26,16 +26,14 @@ func main() {
// Create a new wallet
w, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("New wallet created:")
fmt.Println("Address:", w.ClassicAddress)
// Fund the wallet with testnet XRP
if err := client.FundWallet(&w); err != nil {
fmt.Println(err)
return
panic(err)
}
// Get info from the ledger about the address we just funded
@@ -43,8 +41,7 @@ func main() {
Account: w.GetAddress(),
})
if err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Account Balance:", acc_info.AccountData.Balance)
fmt.Println("Account Sequence:", acc_info.AccountData.Sequence)
@@ -52,8 +49,7 @@ func main() {
// Get info about the ledger
ledger, err := client.GetLedger(&ledger.Request{LedgerIndex: common.Current})
if err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Ledger Index:", ledger.Ledger.LedgerIndex)
}

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

@@ -26,8 +26,7 @@ func main() {
// Connect to the network
if err := client.Connect(); err != nil {
fmt.Println(err)
return
panic(err)
}
if !client.IsConnected() {
@@ -41,16 +40,14 @@ func main() {
// Create a new wallet
w, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("New wallet created:")
fmt.Println("Address:", w.ClassicAddress)
// Fund the wallet with testnet XRP
if err := client.FundWallet(&w); err != nil {
fmt.Println(err)
return
panic(err)
}
// Get info from the ledger about the address we just funded
@@ -58,8 +55,7 @@ func main() {
Account: w.GetAddress(),
})
if err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Account Balance:", acc_info.AccountData.Balance)
fmt.Println("Account Sequence:", acc_info.AccountData.Sequence)
@@ -67,8 +63,7 @@ func main() {
// Get info about the ledger
ledger, err := client.GetLedger(&ledger.Request{LedgerIndex: common.Current})
if err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Ledger Index:", ledger.Ledger.LedgerIndex)
}

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

@@ -38,37 +38,31 @@ func main() {
fmt.Println("Setting up wallets...")
coldWallet, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Printf("Error creating cold wallet: %s\n", err)
return
panic(err)
}
err = client.FundWallet(&coldWallet)
if err != nil {
fmt.Printf("Error funding cold wallet: %s\n", err)
return
panic(err)
}
fmt.Println("Cold wallet funded!")
hotWallet, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Printf("Error creating hot wallet: %s\n", err)
return
panic(err)
}
err = client.FundWallet(&hotWallet)
if err != nil {
fmt.Printf("Error funding hot wallet: %s\n", err)
return
panic(err)
}
fmt.Println("Hot wallet funded!")
customerOneWallet, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Printf("Error creating token wallet: %s\n", err)
return
panic(err)
}
err = client.FundWallet(&customerOneWallet)
if err != nil {
fmt.Printf("Error funding customer one wallet: %s\n", err)
return
panic(err)
}
fmt.Println("Customer one wallet funded!")
fmt.Println()
@@ -101,20 +95,17 @@ func main() {
err = client.Autofill(&flattenedTx)
if err != nil {
fmt.Printf("Error autofilling transaction: %s\n", err)
return
panic(err)
}
txBlob, _, err := coldWallet.Sign(flattenedTx)
if err != nil {
fmt.Printf("Error signing transaction: %s\n", err)
return
panic(err)
}
response, err := client.SubmitTxBlobAndWait(txBlob, false)
if err != nil {
fmt.Printf("Error submitting transaction: %s\n", err)
return
panic(err)
}
if !response.Validated {
@@ -146,20 +137,17 @@ func main() {
flattenedTx = hotWalletAccountSet.Flatten()
err = client.Autofill(&flattenedTx)
if err != nil {
fmt.Printf("Error autofilling transaction: %s\n", err)
return
panic(err)
}
txBlob, _, err = hotWallet.Sign(flattenedTx)
if err != nil {
fmt.Printf("Error signing transaction: %s\n", err)
return
panic(err)
}
response, err = client.SubmitTxBlobAndWait(txBlob, false)
if err != nil {
fmt.Printf("Error submitting transaction: %s\n", err)
return
panic(err)
}
if !response.Validated {
@@ -191,20 +179,17 @@ func main() {
flattenedTx = hotColdTrustSet.Flatten()
err = client.Autofill(&flattenedTx)
if err != nil {
fmt.Printf("Error autofilling transaction: %s\n", err)
return
panic(err)
}
txBlob, _, err = hotWallet.Sign(flattenedTx)
if err != nil {
fmt.Printf("Error signing transaction: %s\n", err)
return
panic(err)
}
response, err = client.SubmitTxBlobAndWait(txBlob, false)
if err != nil {
fmt.Printf("Error submitting transaction: %s\n", err)
return
panic(err)
}
if !response.Validated {
@@ -236,20 +221,17 @@ func main() {
flattenedTx = customerOneColdTrustSet.Flatten()
err = client.Autofill(&flattenedTx)
if err != nil {
fmt.Printf("Error autofilling transaction: %s\n", err)
return
panic(err)
}
txBlob, _, err = customerOneWallet.Sign(flattenedTx)
if err != nil {
fmt.Printf("Error signing transaction: %s\n", err)
return
panic(err)
}
response, err = client.SubmitTxBlobAndWait(txBlob, false)
if err != nil {
fmt.Printf("Error submitting transaction: %s\n", err)
return
panic(err)
}
if !response.Validated {
@@ -283,20 +265,17 @@ func main() {
flattenedTx = coldToHotPayment.Flatten()
err = client.Autofill(&flattenedTx)
if err != nil {
fmt.Printf("Error autofilling transaction: %s\n", err)
return
panic(err)
}
txBlob, _, err = coldWallet.Sign(flattenedTx)
if err != nil {
fmt.Printf("Error signing transaction: %s\n", err)
return
panic(err)
}
response, err = client.SubmitTxBlobAndWait(txBlob, false)
if err != nil {
fmt.Printf("Error submitting transaction: %s\n", err)
return
panic(err)
}
if !response.Validated {
@@ -329,20 +308,17 @@ func main() {
flattenedTx = coldToCustomerOnePayment.Flatten()
err = client.Autofill(&flattenedTx)
if err != nil {
fmt.Printf("Error autofilling transaction: %s\n", err)
return
panic(err)
}
txBlob, _, err = coldWallet.Sign(flattenedTx)
if err != nil {
fmt.Printf("Error signing transaction: %s\n", err)
return
panic(err)
}
response, err = client.SubmitTxBlobAndWait(txBlob, false)
if err != nil {
fmt.Printf("Error submitting transaction: %s\n", err)
return
panic(err)
}
if !response.Validated {
@@ -370,20 +346,17 @@ func main() {
flattenedTx = freezeColdWallet.Flatten()
err = client.Autofill(&flattenedTx)
if err != nil {
fmt.Printf("Error autofilling transaction: %s\n", err)
return
panic(err)
}
txBlob, _, err = coldWallet.Sign(flattenedTx)
if err != nil {
fmt.Printf("Error signing transaction: %s\n", err)
return
panic(err)
}
response, err = client.SubmitTxBlobAndWait(txBlob, false)
if err != nil {
fmt.Printf("Error submitting transaction: %s\n", err)
return
panic(err)
}
if !response.Validated {
@@ -416,14 +389,12 @@ func main() {
flattenedTx = hotToCustomerOnePayment.Flatten()
err = client.Autofill(&flattenedTx)
if err != nil {
fmt.Printf("Error autofilling transaction: %s\n", err)
return
panic(err)
}
txBlob, _, err = hotWallet.Sign(flattenedTx)
if err != nil {
fmt.Printf("Error signing transaction: %s\n", err)
return
panic(err)
}
_, err = client.SubmitTxBlobAndWait(txBlob, false)
@@ -449,20 +420,17 @@ func main() {
flattenedTx = unfreezeColdWallet.Flatten()
err = client.Autofill(&flattenedTx)
if err != nil {
fmt.Printf("Error autofilling transaction: %s\n", err)
return
panic(err)
}
txBlob, _, err = coldWallet.Sign(flattenedTx)
if err != nil {
fmt.Printf("Error signing transaction: %s\n", err)
return
panic(err)
}
response, err = client.SubmitTxBlobAndWait(txBlob, false)
if err != nil {
fmt.Printf("Error submitting transaction: %s\n", err)
return
panic(err)
}
if !response.Validated {
@@ -495,20 +463,17 @@ func main() {
flattenedTx = hotToCustomerOnePayment.Flatten()
err = client.Autofill(&flattenedTx)
if err != nil {
fmt.Printf("Error autofilling transaction: %s\n", err)
return
panic(err)
}
txBlob, _, err = hotWallet.Sign(flattenedTx)
if err != nil {
fmt.Printf("Error signing transaction: %s\n", err)
return
panic(err)
}
response, err = client.SubmitTxBlobAndWait(txBlob, false)
if err != nil {
fmt.Printf("Error submitting transaction: %s\n", err)
return
panic(err)
}
if !response.Validated {

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

@@ -31,8 +31,7 @@ func main() {
fmt.Println("Connecting to server...")
if err := client.Connect(); err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Connection: ", client.IsConnected())
@@ -44,37 +43,31 @@ func main() {
fmt.Println("Setting up wallets...")
coldWallet, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Printf("Error creating cold wallet: %s\n", err)
return
panic(err)
}
err = client.FundWallet(&coldWallet)
if err != nil {
fmt.Printf("Error funding cold wallet: %s\n", err)
return
panic(err)
}
fmt.Println("Cold wallet funded!")
hotWallet, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Printf("Error creating hot wallet: %s\n", err)
return
panic(err)
}
err = client.FundWallet(&hotWallet)
if err != nil {
fmt.Printf("Error funding hot wallet: %s\n", err)
return
panic(err)
}
fmt.Println("Hot wallet funded!")
customerOneWallet, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Printf("Error creating token wallet: %s\n", err)
return
panic(err)
}
err = client.FundWallet(&customerOneWallet)
if err != nil {
fmt.Printf("Error funding customer one wallet: %s\n", err)
return
panic(err)
}
fmt.Println("Customer one wallet funded!")
fmt.Println()
@@ -107,20 +100,17 @@ func main() {
err = client.Autofill(&flattenedTx)
if err != nil {
fmt.Printf("Error autofilling transaction: %s\n", err)
return
panic(err)
}
txBlob, _, err := coldWallet.Sign(flattenedTx)
if err != nil {
fmt.Printf("Error signing transaction: %s\n", err)
return
panic(err)
}
response, err := client.SubmitTxBlobAndWait(txBlob, false)
if err != nil {
fmt.Printf("Error submitting transaction: %s\n", err)
return
panic(err)
}
if !response.Validated {
@@ -152,20 +142,17 @@ func main() {
flattenedTx = hotWalletAccountSet.Flatten()
err = client.Autofill(&flattenedTx)
if err != nil {
fmt.Printf("Error autofilling transaction: %s\n", err)
return
panic(err)
}
txBlob, _, err = hotWallet.Sign(flattenedTx)
if err != nil {
fmt.Printf("Error signing transaction: %s\n", err)
return
panic(err)
}
response, err = client.SubmitTxBlobAndWait(txBlob, false)
if err != nil {
fmt.Printf("Error submitting transaction: %s\n", err)
return
panic(err)
}
if !response.Validated {
@@ -197,20 +184,17 @@ func main() {
flattenedTx = hotColdTrustSet.Flatten()
err = client.Autofill(&flattenedTx)
if err != nil {
fmt.Printf("Error autofilling transaction: %s\n", err)
return
panic(err)
}
txBlob, _, err = hotWallet.Sign(flattenedTx)
if err != nil {
fmt.Printf("Error signing transaction: %s\n", err)
return
panic(err)
}
response, err = client.SubmitTxBlobAndWait(txBlob, false)
if err != nil {
fmt.Printf("Error submitting transaction: %s\n", err)
return
panic(err)
}
if !response.Validated {
@@ -242,20 +226,17 @@ func main() {
flattenedTx = customerOneColdTrustSet.Flatten()
err = client.Autofill(&flattenedTx)
if err != nil {
fmt.Printf("Error autofilling transaction: %s\n", err)
return
panic(err)
}
txBlob, _, err = customerOneWallet.Sign(flattenedTx)
if err != nil {
fmt.Printf("Error signing transaction: %s\n", err)
return
panic(err)
}
response, err = client.SubmitTxBlobAndWait(txBlob, false)
if err != nil {
fmt.Printf("Error submitting transaction: %s\n", err)
return
panic(err)
}
if !response.Validated {
@@ -289,20 +270,17 @@ func main() {
flattenedTx = coldToHotPayment.Flatten()
err = client.Autofill(&flattenedTx)
if err != nil {
fmt.Printf("Error autofilling transaction: %s\n", err)
return
panic(err)
}
txBlob, _, err = coldWallet.Sign(flattenedTx)
if err != nil {
fmt.Printf("Error signing transaction: %s\n", err)
return
panic(err)
}
response, err = client.SubmitTxBlobAndWait(txBlob, false)
if err != nil {
fmt.Printf("Error submitting transaction: %s\n", err)
return
panic(err)
}
if !response.Validated {
@@ -335,20 +313,17 @@ func main() {
flattenedTx = coldToCustomerOnePayment.Flatten()
err = client.Autofill(&flattenedTx)
if err != nil {
fmt.Printf("Error autofilling transaction: %s\n", err)
return
panic(err)
}
txBlob, _, err = coldWallet.Sign(flattenedTx)
if err != nil {
fmt.Printf("Error signing transaction: %s\n", err)
return
panic(err)
}
response, err = client.SubmitTxBlobAndWait(txBlob, false)
if err != nil {
fmt.Printf("Error submitting transaction: %s\n", err)
return
panic(err)
}
if !response.Validated {
@@ -376,20 +351,17 @@ func main() {
flattenedTx = freezeColdWallet.Flatten()
err = client.Autofill(&flattenedTx)
if err != nil {
fmt.Printf("Error autofilling transaction: %s\n", err)
return
panic(err)
}
txBlob, _, err = coldWallet.Sign(flattenedTx)
if err != nil {
fmt.Printf("Error signing transaction: %s\n", err)
return
panic(err)
}
response, err = client.SubmitTxBlobAndWait(txBlob, false)
if err != nil {
fmt.Printf("Error submitting transaction: %s\n", err)
return
panic(err)
}
if !response.Validated {
@@ -422,14 +394,12 @@ func main() {
flattenedTx = hotToCustomerOnePayment.Flatten()
err = client.Autofill(&flattenedTx)
if err != nil {
fmt.Printf("Error autofilling transaction: %s\n", err)
return
panic(err)
}
txBlob, _, err = hotWallet.Sign(flattenedTx)
if err != nil {
fmt.Printf("Error signing transaction: %s\n", err)
return
panic(err)
}
_, err = client.SubmitTxBlobAndWait(txBlob, false)
@@ -455,20 +425,17 @@ func main() {
flattenedTx = unfreezeColdWallet.Flatten()
err = client.Autofill(&flattenedTx)
if err != nil {
fmt.Printf("Error autofilling transaction: %s\n", err)
return
panic(err)
}
txBlob, _, err = coldWallet.Sign(flattenedTx)
if err != nil {
fmt.Printf("Error signing transaction: %s\n", err)
return
panic(err)
}
response, err = client.SubmitTxBlobAndWait(txBlob, false)
if err != nil {
fmt.Printf("Error submitting transaction: %s\n", err)
return
panic(err)
}
if !response.Validated {
@@ -501,20 +468,17 @@ func main() {
flattenedTx = hotToCustomerOnePayment.Flatten()
err = client.Autofill(&flattenedTx)
if err != nil {
fmt.Printf("Error autofilling transaction: %s\n", err)
return
panic(err)
}
txBlob, _, err = hotWallet.Sign(flattenedTx)
if err != nil {
fmt.Printf("Error signing transaction: %s\n", err)
return
panic(err)
}
response, err = client.SubmitTxBlobAndWait(txBlob, false)
if err != nil {
fmt.Printf("Error submitting transaction: %s\n", err)
return
panic(err)
}
if !response.Validated {

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

@@ -43,7 +43,7 @@ func main() {
// make the connection
c, _, err := websocket.DefaultDialer.Dial(u.String(), nil)
if err != nil {
log.Fatal("dial:", err)
panic(err)
}
// on exit close
defer c.Close()
@@ -59,15 +59,13 @@ func main() {
// write to the websocket
err = c.WriteMessage(websocket.TextMessage, []byte(string(msg)))
if err != nil {
log.Println("write:", err)
return
panic(err)
}
// read from the websocket
_, message, err := c.ReadMessage()
if err != nil {
log.Println("read:", err)
return
panic(err)
}
// print the response from the XRP Ledger
log.Printf("recv: %s", message)
@@ -84,8 +82,7 @@ func main() {
// waiting (with timeout) for the server to close the connection.
err := c.WriteMessage(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseNormalClosure, ""))
if err != nil {
log.Println("write close:", err)
return
panic(err)
}
select {
case <-done:

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

@@ -28,40 +28,34 @@ func main() {
w1, err := wallet.FromSeed("sEdTtvLmJmrb7GaivhWoXRkvU4NDjVf", "")
if err != nil {
fmt.Println(err)
return
panic(err)
}
w2, err := wallet.FromSeed("sEdSFiKMQp7RvYLgH7t7FEpwNRWv2Gr", "")
if err != nil {
fmt.Println(err)
return
panic(err)
}
master, err := wallet.FromSeed("sEdTMm2yv8c8Rg8YHFHQA9TxVMFy1ze", "")
if err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Funding wallets...")
if err := client.FundWallet(&w1); err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Wallet 1 funded")
if err := client.FundWallet(&w2); err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Wallet 2 funded")
if err := client.FundWallet(&master); err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Master wallet funded")
fmt.Println()
@@ -97,20 +91,17 @@ func main() {
flatSs := ss.Flatten()
if err := client.Autofill(&flatSs); err != nil {
fmt.Println(err)
return
panic(err)
}
blob, _, err := master.Sign(flatSs)
if err != nil {
fmt.Println(err)
return
panic(err)
}
res, err := client.SubmitTxBlobAndWait(blob, false)
if err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("SignerListSet transaction submitted!")
@@ -129,36 +120,31 @@ func main() {
flatAs := as.Flatten()
if err := client.AutofillMultisigned(&flatAs, 2); err != nil {
fmt.Println(err)
return
panic(err)
}
w1As := maps.Clone(flatAs)
blob1, _, err := w1.Multisign(w1As)
if err != nil {
fmt.Println(err)
return
panic(err)
}
w2As := maps.Clone(flatAs)
blob2, _, err := w2.Multisign(w2As)
if err != nil {
fmt.Println(err)
return
panic(err)
}
blob, err = xrpl.Multisign(blob1, blob2)
if err != nil {
fmt.Println(err)
return
panic(err)
}
mRes, err := client.SubmitMultisigned(blob, false)
if err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Multisigned transaction submitted!")

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

@@ -25,8 +25,7 @@ func main() {
defer client.Disconnect()
if err := client.Connect(); err != nil {
fmt.Println(err)
return
panic(err)
}
if !client.IsConnected() {
@@ -39,40 +38,34 @@ func main() {
w1, err := wallet.FromSeed("sEdTtvLmJmrb7GaivhWoXRkvU4NDjVf", "")
if err != nil {
fmt.Println(err)
return
panic(err)
}
w2, err := wallet.FromSeed("sEdSFiKMQp7RvYLgH7t7FEpwNRWv2Gr", "")
if err != nil {
fmt.Println(err)
return
panic(err)
}
master, err := wallet.FromSeed("sEdTMm2yv8c8Rg8YHFHQA9TxVMFy1ze", "")
if err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Funding wallets...")
if err := client.FundWallet(&w1); err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Wallet 1 funded")
if err := client.FundWallet(&w2); err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Wallet 2 funded")
if err := client.FundWallet(&master); err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Master wallet funded")
fmt.Println()
@@ -110,22 +103,19 @@ func main() {
fmt.Println("Autofilling transaction...")
if err := client.Autofill(&flatSs); err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Signing transaction...")
blob, _, err := master.Sign(flatSs)
if err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Submitting transaction...")
res, err := client.SubmitTxBlobAndWait(blob, false)
if err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("SignerListSet transaction submitted!")
@@ -144,36 +134,31 @@ func main() {
flatAs := as.Flatten()
if err := client.AutofillMultisigned(&flatAs, 2); err != nil {
fmt.Println(err)
return
panic(err)
}
w1As := maps.Clone(flatAs)
blob1, _, err := w1.Multisign(w1As)
if err != nil {
fmt.Println(err)
return
panic(err)
}
w2As := maps.Clone(flatAs)
blob2, _, err := w2.Multisign(w2As)
if err != nil {
fmt.Println(err)
return
panic(err)
}
blob, err = xrpl.Multisign(blob1, blob2)
if err != nil {
fmt.Println(err)
return
panic(err)
}
mRes, err := client.SubmitMultisigned(blob, false)
if err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Multisigned transaction submitted!")

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

@@ -31,24 +31,20 @@ func main() {
// Create and fund the NFT minter wallet
nftMinter, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Println("Error creating NFT minter wallet:", err)
return
panic(err)
}
if err := client.FundWallet(&nftMinter); err != nil {
fmt.Println("Error funding NFT minter wallet:", err)
return
panic(err)
}
fmt.Println("NFT minter wallet funded!")
// Create and fund the NFT buyer wallet
nftBuyer, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Println("Error creating NFT buyer wallet:", err)
return
panic(err)
}
if err := client.FundWallet(&nftBuyer); err != nil {
fmt.Println("Error funding NFT buyer wallet:", err)
return
panic(err)
}
fmt.Println("NFT buyer wallet funded!")
fmt.Println()
@@ -73,8 +69,7 @@ func main() {
Wallet: &nftMinter,
})
if err != nil {
fmt.Println("Error minting NFT:", err)
return
panic(err)
}
if !responseMint.Validated {
fmt.Println("NFTokenMint txn is not in a validated ledger", responseMint)
@@ -117,8 +112,7 @@ func main() {
Wallet: &nftBuyer,
})
if err != nil {
fmt.Println("Error accepting NFT offer:", err)
return
panic(err)
}
if !response.Validated {
fmt.Println("NFTokenAcceptOffer txn is not in a validated ledger", response)

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

@@ -23,8 +23,7 @@ func main() {
defer client.Disconnect()
if err := client.Connect(); err != nil {
fmt.Println("Error connecting to devnet:", err)
return
panic(err)
}
if !client.IsConnected() {
@@ -40,24 +39,20 @@ func main() {
// Create and fund the NFT minter wallet
nftMinter, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Println("Error creating NFT minter wallet:", err)
return
panic(err)
}
if err := client.FundWallet(&nftMinter); err != nil {
fmt.Println("Error funding NFT minter wallet:", err)
return
panic(err)
}
fmt.Println("NFT minter wallet funded!")
// Create and fund the NFT buyer wallet
nftBuyer, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Println("Error creating NFT buyer wallet:", err)
return
panic(err)
}
if err := client.FundWallet(&nftBuyer); err != nil {
fmt.Println("Error funding NFT buyer wallet:", err)
return
panic(err)
}
fmt.Println("NFT buyer wallet funded!")
fmt.Println()
@@ -81,8 +76,7 @@ func main() {
Wallet: &nftMinter,
})
if err != nil {
fmt.Println("Error minting NFT:", err)
return
panic(err)
}
if !responseMint.Validated {
fmt.Println("NFTokenMint transaction is not in a validated ledger:", responseMint)
@@ -122,8 +116,7 @@ func main() {
Wallet: &nftBuyer,
})
if err != nil {
fmt.Println("Error accepting NFT offer:", err)
return
panic(err)
}
if !response.Validated {
fmt.Println("NFTokenAcceptOffer transaction is not in a validated ledger:", response)

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

@@ -31,12 +31,10 @@ func main() {
// Create and fund the NFT minter wallet
nftMinter, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Println("Error creating NFT minter wallet:", err)
return
panic(err)
}
if err := client.FundWallet(&nftMinter); err != nil {
fmt.Println("Error funding NFT minter wallet:", err)
return
panic(err)
}
fmt.Println("NFT minter wallet funded!")
fmt.Println()
@@ -59,8 +57,7 @@ func main() {
Wallet: &nftMinter,
})
if err != nil {
fmt.Println("Error minting NFT:", err)
return
panic(err)
}
if !responseMint.Validated {
fmt.Println("NFTokenMint txn is not in a validated ledger", responseMint)
@@ -103,8 +100,7 @@ func main() {
Wallet: &nftMinter,
})
if err != nil {
fmt.Println("Error burning NFT:", err)
return
panic(err)
}
if !responseBurn.Validated {
fmt.Println("NFTokenBurn transactiob is not in a validated ledger", responseBurn)

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

@@ -23,8 +23,7 @@ func main() {
defer client.Disconnect()
if err := client.Connect(); err != nil {
fmt.Println("Error connecting to devnet:", err)
return
panic(err)
}
if !client.IsConnected() {
@@ -40,12 +39,10 @@ func main() {
// Create and fund the NFT minter wallet
nftMinter, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Println("Error creating NFT minter wallet:", err)
return
panic(err)
}
if err := client.FundWallet(&nftMinter); err != nil {
fmt.Println("Error funding NFT minter wallet:", err)
return
panic(err)
}
fmt.Println("NFT minter wallet funded!")
fmt.Println()
@@ -68,8 +65,7 @@ func main() {
Wallet: &nftMinter,
})
if err != nil {
fmt.Println("Error minting NFT:", err)
return
panic(err)
}
if !responseMint.Validated {
fmt.Println("NFTokenMint txn is not in a validated ledger", responseMint)
@@ -112,8 +108,7 @@ func main() {
Wallet: &nftMinter,
})
if err != nil {
fmt.Println("Error burning NFT:", err)
return
panic(err)
}
if !responseBurn.Validated {
fmt.Println("NFTokenBurn transactiob is not in a validated ledger", responseBurn)

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

@@ -31,12 +31,10 @@ func main() {
// Create and fund the NFT minter wallet
nftMinter, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Println("Error creating NFT minter wallet:", err)
return
panic(err)
}
if err := client.FundWallet(&nftMinter); err != nil {
fmt.Println("Error funding NFT minter wallet:", err)
return
panic(err)
}
fmt.Println("NFT minter wallet funded!")
@@ -58,8 +56,7 @@ func main() {
Wallet: &nftMinter,
})
if err != nil {
fmt.Println("Error minting first NFT:", err)
return
panic(err)
}
if !responseMint.Validated {
fmt.Println("First NFTokenMint transaction is not in a validated ledger", responseMint)
@@ -105,8 +102,7 @@ func main() {
Wallet: &nftMinter,
})
if err != nil {
fmt.Println("Error minting second NFT:", err)
return
panic(err)
}
if !responseMint.Validated {
fmt.Println("Second NFTokenMint transaction is not in a validated ledger", responseMint)
@@ -152,8 +148,7 @@ func main() {
Wallet: &nftMinter,
})
if err != nil {
fmt.Println("Error canceling NFT offers:", err)
return
panic(err)
}
if !response.Validated {
fmt.Println("NFTokenCancelOffer transaction is not in a validated ledger", response)

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

@@ -23,8 +23,7 @@ func main() {
defer client.Disconnect()
if err := client.Connect(); err != nil {
fmt.Println("Error connecting to devnet:", err)
return
panic(err)
}
if !client.IsConnected() {
@@ -40,12 +39,10 @@ func main() {
// Create and fund the NFT minter wallet
nftMinter, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Println("Error creating NFT minter wallet:", err)
return
panic(err)
}
if err := client.FundWallet(&nftMinter); err != nil {
fmt.Println("Error funding NFT minter wallet:", err)
return
panic(err)
}
fmt.Println("NFT minter wallet funded!")
@@ -67,8 +64,7 @@ func main() {
Wallet: &nftMinter,
})
if err != nil {
fmt.Println("Error minting first NFT:", err)
return
panic(err)
}
if !responseMint.Validated {
fmt.Println("First NFTokenMint transaction is not in a validated ledger", responseMint)
@@ -114,8 +110,7 @@ func main() {
Wallet: &nftMinter,
})
if err != nil {
fmt.Println("Error minting second NFT:", err)
return
panic(err)
}
if !responseMint.Validated {
fmt.Println("Second NFTokenMint transaction is not in a validated ledger", responseMint)
@@ -161,8 +156,7 @@ func main() {
Wallet: &nftMinter,
})
if err != nil {
fmt.Println("Error canceling NFT offers:", err)
return
panic(err)
}
if !response.Validated {
fmt.Println("NFTokenCancelOffer transaction is not in a validated ledger", response)

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

@@ -29,12 +29,10 @@ func main() {
// Create and fund the nft wallet
nftWallet, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Println("Error creating nft wallet:", err)
return
panic(err)
}
if err := client.FundWallet(&nftWallet); err != nil {
fmt.Println("Error funding nft wallet:", err)
return
panic(err)
}
fmt.Println("NFT wallet funded: ", nftWallet.ClassicAddress)
fmt.Println()
@@ -56,8 +54,7 @@ func main() {
Wallet: &nftWallet,
})
if err != nil {
fmt.Println("Error minting NFT:", err)
return
panic(err)
}
if !responseMint.Validated {
fmt.Println("NFTokenMint txn is not in a validated ledger", responseMint)
@@ -96,8 +93,7 @@ func main() {
Wallet: &nftWallet,
})
if err != nil {
fmt.Println("Error modifying NFT:", err)
return
panic(err)
}
if !responseModify.Validated {
fmt.Println("NFTokenModify txn is not in a validated ledger", responseModify)

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

@@ -23,8 +23,7 @@ func main() {
defer client.Disconnect()
if err := client.Connect(); err != nil {
fmt.Println(err)
return
panic(err)
}
if !client.IsConnected() {
@@ -39,12 +38,10 @@ func main() {
fmt.Println("Funding wallet...")
nftWallet, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Println("Error creating nft wallet:", err)
return
panic(err)
}
if err := client.FundWallet(&nftWallet); err != nil {
fmt.Println("Error funding nft wallet:", err)
return
panic(err)
}
fmt.Println("NFT wallet funded!")
fmt.Println()
@@ -66,8 +63,7 @@ func main() {
Wallet: &nftWallet,
})
if err != nil {
fmt.Println("Error minting NFT:", err)
return
panic(err)
}
if !responseMint.Validated {
fmt.Println("NFTokenMint txn is not in a validated ledger", responseMint)
@@ -106,8 +102,7 @@ func main() {
Wallet: &nftWallet,
})
if err != nil {
fmt.Println("Error modifying NFT:", err)
return
panic(err)
}
if !responseModify.Validated {
fmt.Println("NFTokenModify txn is not in a validated ledger", responseModify)

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

@@ -26,24 +26,20 @@ func main() {
fmt.Println("Funding wallets...")
w1, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Println(err)
return
panic(err)
}
w2, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Println(err)
return
panic(err)
}
if err := client.FundWallet(&w1); err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Wallet 1 funded")
if err := client.FundWallet(&w2); err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Wallet 2 funded")
@@ -67,20 +63,17 @@ func main() {
err = client.Autofill(&flatTs)
if err != nil {
fmt.Println(err)
return
panic(err)
}
blob, _, err := w2.Sign(flatTs)
if err != nil {
fmt.Println(err)
return
panic(err)
}
res, err := client.SubmitTxBlobAndWait(blob, false)
if err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("TrustSet transaction submitted!")
@@ -105,20 +98,17 @@ func main() {
err = client.Autofill(&flatP)
if err != nil {
fmt.Println(err)
return
panic(err)
}
blob, _, err = w1.Sign(flatP)
if err != nil {
fmt.Println(err)
return
panic(err)
}
res, err = client.SubmitTxBlobAndWait(blob, false)
if err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Payment transaction submitted!")
@@ -145,20 +135,17 @@ func main() {
err = client.Autofill(&flatPP)
if err != nil {
fmt.Println(err)
return
panic(err)
}
blob, _, err = w2.Sign(flatPP)
if err != nil {
fmt.Println(err)
return
panic(err)
}
res, err = client.SubmitTxBlobAndWait(blob, false)
if err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Partial Payment transaction submitted!")

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

@@ -22,8 +22,7 @@ func main() {
defer client.Disconnect()
if err := client.Connect(); err != nil {
fmt.Println(err)
return
panic(err)
}
if !client.IsConnected() {
@@ -37,24 +36,20 @@ func main() {
fmt.Println("Funding wallets...")
w1, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Println(err)
return
panic(err)
}
w2, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Println(err)
return
panic(err)
}
if err := client.FundWallet(&w1); err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Wallet 1 funded")
if err := client.FundWallet(&w2); err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Wallet 2 funded")
@@ -78,20 +73,17 @@ func main() {
err = client.Autofill(&flatTs)
if err != nil {
fmt.Println(err)
return
panic(err)
}
blob, _, err := w2.Sign(flatTs)
if err != nil {
fmt.Println(err)
return
panic(err)
}
res, err := client.SubmitTxBlobAndWait(blob, false)
if err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("TrustSet transaction submitted!")
@@ -116,20 +108,17 @@ func main() {
err = client.Autofill(&flatP)
if err != nil {
fmt.Println(err)
return
panic(err)
}
blob, _, err = w1.Sign(flatP)
if err != nil {
fmt.Println(err)
return
panic(err)
}
res, err = client.SubmitTxBlobAndWait(blob, false)
if err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Payment transaction submitted!")
@@ -156,20 +145,17 @@ func main() {
err = client.Autofill(&flatPP)
if err != nil {
fmt.Println(err)
return
panic(err)
}
blob, _, err = w2.Sign(flatPP)
if err != nil {
fmt.Println(err)
return
panic(err)
}
res, err = client.SubmitTxBlobAndWait(blob, false)
if err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Partial Payment transaction submitted!")

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

@@ -39,14 +39,12 @@ func main() {
wallet, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Funding wallet...")
if err := client.FundWallet(&wallet); err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Wallet funded")
@@ -64,8 +62,7 @@ func main() {
DestinationAmount: DestinationAmount,
})
if err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Printf("Computed paths: %d\n", len(res.Alternatives))
@@ -89,20 +86,17 @@ func main() {
flatP := p.Flatten()
if err := client.Autofill(&flatP); err != nil {
fmt.Println(err)
return
panic(err)
}
blob, hash, err := wallet.Sign(flatP)
if err != nil {
fmt.Println(err)
return
panic(err)
}
txRes, err := client.SubmitTxBlobAndWait(blob, false)
if err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Payment submitted")

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

@@ -36,8 +36,7 @@ func main() {
defer client.Disconnect()
if err := client.Connect(); err != nil {
fmt.Println(err)
return
panic(err)
}
if !client.IsConnected() {
@@ -50,14 +49,12 @@ func main() {
wallet, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Funding wallet...")
if err := client.FundWallet(&wallet); err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Wallet funded")
@@ -75,8 +72,7 @@ func main() {
DestinationAmount: DestinationAmount,
})
if err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Printf("Computed paths: %d\n", len(res.Alternatives))
@@ -100,20 +96,17 @@ func main() {
flatP := p.Flatten()
if err := client.Autofill(&flatP); err != nil {
fmt.Println(err)
return
panic(err)
}
blob, hash, err := wallet.Sign(flatP)
if err != nil {
fmt.Println(err)
return
panic(err)
}
txRes, err := client.SubmitTxBlobAndWait(blob, false)
if err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Payment submitted")

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

@@ -16,14 +16,12 @@ import (
func main() {
w, err := wallet.FromSeed("sEdSMVV4dJ1JbdBxmakRR4Puu3XVZz2", "")
if err != nil {
fmt.Println(err)
return
panic(err)
}
receiverWallet, err := wallet.FromSeed("sEd7d8Ci9nevdLCeUMctF3uGXp9WQqJ", "")
if err != nil {
fmt.Println(err)
return
panic(err)
}
cfg, err := rpc.NewClientConfig(
@@ -42,8 +40,7 @@ func main() {
fmt.Println("Funding wallet...")
err = client.FundWallet(&w)
if err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Wallet funded")
}
@@ -54,14 +51,12 @@ func main() {
amount, err := currency.XrpToDrops("1")
if err != nil {
fmt.Println(err)
return
panic(err)
}
amountUint, err := strconv.ParseUint(amount, 10, 64)
if err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Sending payment...")
@@ -93,20 +88,17 @@ func main() {
err = client.Autofill(&flatTx)
if err != nil {
fmt.Println(err)
return
panic(err)
}
txBlob, _, err := w.Sign(flatTx)
if err != nil {
fmt.Println(err)
return
panic(err)
}
response, err := client.SubmitTxBlobAndWait(txBlob, true)
if err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Payment submitted")

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

@@ -16,14 +16,12 @@ import (
func main() {
w, err := wallet.FromSeed("sEdSMVV4dJ1JbdBxmakRR4Puu3XVZz2", "")
if err != nil {
fmt.Println(err)
return
panic(err)
}
receiverWallet, err := wallet.FromSeed("sEd7d8Ci9nevdLCeUMctF3uGXp9WQqJ", "")
if err != nil {
fmt.Println(err)
return
panic(err)
}
client := websocket.NewClient(
@@ -35,8 +33,7 @@ func main() {
fmt.Println("Connecting to server...")
if err := client.Connect(); err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Connected to server")
@@ -48,8 +45,7 @@ func main() {
fmt.Println("Funding wallet...")
err = client.FundWallet(&w)
if err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Wallet funded")
}
@@ -60,14 +56,12 @@ func main() {
amount, err := currency.XrpToDrops("1")
if err != nil {
fmt.Println(err)
return
panic(err)
}
amountUint, err := strconv.ParseUint(amount, 10, 64)
if err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Sending payment...")
@@ -99,20 +93,17 @@ func main() {
err = client.Autofill(&flatTx)
if err != nil {
fmt.Println(err)
return
panic(err)
}
txBlob, _, err := w.Sign(flatTx)
if err != nil {
fmt.Println(err)
return
panic(err)
}
response, err := client.SubmitTxBlobAndWait(txBlob, true)
if err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Payment submitted")

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

@@ -34,14 +34,12 @@ func main() {
w, err := wallet.FromSeed(WalletSeed, "")
if err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Funding wallet...")
if err := client.FundWallet(&w); err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Wallet funded")
@@ -49,14 +47,12 @@ func main() {
xrpAmount, err := currency.XrpToDrops("1")
if err != nil {
fmt.Println(err)
return
panic(err)
}
xrpAmountInt, err := strconv.ParseInt(xrpAmount, 10, 64)
if err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Sending 1 XRP to rPT1Sjq2YGrBMTttX4GZHjKu9dyfzbpAYe...")
@@ -72,20 +68,17 @@ func main() {
flattenedTx := p.Flatten()
if err := client.Autofill(&flattenedTx); err != nil {
fmt.Println(err)
return
panic(err)
}
txBlob, _, err := w.Sign(flattenedTx)
if err != nil {
fmt.Println(err)
return
panic(err)
}
res, err := client.SubmitTxBlobAndWait(txBlob, false)
if err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Payment submitted")
@@ -101,8 +94,7 @@ func main() {
Wallet: &w,
})
if err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Payment submitted via SubmitTxAndWait")

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

@@ -23,8 +23,7 @@ client := websocket.NewClient(
defer client.Disconnect()
if err := client.Connect(); err != nil {
fmt.Println(err)
return
panic(err)
}
if !client.IsConnected() {
@@ -39,15 +38,13 @@ fmt.Println()
const WalletSeed = "sEd7zwWAu7vXMCBkkzokJHEXiKw2B2s"
w, err := wallet.FromSeed(WalletSeed, "")
if err != nil {
fmt.Println(err)
return
panic(err)
}
// Funding the wallet
fmt.Println("Funding wallet...")
if err := client.FundWallet(&w); err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Wallet funded")
@@ -55,14 +52,12 @@ fmt.Println()
xrpAmount, err := currency.XrpToDrops("1")
if err != nil {
fmt.Println(err)
return
panic(err)
}
xrpAmountInt, err := strconv.ParseInt(xrpAmount, 10, 64)
if err != nil {
fmt.Println(err)
return
panic(err)
}
// Prepare a payment transaction
@@ -78,22 +73,19 @@ p := &transaction.Payment{
flattenedTx := p.Flatten()
if err := client.Autofill(&flattenedTx); err != nil {
fmt.Println(err)
return
panic(err)
}
// Sign the transaction using the wallet
txBlob, _, err := w.Sign(flattenedTx)
if err != nil {
fmt.Println(err)
return
panic(err)
}
// Submit the transaction and wait for the result
res_blob, err := client.SubmitTxBlobAndWait(txBlob, false)
if err != nil {
fmt.Println(err)
return
panic(err)
}
// Example with SubmitTxAndWait
@@ -103,8 +95,7 @@ res_flat, err := client.SubmitTxAndWait(flattenedTx2, &wstypes.SubmitOptions{
Wallet: &w,
})
if err != nil {
fmt.Println(err)
return
panic(err)
}
// Wait for validation -------------------------------------------------------
// SubmitTxBlobAndWait() handles this automatically, but it can take 4-7s.

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

@@ -24,40 +24,34 @@ func main() {
w1, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Println(err)
return
panic(err)
}
w2, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Println(err)
return
panic(err)
}
regularKeyWallet, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Funding wallets...")
if err := client.FundWallet(&w1); err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Wallet 1 funded")
if err := client.FundWallet(&w2); err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Wallet 2 funded")
if err := client.FundWallet(&regularKeyWallet); err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Regular key wallet funded")
@@ -75,20 +69,17 @@ func main() {
err = client.Autofill(&flatRk)
if err != nil {
fmt.Println(err)
return
panic(err)
}
blob, _, err := w1.Sign(flatRk)
if err != nil {
fmt.Println(err)
return
panic(err)
}
res, err := client.SubmitTxBlobAndWait(blob, false)
if err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("SetRegularKey transaction submitted")
@@ -109,20 +100,17 @@ func main() {
err = client.Autofill(&flatP)
if err != nil {
fmt.Println(err)
return
panic(err)
}
blob, _, err = regularKeyWallet.Sign(flatP)
if err != nil {
fmt.Println(err)
return
panic(err)
}
res, err = client.SubmitTxBlobAndWait(blob, false)
if err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Payment transaction submitted")

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

@@ -21,8 +21,7 @@ func main() {
defer client.Disconnect()
if err := client.Connect(); err != nil {
fmt.Println(err)
return
panic(err)
}
if !client.IsConnected() {
@@ -35,40 +34,34 @@ func main() {
w1, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Println(err)
return
panic(err)
}
w2, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Println(err)
return
panic(err)
}
regularKeyWallet, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Funding wallets...")
if err := client.FundWallet(&w1); err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Wallet 1 funded")
if err := client.FundWallet(&w2); err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Wallet 2 funded")
if err := client.FundWallet(&regularKeyWallet); err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Regular key wallet funded")
@@ -86,20 +79,17 @@ func main() {
err = client.Autofill(&flatRk)
if err != nil {
fmt.Println(err)
return
panic(err)
}
blob, _, err := w1.Sign(flatRk)
if err != nil {
fmt.Println(err)
return
panic(err)
}
res, err := client.SubmitTxBlobAndWait(blob, false)
if err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("SetRegularKey transaction submitted")
@@ -120,20 +110,17 @@ func main() {
err = client.Autofill(&flatP)
if err != nil {
fmt.Println(err)
return
panic(err)
}
blob, _, err = regularKeyWallet.Sign(flatP)
if err != nil {
fmt.Println(err)
return
panic(err)
}
res, err = client.SubmitTxBlobAndWait(blob, false)
if err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Payment transaction submitted")

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

@@ -25,14 +25,12 @@ func main() {
w, err := wallet.New(crypto.ED25519())
if err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Funding wallet...")
if err := client.FundWallet(&w); err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Wallet funded")
@@ -42,8 +40,7 @@ func main() {
Account: w.GetAddress(),
})
if err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Current wallet sequence:", info.AccountData.Sequence)
@@ -61,20 +58,17 @@ func main() {
flatTc := tc.Flatten()
if err := client.Autofill(&flatTc); err != nil {
fmt.Println(err)
return
panic(err)
}
blob, _, err := w.Sign(flatTc)
if err != nil {
fmt.Println(err)
return
panic(err)
}
res, err := client.SubmitTxBlobAndWait(blob, false)
if err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("TicketCreate transaction submitted")
@@ -86,16 +80,14 @@ func main() {
Account: w.GetAddress(),
})
if err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Account objects:", objects.AccountObjects[0]["TicketSequence"])
seq, err := objects.AccountObjects[0]["TicketSequence"].(json.Number).Int64()
if err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("Submitting AccountSet transaction...")
@@ -110,22 +102,19 @@ func main() {
flatAs := as.Flatten()
if err := client.Autofill(&flatAs); err != nil {
fmt.Println(err)
return
panic(err)
}
flatAs["Sequence"] = uint32(0)
blob, _, err = w.Sign(flatAs)
if err != nil {
fmt.Println(err)
return
panic(err)
}
res, err = client.SubmitTxBlobAndWait(blob, false)
if err != nil {
fmt.Println(err)
return
panic(err)
}
fmt.Println("AccountSet transaction submitted")