Refactor to use use unwrapErr() throughout the codebase

rpc/block.go

@@ -22,11 +22,8 @@ func (provider *Provider) BlockNumber(ctx context.Context) (uint64, error) {
 // BlockHashAndNumber gets block information given the block number or its hash.
 func (provider *Provider) BlockHashAndNumber(ctx context.Context) (*BlockHashAndNumberOutput, error) {
 	var block BlockHashAndNumberOutput
-	if err := do(ctx, provider.c, "starknet_blockHashAndNumber", &block); err != nil {
-		if errors.Is(err, errNotFound) {
-			return nil, ErrNoBlocks
-		}
-		return nil, err
+	if err := do(ctx, provider.c, "starknet_blockHashAndNumber", &block); err != nil {		
+		return nil, tryUnwrapToRPCErr(err, ErrNoBlocks )
 	}
 	return &block, nil
 }
@@ -52,11 +49,8 @@ func WithBlockTag(tag string) BlockID {
 // BlockWithTxHashes gets block information given the block id.
 func (provider *Provider) BlockWithTxHashes(ctx context.Context, blockID BlockID) (interface{}, error) {
 	var result BlockTxHashes
-	if err := do(ctx, provider.c, "starknet_getBlockWithTxHashes", &result, blockID); err != nil {
-		if errors.Is(err, errNotFound) {
-			return nil, ErrBlockNotFound
-		}
-		return nil, err
+	if err := do(ctx, provider.c, "starknet_getBlockWithTxHashes", &result, blockID); err != nil {		
+		return nil, tryUnwrapToRPCErr(err,ErrBlockNotFound )
 	}
 
 	// if header.Hash == nil it's a pending block
@@ -75,11 +69,8 @@ func (provider *Provider) BlockWithTxHashes(ctx context.Context, blockID BlockID
 // StateUpdate gets the information about the result of executing the requested block.
 func (provider *Provider) StateUpdate(ctx context.Context, blockID BlockID) (*StateUpdateOutput, error) {
 	var state StateUpdateOutput
-	if err := do(ctx, provider.c, "starknet_getStateUpdate", &state, blockID); err != nil {
-		if errors.Is(err, errNotFound) {
-			return nil, ErrBlockNotFound
-		}
-		return nil, err
+	if err := do(ctx, provider.c, "starknet_getStateUpdate", &state, blockID); err != nil {		
+		return nil,tryUnwrapToRPCErr(err,ErrBlockNotFound )
 	}
 	return &state, nil
 }
@@ -100,10 +91,7 @@ func (provider *Provider) BlockTransactionCount(ctx context.Context, blockID Blo
 func (provider *Provider) BlockWithTxs(ctx context.Context, blockID BlockID) (interface{}, error) {
 	var result Block
 	if err := do(ctx, provider.c, "starknet_getBlockWithTxs", &result, blockID); err != nil {
-		if errors.Is(err, errNotFound) {
-			return nil, ErrBlockNotFound
-		}
-		return nil, err
+		return nil, tryUnwrapToRPCErr(err,ErrBlockNotFound )
 	}
 	// if header.Hash == nil it's a pending block
 	if result.BlockHeader.BlockHash == nil {

rpc/call.go

@@ -2,7 +2,7 @@ package rpc
 
 import (
 	"context"
-	"errors"
+
 
 	"github.com/NethermindEth/juno/core/felt"
 )
@@ -15,15 +15,8 @@ func (provider *Provider) Call(ctx context.Context, request FunctionCall, blockI
 	}
 	var result []*felt.Felt
 	if err := do(ctx, provider.c, "starknet_call", &result, request, blockID); err != nil {
-		switch {
-		case errors.Is(err, ErrContractNotFound):
-			return nil, ErrContractNotFound
-		case errors.Is(err, ErrContractError):
-			return nil, ErrContractError
-		case errors.Is(err, ErrBlockNotFound):
-			return nil, ErrBlockNotFound
-		}
-		return nil, err
+
+		return nil,  tryUnwrapToRPCErr(err, ErrContractNotFound, ErrContractError, ErrBlockNotFound)
 	}
 	return result, nil
 }

rpc/contract.go

@@ -3,7 +3,7 @@ package rpc
 import (
 	"context"
 	"encoding/json"
-	"errors"
+
 	"fmt"
 
 	"github.com/NethermindEth/juno/core/felt"
@@ -14,13 +14,8 @@ import (
 func (provider *Provider) Class(ctx context.Context, blockID BlockID, classHash *felt.Felt) (ClassOutput, error) {
 	var rawClass map[string]any
 	if err := do(ctx, provider.c, "starknet_getClass", &rawClass, blockID, classHash); err != nil {
-		switch {
-		case errors.Is(err, ErrClassHashNotFound):
-			return nil, ErrClassHashNotFound
-		case errors.Is(err, ErrBlockNotFound):
-			return nil, ErrBlockNotFound
-		}
-		return nil, err
+
+		return nil, tryUnwrapToRPCErr(err, ErrClassHashNotFound, ErrBlockNotFound)
 	}
 
 	return typecastClassOutput(&rawClass)
@@ -31,13 +26,8 @@ func (provider *Provider) Class(ctx context.Context, blockID BlockID, classHash
 func (provider *Provider) ClassAt(ctx context.Context, blockID BlockID, contractAddress *felt.Felt) (ClassOutput, error) {
 	var rawClass map[string]any
 	if err := do(ctx, provider.c, "starknet_getClassAt", &rawClass, blockID, contractAddress); err != nil {
-		switch {
-		case errors.Is(err, ErrContractNotFound):
-			return nil, ErrContractNotFound
-		case errors.Is(err, ErrBlockNotFound):
-			return nil, ErrBlockNotFound
-		}
-		return nil, err
+
+		return nil, tryUnwrapToRPCErr(err, ErrContractNotFound, ErrBlockNotFound)
 	}
 	return typecastClassOutput(&rawClass)
 }
@@ -69,13 +59,8 @@ func typecastClassOutput(rawClass *map[string]any) (ClassOutput, error) {
 func (provider *Provider) ClassHashAt(ctx context.Context, blockID BlockID, contractAddress *felt.Felt) (*felt.Felt, error) {
 	var result *felt.Felt
 	if err := do(ctx, provider.c, "starknet_getClassHashAt", &result, blockID, contractAddress); err != nil {
-		switch {
-		case errors.Is(err, ErrContractNotFound):
-			return nil, ErrContractNotFound
-		case errors.Is(err, ErrBlockNotFound):
-			return nil, ErrBlockNotFound
-		}
-		return nil, err
+
+		return nil, tryUnwrapToRPCErr(err, ErrContractNotFound, ErrBlockNotFound)
 	}
 	return result, nil
 }
@@ -85,13 +70,8 @@ func (provider *Provider) StorageAt(ctx context.Context, contractAddress *felt.F
 	var value string
 	hashKey := fmt.Sprintf("0x%x", utils.GetSelectorFromName(key))
 	if err := do(ctx, provider.c, "starknet_getStorageAt", &value, contractAddress, hashKey, blockID); err != nil {
-		switch {
-		case errors.Is(err, ErrContractNotFound):
-			return "", ErrContractNotFound
-		case errors.Is(err, ErrBlockNotFound):
-			return "", ErrBlockNotFound
-		}
-		return "", err
+
+		return "", tryUnwrapToRPCErr(err, ErrContractNotFound, ErrBlockNotFound)
 	}
 	return value, nil
 }
@@ -100,13 +80,8 @@ func (provider *Provider) StorageAt(ctx context.Context, contractAddress *felt.F
 func (provider *Provider) Nonce(ctx context.Context, blockID BlockID, contractAddress *felt.Felt) (*string, error) {
 	nonce := ""
 	if err := do(ctx, provider.c, "starknet_getNonce", &nonce, blockID, contractAddress); err != nil {
-		switch {
-		case errors.Is(err, ErrContractNotFound):
-			return nil, ErrContractNotFound
-		case errors.Is(err, ErrBlockNotFound):
-			return nil, ErrBlockNotFound
-		}
-		return nil, err
+
+		return nil, tryUnwrapToRPCErr(err, ErrContractNotFound, ErrBlockNotFound)
 	}
 	return &nonce, nil
 }
@@ -115,15 +90,8 @@ func (provider *Provider) Nonce(ctx context.Context, blockID BlockID, contractAd
 func (provider *Provider) EstimateFee(ctx context.Context, requests []EstimateFeeInput, blockID BlockID) ([]FeeEstimate, error) {
 	var raw []FeeEstimate
 	if err := do(ctx, provider.c, "starknet_estimateFee", &raw, requests, blockID); err != nil {
-		switch {
-		case errors.Is(err, ErrContractNotFound):
-			return nil, ErrContractNotFound
-		case errors.Is(err, ErrContractError):
-			return nil, ErrContractError
-		case errors.Is(err, ErrBlockNotFound):
-			return nil, ErrBlockNotFound
-		}
-		return nil, err
+
+		return nil, tryUnwrapToRPCErr(err, ErrContractNotFound,ErrContractError, ErrBlockNotFound)
 	}
 	return raw, nil
 }
@@ -132,15 +100,8 @@ func (provider *Provider) EstimateFee(ctx context.Context, requests []EstimateFe
 func (provider *Provider) EstimateMessageFee(ctx context.Context, msg MsgFromL1, blockID BlockID) (*FeeEstimate, error) {
 	var raw FeeEstimate
 	if err := do(ctx, provider.c, "starknet_estimateMessageFee", &raw, msg, blockID); err != nil {
-		switch {
-		case errors.Is(err, ErrContractNotFound):
-			return nil, ErrContractNotFound
-		case errors.Is(err, ErrContractError):
-			return nil, ErrContractError
-		case errors.Is(err, ErrBlockNotFound):
-			return nil, ErrBlockNotFound
-		}
-		return nil, err
+
+		return nil, tryUnwrapToRPCErr(err, ErrContractNotFound,ErrContractError, ErrBlockNotFound)
 	}
 	return &raw, nil
 }

rpc/events.go

@@ -2,24 +2,15 @@ package rpc
 
 import (
 	"context"
-	"errors"
+
 )
 
 // Events returns all events matching the given filter
 func (provider *Provider) Events(ctx context.Context, input EventsInput) (*EventChunk, error) {
 	var result EventChunk
 	if err := do(ctx, provider.c, "starknet_getEvents", &result, input); err != nil {
-		switch {
-		case errors.Is(err, ErrPageSizeTooBig):
-			return nil, ErrPageSizeTooBig
-		case errors.Is(err, ErrInvalidContinuationToken):
-			return nil, ErrInvalidContinuationToken
-		case errors.Is(err, ErrBlockNotFound):
-			return nil, ErrBlockNotFound
-		case errors.Is(err, ErrTooManyKeysInFilter):
-			return nil, ErrTooManyKeysInFilter
-		}
-		return nil, err
+
+		return nil, tryUnwrapToRPCErr(err,  ErrPageSizeTooBig , ErrInvalidContinuationToken , ErrBlockNotFound ,ErrTooManyKeysInFilter)
 	}
 	return &result, nil
 }

rpc/transaction.go

@@ -62,25 +62,18 @@ func (provider *Provider) TransactionByHash(ctx context.Context, hash *felt.Felt
 	// todo: update to return a custom Transaction type, then use adapt function
 	var tx TXN
 	if err := do(ctx, provider.c, "starknet_getTransactionByHash", &tx, hash); err != nil {
-		if errors.Is(err, ErrHashNotFound) {
-			return nil, ErrHashNotFound
-		}
-		return nil, err
-	}
+			return nil, tryUnwrapToRPCErr(err,ErrHashNotFound)	
+}
 	return adaptTransaction(tx)
 }
 
 // TransactionByBlockIdAndIndex Get the details of the transaction given by the identified block and index in that block. If no transaction is found, null is returned.
 func (provider *Provider) TransactionByBlockIdAndIndex(ctx context.Context, blockID BlockID, index uint64) (Transaction, error) {
 	var tx TXN
 	if err := do(ctx, provider.c, "starknet_getTransactionByBlockIdAndIndex", &tx, blockID, index); err != nil {
-		switch {
-		case errors.Is(err, ErrInvalidTxnIndex):
-			return nil, ErrInvalidTxnIndex
-		case errors.Is(err, ErrBlockNotFound):
-			return nil, ErrBlockNotFound
-		}
-		return nil, err
+
+		return nil,tryUnwrapToRPCErr(err,  ErrInvalidTxnIndex ,ErrBlockNotFound)
+
 	}
 	return adaptTransaction(tx)
 }
@@ -90,10 +83,7 @@ func (provider *Provider) TransactionReceipt(ctx context.Context, transactionHas
 	var receipt UnknownTransactionReceipt
 	err := do(ctx, provider.c, "starknet_getTransactionReceipt", &receipt, transactionHash)
 	if err != nil {
-		if errors.Is(err, ErrHashNotFound) {
-			return nil, ErrHashNotFound
-		}
-		return nil, err
+		return nil, tryUnwrapToRPCErr(err,ErrHashNotFound)
 	}
 	return receipt.TransactionReceipt, nil
 }