diff --git a/lib/tests/e2e/suite.go b/lib/tests/e2e/suite.go
index 99fd97c..0a2ca9c 100644
--- a/lib/tests/e2e/suite.go
+++ b/lib/tests/e2e/suite.go
@@ -91,7 +91,8 @@ func (s *E2ETestSuite) TestBankSendBroadcastTxWithFileLock() {
 func (s *E2ETestSuite) TestOccSigning() {
 	val := s.network.Validators[0]
 
-	setKeys()
+	_, err := setKeys()
+	s.Require().NoError(err)
 
 	k, err := val.ClientCtx.Keyring.Key(sample.Name)
 	s.Require().NoError(err)
diff --git a/lib/trustwallet/occ.go b/lib/trustwallet/occ.go
index 5bc015d..319d8dd 100644
--- a/lib/trustwallet/occ.go
+++ b/lib/trustwallet/occ.go
@@ -1,6 +1,7 @@
 package trustwallet
 
 import (
+	"errors"
 	"fmt"
 	"io"
 	"time"
@@ -30,20 +31,16 @@ func occDo(data []byte, bufferDelayMs int, portName string, outBuffer []byte) (i
 	mode := &serial.Mode{BaudRate: 115200}
 	s, err := serial.Open(portName, mode)
 	if err != nil {
-		return 0, fmt.Errorf("unable to open serial port: %v", err)
+		return 0, fmt.Errorf("unable to open serial port: %w", err)
 	}
 	defer s.Close()
 
-	fmt.Println("serial connected to port.")
-
 	// Encode payload using SLIP
-	if err := encodeSLIP(payloadUnencoded, &payloadSlipEncoded); err != nil {
-		return 0, fmt.Errorf("unable to encode SLIP: %v", err)
-	}
+	encodeSLIP(payloadUnencoded, &payloadSlipEncoded)
 
 	// Send encoded payload over serial
 	if _, err := s.Write(payloadSlipEncoded); err != nil {
-		return 0, fmt.Errorf("unable to write to serial port: %v", err)
+		return 0, fmt.Errorf("unable to write to serial port: %w", err)
 	}
 
 	time.Sleep(time.Duration(bufferDelayMs) * time.Millisecond)
@@ -56,7 +53,7 @@ func occDo(data []byte, bufferDelayMs int, portName string, outBuffer []byte) (i
 
 	for {
 		n, err := s.Read(readBuffer)
-		if err != nil && err != io.EOF {
+		if err != nil && !errors.Is(err, io.EOF) {
 			time.Sleep(10 * time.Millisecond)
 			continue
 		}
@@ -69,9 +66,8 @@ func occDo(data []byte, bufferDelayMs int, portName string, outBuffer []byte) (i
 		if readBuffer[0] == SlipEnd {
 			if slipMsgFramer == 1 {
 				break
-			} else {
-				slipMsgFramer++
 			}
+			slipMsgFramer++
 		}
 		time.Sleep(1 * time.Millisecond)
 	}
@@ -79,7 +75,7 @@ func occDo(data []byte, bufferDelayMs int, portName string, outBuffer []byte) (i
 	// Decode SLIP response
 	decodedResponse, err := decodeSLIP(encodedResponse)
 	if err != nil {
-		return 0, fmt.Errorf("unable to decode SLIP: %v", err)
+		return 0, fmt.Errorf("unable to decode SLIP: %w", err)
 	}
 
 	// Copy decoded response to outBuffer
@@ -90,7 +86,7 @@ func occDo(data []byte, bufferDelayMs int, portName string, outBuffer []byte) (i
 }
 
 // encodeSLIP encodes data using SLIP protocol.
-func encodeSLIP(data []byte, encoded *[]byte) error {
+func encodeSLIP(data []byte, encoded *[]byte) {
 	*encoded = append(*encoded, SlipEnd)
 	for _, b := range data {
 		switch b {
@@ -103,14 +99,13 @@ func encodeSLIP(data []byte, encoded *[]byte) error {
 		}
 	}
 	*encoded = append(*encoded, SlipEnd)
-	return nil
 }
 
 // decodeSLIP decodes SLIP-encoded data.
 func decodeSLIP(encoded []byte) ([]byte, error) {
 	// Check for empty input
 	if len(encoded) == 0 {
-		return nil, fmt.Errorf("encoded data is empty")
+		return nil, errors.New("encoded data is empty")
 	}
 
 	// Remove first and last SLIP_END bytes
diff --git a/lib/trustwallet/trustwallet.go b/lib/trustwallet/trustwallet.go
index 75ec483..fcac449 100644
--- a/lib/trustwallet/trustwallet.go
+++ b/lib/trustwallet/trustwallet.go
@@ -3,6 +3,7 @@ package trustwallet
 import (
 	"bytes"
 	"encoding/binary"
+	"errors"
 	"fmt"
 	"strconv"
 	"strings"
@@ -46,11 +47,11 @@ func (s *OSCMessageSender) SendMessage(message []byte) (OSCResponse, error) {
 	)
 
 	if err != nil {
-		return OSCResponse{}, fmt.Errorf("failed to send message: %v", err)
+		return OSCResponse{}, fmt.Errorf("failed to send message: %w", err)
 	}
 
 	if outputLength == 0 {
-		return OSCResponse{}, fmt.Errorf("no response received")
+		return OSCResponse{}, errors.New("no response received")
 	}
 
 	// Extract the information from the output buffer
@@ -108,61 +109,65 @@ func (t *Connector) sendOSCMessage(address string, args ...interface{}) (OSCResp
 	t.mu.Lock()
 	defer t.mu.Unlock()
 
-	message := encodeOSCMessage(address, args...)
+	message, err := encodeOSCMessage(address, args...)
+	if err != nil {
+		return OSCResponse{}, err
+	}
+
 	return t.oscSender.SendMessage(message)
 }
 
 func (t *Connector) ValiseGet() (string, error) {
-	response, err := t.sendOSCMessage(fmt.Sprintf("%s/getSeed", PrefixIhw))
+	response, err := t.sendOSCMessage(PrefixIhw + "/getSeed")
 	if err != nil {
 		return "", err
 	}
 	if len(response.Data) > 0 {
 		return response.Data[0], nil
 	}
-	return "", fmt.Errorf("no data returned")
+	return "", errors.New("no data returned")
 }
 
 func (t *Connector) CreateMnemonic() (string, error) {
-	response, err := t.sendOSCMessage(fmt.Sprintf("%s/mnemonicToSeed", PrefixIhw), int32(1))
+	response, err := t.sendOSCMessage(PrefixIhw+"/mnemonicToSeed", int32(1))
 	if err != nil {
 		return "", err
 	}
 	if len(response.Data) > 0 {
 		return response.Data[0], nil
 	}
-	return "", fmt.Errorf("no data returned")
+	return "", errors.New("no data returned")
 }
 
 func (t *Connector) InjectPlanetminkeyToSE050(slot int) (bool, error) {
-	response, err := t.sendOSCMessage(fmt.Sprintf("%s/se050InjectSECPKeys", PrefixIhw), int32(slot))
+	response, err := t.sendOSCMessage(PrefixIhw+"/se050InjectSECPKeys", int32(slot))
 	if err != nil {
 		return false, err
 	}
 	if len(response.Data) > 0 {
 		return response.Data[0] == "0", nil
 	}
-	return false, fmt.Errorf("no data returned")
+	return false, errors.New("no data returned")
 }
 
 func (t *Connector) RecoverFromMnemonic(mnemonic string) (string, error) {
-	response, err := t.sendOSCMessage(fmt.Sprintf("%s/mnemonicToSeed", PrefixIhw), int32(1), mnemonic)
+	response, err := t.sendOSCMessage(PrefixIhw+"/mnemonicToSeed", int32(1), mnemonic)
 	if err != nil {
 		return "", err
 	}
 	if len(response.Data) > 0 {
 		return response.Data[0], nil
 	}
-	return "", fmt.Errorf("no data returned")
+	return "", errors.New("no data returned")
 }
 
 func (t *Connector) GetPlanetmintKeys() (*PlanetMintKeys, error) {
-	response, err := t.sendOSCMessage(fmt.Sprintf("%s/getPlntmntKeys", PrefixIhw))
+	response, err := t.sendOSCMessage(PrefixIhw + "/getPlntmntKeys")
 	if err != nil {
 		return nil, err
 	}
 	if len(response.Data) < 4 {
-		return nil, fmt.Errorf("trust wallet not initialized. Please initialize the wallet")
+		return nil, errors.New("trust wallet not initialized. Please initialize the wallet")
 	}
 	return &PlanetMintKeys{
 		PlanetmintAddress:        response.Data[0],
@@ -173,58 +178,58 @@ func (t *Connector) GetPlanetmintKeys() (*PlanetMintKeys, error) {
 }
 
 func (t *Connector) GetSeedSE050() (string, error) {
-	response, err := t.sendOSCMessage(fmt.Sprintf("%s/se050GetSeed", PrefixIhw))
+	response, err := t.sendOSCMessage(PrefixIhw + "/se050GetSeed")
 	if err != nil {
 		return "", err
 	}
 	if len(response.Data) > 0 {
 		return response.Data[0], nil
 	}
-	return "", fmt.Errorf("no data returned")
+	return "", errors.New("no data returned")
 }
 
 func (t *Connector) SignHashWithPlanetmint(dataToSign string) (string, error) {
-	response, err := t.sendOSCMessage(fmt.Sprintf("%s/ecdsaSignPlmnt", PrefixIhw), dataToSign)
+	response, err := t.sendOSCMessage(PrefixIhw+"/ecdsaSignPlmnt", dataToSign)
 	if err != nil {
 		return "", err
 	}
 	if len(response.Data) > 1 {
 		return response.Data[1], nil
 	}
-	return "", fmt.Errorf("no signature returned")
+	return "", errors.New("no signature returned")
 }
 
 func (t *Connector) SignHashWithRDDL(dataToSign string) (string, error) {
-	response, err := t.sendOSCMessage(fmt.Sprintf("%s/ecdsaSignRddl", PrefixIhw), dataToSign)
+	response, err := t.sendOSCMessage(PrefixIhw+"/ecdsaSignRddl", dataToSign)
 	if err != nil {
 		return "", err
 	}
 	if len(response.Data) > 1 {
 		return response.Data[1], nil
 	}
-	return "", fmt.Errorf("no signature returned")
+	return "", errors.New("no signature returned")
 }
 
 func (t *Connector) CreateOptegaKeypair(ctx int) (string, error) {
-	response, err := t.sendOSCMessage(fmt.Sprintf("%s/optigaTrustXCreateSecret", PrefixIhw), int32(ctx), "")
+	response, err := t.sendOSCMessage(PrefixIhw+"/optigaTrustXCreateSecret", int32(ctx), "")
 	if err != nil {
 		return "", err
 	}
 	if len(response.Data) > 1 {
 		return response.Data[1], nil
 	}
-	return "", fmt.Errorf("no public key returned")
+	return "", errors.New("no public key returned")
 }
 
 func (t *Connector) SignWithOptega(ctx int, dataToSign, pubkey string) (string, error) {
-	response, err := t.sendOSCMessage(fmt.Sprintf("%s/optigaTrustXSignMessage", PrefixIhw), int32(ctx), dataToSign, pubkey, "")
+	response, err := t.sendOSCMessage(PrefixIhw+"/optigaTrustXSignMessage", int32(ctx), dataToSign, pubkey, "")
 	if err != nil {
 		return "", err
 	}
 	if len(response.Data) > 1 {
 		return response.Data[1], nil
 	}
-	return "", fmt.Errorf("no signature returned")
+	return "", errors.New("no signature returned")
 }
 
 func (t *Connector) UnwrapPublicKey(publicKey string) (bool, string) {
@@ -238,65 +243,65 @@ func (t *Connector) UnwrapPublicKey(publicKey string) (bool, string) {
 }
 
 func (t *Connector) CalculateHash(dataToSign string) (string, error) {
-	response, err := t.sendOSCMessage(fmt.Sprintf("%s/se050CalculateHash", PrefixIhw), dataToSign)
+	response, err := t.sendOSCMessage(PrefixIhw+"/se050CalculateHash", dataToSign)
 	if err != nil {
 		return "", err
 	}
 	if len(response.Data) > 1 {
 		return response.Data[1], nil
 	}
-	return "", fmt.Errorf("no hash returned")
+	return "", errors.New("no hash returned")
 }
 
 func (t *Connector) CreateSE050KeypairNIST(ctx int) (string, error) {
-	response, err := t.sendOSCMessage(fmt.Sprintf("%s/se050CreateKeyPair", PrefixIhw), int32(ctx), int32(1))
+	response, err := t.sendOSCMessage(PrefixIhw+"/se050CreateKeyPair", int32(ctx), int32(1))
 	if err != nil {
 		return "", err
 	}
 	if len(response.Data) > 1 {
 		return response.Data[1], nil
 	}
-	return "", fmt.Errorf("no public key returned")
+	return "", errors.New("no public key returned")
 }
 
 func (t *Connector) GetPublicKeyFromSE050(ctx int) (string, error) {
-	response, err := t.sendOSCMessage(fmt.Sprintf("%s/se050GetPublicKey", PrefixIhw), int32(ctx))
+	response, err := t.sendOSCMessage(PrefixIhw+"/se050GetPublicKey", int32(ctx))
 	if err != nil {
 		return "", err
 	}
 	if len(response.Data) > 1 {
 		valid, pubKey := t.UnwrapPublicKey(response.Data[1])
 		if !valid {
-			return "", fmt.Errorf("inject PlanetMintKey failed: No key found")
+			return "", errors.New("inject PlanetMintKey failed: No key found")
 		}
 		return pubKey, nil
 	}
-	return "", fmt.Errorf("no public key returned")
+	return "", errors.New("no public key returned")
 }
 
 func (t *Connector) SignWithSE050(dataToSign string, ctx int) (string, error) {
-	response, err := t.sendOSCMessage(fmt.Sprintf("%s/se050SignData", PrefixIhw), dataToSign, int32(ctx))
+	response, err := t.sendOSCMessage(PrefixIhw+"/se050SignData", dataToSign, int32(ctx))
 	if err != nil {
 		return "", err
 	}
 	if len(response.Data) > 1 {
 		return response.Data[1], nil
 	}
-	return "", fmt.Errorf("no signature returned")
+	return "", errors.New("no signature returned")
 }
 
 func (t *Connector) VerifySE050Signature(dataToSign, signature string, ctx int) (bool, error) {
-	response, err := t.sendOSCMessage(fmt.Sprintf("%s/se050VerifySignature", PrefixIhw), dataToSign, signature, int32(ctx))
+	response, err := t.sendOSCMessage(PrefixIhw+"/se050VerifySignature", dataToSign, signature, int32(ctx))
 	if err != nil {
 		return false, err
 	}
 	if len(response.Data) > 1 {
 		return strconv.ParseBool(response.Data[1])
 	}
-	return false, fmt.Errorf("no verification result returned")
+	return false, errors.New("no verification result returned")
 }
 
-func encodeOSCMessage(address string, args ...interface{}) []byte {
+func encodeOSCMessage(address string, args ...interface{}) (returnBytes []byte, err error) {
 	var buffer bytes.Buffer
 
 	// Write address
@@ -309,13 +314,17 @@ func encodeOSCMessage(address string, args ...interface{}) []byte {
 	for _, arg := range args {
 		switch arg.(type) {
 		case int32:
-			buffer.WriteByte('i')
+			err = buffer.WriteByte('i')
 		case float32:
-			buffer.WriteByte('f')
+			err = buffer.WriteByte('f')
 		case string:
-			buffer.WriteByte('s')
+			err = buffer.WriteByte('s')
+		}
+		if err != nil {
+			return buffer.Bytes(), err
 		}
 	}
+
 	buffer.WriteByte(0)
 	alignBuffer(&buffer)
 
@@ -323,17 +332,23 @@ func encodeOSCMessage(address string, args ...interface{}) []byte {
 	for _, arg := range args {
 		switch v := arg.(type) {
 		case int32:
-			binary.Write(&buffer, binary.BigEndian, v)
+			err = binary.Write(&buffer, binary.BigEndian, v)
 		case float32:
-			binary.Write(&buffer, binary.BigEndian, v)
+			err = binary.Write(&buffer, binary.BigEndian, v)
 		case string:
-			buffer.WriteString(v)
-			buffer.WriteByte(0)
+			_, err = buffer.WriteString(v)
+			if err != nil {
+				return buffer.Bytes(), err
+			}
+			err = buffer.WriteByte(0)
 			alignBuffer(&buffer)
 		}
+		if err != nil {
+			return buffer.Bytes(), err
+		}
 	}
 
-	return buffer.Bytes()
+	return buffer.Bytes(), nil
 }
 
 func alignBuffer(buffer *bytes.Buffer) {