Mirroristas/planetmint-go
2
0
Fork 0
mirror of https://github.com/planetmint/planetmint-go.git synced 2025-11-24 14:35:47 +00:00
Code Issues Packages Projects Releases Wiki Activity

fix: linter errors

Browse Source 
Signed-off-by: Lorenz Herzberger <lorenzherzberger@gmail.com>
This commit is contained in:
Lorenz Herzberger 2024-09-11 16:23:10 +02:00
parent fca9100d47
commit f047cacdc5
No known key found for this signature in database
GPG Key ID: FA5EE906EB55316A
3 changed files with 69 additions and 58 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
lib/tests/e2e/suite.go
View File

@ -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)

23
lib/trustwallet/occ.go
View File

@ -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

101
lib/trustwallet/trustwallet.go
View File

@ -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) {