refactor(xrpl): custom errors

Author: GuillemGarciaDev

binary-codec/quality_test.go

@@ -22,7 +22,7 @@ func TestQualityCodec_Encode(t *testing.T) {
 		{
 			name:        "fail - invalid quality - invalid character",
 			input:       "invalid",
-			expectedErr: bigdecimal.ErrInvalidCharacter,
+			expectedErr: bigdecimal.ErrInvalidCharacter{Allowed: bigdecimal.AllowedCharacters},
 		},
 		{
 			name:        "fail - invalid quality - overflow",

binary-codec/types/amount_test.go

@@ -427,7 +427,7 @@ func TestSerializeIssuedCurrencyAmount(t *testing.T) {
 			inputCurrency: "USD",
 			inputIssuer:   "rvYAfWj5gh67oV6fW32ZzP3Aw4Eubs59B",
 			expected:      nil,
-			expectedErr:   fmt.Errorf("%w: only the following are allowed: %q", bigdecimal.ErrInvalidCharacter, bigdecimal.AllowedCharacters),
+			expectedErr:   bigdecimal.ErrInvalidCharacter{Allowed: bigdecimal.AllowedCharacters},
 		},
 		{
 			name:          "fail - invalid currency code",

pkg/big-decimal/big_decimal.go

@@ -2,7 +2,6 @@
 package bigdecimal
 
 import (
-	"fmt"
 	"math/big"
 	"regexp"
 	"strconv"
@@ -68,7 +67,9 @@ func NewBigDecimal(value string) (bd *BigDecimal, err error) {
 
 	// check if the value string contains only allowed characters
 	if !bigDecimalRegEx(value) {
-		return nil, fmt.Errorf("%w: only the following are allowed: %q", ErrInvalidCharacter, AllowedCharacters)
+		return nil, ErrInvalidCharacter{
+			Allowed: AllowedCharacters,
+		}
 
 	}
 

pkg/big-decimal/big_decimal_test.go

@@ -650,25 +650,25 @@ func TestNewBigDecimal(t *testing.T) {
 			name:      "contains invalid chars",
 			input:     "12345678r90.1234567890a",
 			expBigDec: nil,
-			expErr:    ErrInvalidCharacter,
+			expErr:    ErrInvalidCharacter{Allowed: AllowedCharacters},
 		},
 		{
 			name:      "contains multiple decimal points",
 			input:     "12345678.90.1234567890",
 			expBigDec: nil,
-			expErr:    ErrInvalidCharacter,
+			expErr:    ErrInvalidCharacter{Allowed: AllowedCharacters},
 		},
 		{
 			name:      "contains multiple 'e' or 'E'",
 			input:     "12345678e90E1234567890",
 			expBigDec: nil,
-			expErr:    ErrInvalidCharacter,
+			expErr:    ErrInvalidCharacter{Allowed: AllowedCharacters},
 		},
 		{
 			name:      "contains multiple '-' signs:  excluding the exponent sign",
 			input:     "-1234-567890.1234567890e-9",
 			expBigDec: nil,
-			expErr:    ErrInvalidCharacter,
+			expErr:    ErrInvalidCharacter{Allowed: AllowedCharacters},
 		},
 	}
 	for _, tc := range tt {

pkg/big-decimal/errors.go

@@ -2,11 +2,20 @@ package bigdecimal
 
 import (
 	"errors"
+	"fmt"
 )
 
 var (
-	// ErrInvalidCharacter is returned when a string contains disallowed characters.
-	ErrInvalidCharacter = errors.New("value contains invalid characters")
 	// ErrInvalidZeroValue indicates the value string represents zero or is invalid zero.
 	ErrInvalidZeroValue = errors.New("value cannot be zero")
 )
+
+// ErrInvalidCharacter is returned when a string contains disallowed characters.
+type ErrInvalidCharacter struct {
+	Allowed string
+}
+
+// Error implements the error interface for ErrInvalidCharacter
+func (e ErrInvalidCharacter) Error() string {
+	return fmt.Sprintf("value contains invalid character: sonly the following are allowed: %s", e.Allowed)
+}

xrpl/faucet/devnet.go

@@ -40,24 +40,28 @@ func (fp *DevnetFaucetProvider) FundWallet(address types.Address) error {
 	jsonPayload, err := json.Marshal(payload)
 
 	if err != nil {
-		return fmt.Errorf("%w: %v", ErrMarshalPayload, err)
+		return ErrMarshalPayload{
+			Err: err,
+		}
 	}
 
 	req, err := http.NewRequest(http.MethodPost, url, bytes.NewBuffer(jsonPayload))
 	if err != nil {
-		return fmt.Errorf("%w: %v", ErrCreateRequest, err)
+		return ErrCreateRequest{Err: err}
 	}
 	req.Header.Set("Content-Type", "application/json")
 
 	resp, err := http.DefaultClient.Do(req)
 	if err != nil {
-		return fmt.Errorf("%w: %v", ErrSendRequest, err)
+		return ErrSendRequest{Err: err}
 	}
 	defer func() {
 		_ = resp.Body.Close()
 	}()
 	if resp.StatusCode != http.StatusOK {
-		return fmt.Errorf("%w: %d", ErrUnexpectedStatusCode, resp.StatusCode)
+		return ErrUnexpectedStatusCode{
+			Code: resp.StatusCode,
+		}
 	}
 
 	return nil

xrpl/faucet/errors.go

@@ -1,17 +1,45 @@
 package faucet
 
-import "errors"
+import (
+	"fmt"
+)
 
-var (
-	// ErrMarshalPayload is returned when the faucet payload cannot be marshaled to JSON.
-	ErrMarshalPayload = errors.New("failed to marshal faucet payload")
+// ErrMarshalPayload is returned when the faucet payload cannot be marshaled to JSON.
+type ErrMarshalPayload struct {
+	Err error
+}
 
-	// ErrCreateRequest is returned when the faucet request cannot be created.
-	ErrCreateRequest = errors.New("failed to create faucet request")
+// Error implements the error interface for ErrMarshalPayload
+func (e ErrMarshalPayload) Error() string {
+	return fmt.Sprintf("failed to marshal faucet payload: %v", e.Err)
+}
 
-	// ErrSendRequest is returned when the faucet request cannot be sent.
-	ErrSendRequest = errors.New("failed to send POST request to faucet")
+// ErrCreateRequest is returned when the faucet request cannot be created.
+type ErrCreateRequest struct {
+	Err error
+}
 
-	// ErrUnexpectedStatusCode is returned when the faucet responds with a non-200 status code.
-	ErrUnexpectedStatusCode = errors.New("unexpected faucet response status code")
-)
+// Error implements the error interface for ErrCreateRequest
+func (e ErrCreateRequest) Error() string {
+	return fmt.Sprintf("failed to create faucet request: %v", e.Err)
+}
+
+// ErrSendRequest is returned when the faucet request cannot be sent.
+type ErrSendRequest struct {
+	Err error
+}
+
+// Error implements the error interface for ErrSendRequest
+func (e ErrSendRequest) Error() string {
+	return fmt.Sprintf("failed to send POST request to faucet: %v", e.Err)
+}
+
+// ErrUnexpectedStatusCode is returned when the faucet responds with a non-200 status code.
+type ErrUnexpectedStatusCode struct {
+	Code int
+}
+
+// Error implements the error interface for ErrUnexpectedStatusCode
+func (e ErrUnexpectedStatusCode) Error() string {
+	return fmt.Sprintf("unexpected faucet response status code: %d", e.Code)
+}

xrpl/faucet/testnet.go

@@ -40,24 +40,32 @@ func (fp *TestnetFaucetProvider) FundWallet(address types.Address) error {
 	jsonPayload, err := json.Marshal(payload)
 
 	if err != nil {
-		return fmt.Errorf("%w: %v", ErrMarshalPayload, err)
+		return ErrMarshalPayload{
+			Err: err,
+		}
 	}
 
 	req, err := http.NewRequest(http.MethodPost, url, bytes.NewBuffer(jsonPayload))
 	if err != nil {
-		return fmt.Errorf("%w: %v", ErrCreateRequest, err)
+		return ErrCreateRequest{
+			Err: err,
+		}
 	}
 	req.Header.Set("Content-Type", "application/json")
 
 	resp, err := http.DefaultClient.Do(req)
 	if err != nil {
-		return fmt.Errorf("%w: %v", ErrSendRequest, err)
+		return ErrSendRequest{
+			Err: err,
+		}
 	}
 	defer func() {
 		_ = resp.Body.Close()
 	}()
 	if resp.StatusCode != http.StatusOK {
-		return fmt.Errorf("%w: %d", ErrUnexpectedStatusCode, resp.StatusCode)
+		return ErrUnexpectedStatusCode{
+			Code: resp.StatusCode,
+		}
 	}
 
 	return nil

xrpl/ledger-entry-types/errors.go

@@ -2,24 +2,42 @@ package ledger
 
 import (
 	"errors"
+	"fmt"
 )
 
 var (
 	// ledger object
 
-	// ErrUnrecognizedLedgerObjectType is returned when an unrecognized ledger object type is encountered.
-	ErrUnrecognizedLedgerObjectType = errors.New("unrecognized LedgerObject type")
 	// ErrUnsupportedLedgerObjectType is returned when an unsupported ledger object type is encountered.
 	ErrUnsupportedLedgerObjectType = errors.New("unsupported ledger object type")
 
 	// oracle
 
-	// ErrPriceDataScale is returned when the scale is greater than the maximum allowed.
-	ErrPriceDataScale = errors.New("invalid price data scale")
 	// ErrPriceDataAssetPriceAndScale is returned when the asset price and scale are not set together.
 	ErrPriceDataAssetPriceAndScale = errors.New("asset price and scale must be set together")
 	// ErrPriceDataBaseAsset is returned when the base asset is required but not set.
 	ErrPriceDataBaseAsset = errors.New("base asset is required")
 	// ErrPriceDataQuoteAsset is returned when the quote asset is required but not set.
 	ErrPriceDataQuoteAsset = errors.New("quote asset is required")
 )
+
+// ErrPriceDataScale is returned when the scale is greater than the maximum allowed.
+type ErrPriceDataScale struct {
+	Value uint8
+	Limit uint8
+}
+
+// Error implements the error interface for ErrPriceDataScale
+func (e ErrPriceDataScale) Error() string {
+	return fmt.Sprintf("invalid price data scale: got %d, must be less than %d", e.Value, e.Limit)
+}
+
+// ErrUnrecognizedLedgerObjectType is returned when an unrecognized ledger object type is encountered.
+type ErrUnrecognizedLedgerObjectType struct {
+	Type interface{}
+}
+
+// Error implements the error interface for ErrUnrecognizedLedgerObjectType
+func (e ErrUnrecognizedLedgerObjectType) Error() string {
+	return fmt.Sprintf("unrecognized Ledger Object type: %v", e.Type)
+}

xrpl/ledger-entry-types/ledger_object.go

@@ -1,10 +1,5 @@
 package ledger
 
-import (
-	"encoding/json"
-	"fmt"
-)
-
 // EntryType represents the type of a ledger entry as a string identifier.
 type EntryType string
 
@@ -105,77 +100,7 @@ func EmptyLedgerObject(t string) (Object, error) {
 	case XChainOwnedCreateAccountClaimIDEntry:
 		return &XChainOwnedCreateAccountClaimID{}, nil
 	}
-	return nil, fmt.Errorf("%w: %q", ErrUnrecognizedLedgerObjectType, t)
-}
-
-// UnmarshalLedgerObject parses the provided JSON data into the correct ledger entry object based on its LedgerEntryType.
-func UnmarshalLedgerObject(data []byte) (Object, error) {
-	if len(data) == 0 {
-		return nil, nil
-	}
-	type helper struct {
-		LedgerEntryType EntryType
+	return nil, ErrUnrecognizedLedgerObjectType{
+		Type: t,
 	}
-	var h helper
-	if err := json.Unmarshal(data, &h); err != nil {
-		return nil, err
-	}
-	var o Object
-	switch h.LedgerEntryType {
-	case AccountRootEntry:
-		o = &AccountRoot{}
-	case AmendmentsEntry:
-		o = &Amendments{}
-	case BridgeEntry:
-		o = &Bridge{}
-	case CheckEntry:
-		o = &Check{}
-	case CredentialEntry:
-		o = &Credential{}
-	case DelegateEntry:
-		o = &Delegate{}
-	case DepositPreauthObjEntry:
-		o = &DepositPreauthObj{}
-	case DIDEntry:
-		o = &DID{}
-	case DirectoryNodeEntry:
-		o = &DirectoryNode{}
-	case EscrowEntry:
-		o = &Escrow{}
-	case FeeSettingsEntry:
-		o = &FeeSettings{}
-	case LedgerHashesEntry:
-		o = &Hashes{}
-	case NegativeUNLEntry:
-		o = &NegativeUNL{}
-	case NFTokenOfferEntry:
-		o = &NFTokenOffer{}
-	case NFTokenPageEntry:
-		o = &NFTokenPage{}
-	case OfferEntry:
-		o = &Offer{}
-	case OracleEntry:
-		o = &Oracle{}
-	case PayChannelEntry:
-		o = &PayChannel{}
-	case PermissionedDomainEntry:
-		o = &PermissionedDomain{}
-	case RippleStateEntry:
-		o = &RippleState{}
-	case SignerListEntry:
-		o = &SignerList{}
-	case TicketEntry:
-		o = &Ticket{}
-	case XChainOwnedClaimIDEntry:
-		o = &XChainOwnedClaimID{}
-	case XChainOwnedCreateAccountClaimIDEntry:
-		o = &XChainOwnedCreateAccountClaimID{}
-	default:
-		return nil, fmt.Errorf("%w: %s", ErrUnsupportedLedgerObjectType, h.LedgerEntryType)
-	}
-	if err := json.Unmarshal(data, o); err != nil {
-		return nil, err
-	}
-	return o, nil
-
 }