github.com/nspcc-dev/neo-go@v0.105.2-0.20240517133400-6be757af3eba/pkg/crypto/keys/wif_test.go (about)

     1  package keys
     2  
     3  import (
     4  	"encoding/hex"
     5  	"testing"
     6  
     7  	"github.com/nspcc-dev/neo-go/pkg/encoding/base58"
     8  	"github.com/stretchr/testify/assert"
     9  	"github.com/stretchr/testify/require"
    10  )
    11  
    12  type wifTestCase struct {
    13  	wif        string
    14  	compressed bool
    15  	privateKey string
    16  	version    byte
    17  }
    18  
    19  var wifTestCases = []wifTestCase{
    20  	{
    21  		wif:        "KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYjgd9M7rFU73sVHnoWn",
    22  		compressed: true,
    23  		privateKey: "0000000000000000000000000000000000000000000000000000000000000001",
    24  		version:    0x80,
    25  	},
    26  	{
    27  		wif:        "5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip4nEB3kEsreAnchuDf",
    28  		compressed: false,
    29  		privateKey: "0000000000000000000000000000000000000000000000000000000000000001",
    30  		version:    0x80,
    31  	},
    32  	{
    33  		wif:        "KxhEDBQyyEFymvfJD96q8stMbJMbZUb6D1PmXqBWZDU2WvbvVs9o",
    34  		compressed: true,
    35  		privateKey: "2bfe58ab6d9fd575bdc3a624e4825dd2b375d64ac033fbc46ea79dbab4f69a3e",
    36  		version:    0x80,
    37  	},
    38  	{
    39  		wif:        "KxhEDBQyyEFymvfJD96q8stMbJMbZUb6D1PmXqBWZDU2WvbvVs9o",
    40  		compressed: true,
    41  		privateKey: "2bfe58ab6d9fd575bdc3a624e4825dd2b375d64ac033fbc46ea79dbab4f69a3e",
    42  		version:    0x00,
    43  	},
    44  }
    45  
    46  func TestWIFEncodeDecode(t *testing.T) {
    47  	for _, testCase := range wifTestCases {
    48  		b, err := hex.DecodeString(testCase.privateKey)
    49  		assert.Nil(t, err)
    50  		wif, err := WIFEncode(b, testCase.version, testCase.compressed)
    51  		assert.Nil(t, err)
    52  		assert.Equal(t, testCase.wif, wif)
    53  
    54  		WIF, err := WIFDecode(wif, testCase.version)
    55  		assert.Nil(t, err)
    56  		assert.Equal(t, testCase.privateKey, WIF.PrivateKey.String())
    57  		assert.Equal(t, testCase.compressed, WIF.Compressed)
    58  		if testCase.version != 0 {
    59  			assert.Equal(t, testCase.version, WIF.Version)
    60  		} else {
    61  			assert.EqualValues(t, WIFVersion, WIF.Version)
    62  		}
    63  	}
    64  
    65  	wifInv := []byte{0, 1, 2}
    66  	_, err := WIFEncode(wifInv, 0, true)
    67  	require.Error(t, err)
    68  }
    69  
    70  func TestBadWIFDecode(t *testing.T) {
    71  	_, err := WIFDecode("garbage", 0)
    72  	require.Error(t, err)
    73  
    74  	s := base58.CheckEncode([]byte{})
    75  	_, err = WIFDecode(s, 0)
    76  	require.Error(t, err)
    77  
    78  	uncompr := make([]byte, 33)
    79  	compr := make([]byte, 34)
    80  
    81  	s = base58.CheckEncode(compr)
    82  	_, err = WIFDecode(s, 0)
    83  	require.Error(t, err)
    84  
    85  	s = base58.CheckEncode(uncompr)
    86  	_, err = WIFDecode(s, 0)
    87  	require.Error(t, err)
    88  
    89  	compr[33] = 1
    90  	compr[0] = WIFVersion
    91  	uncompr[0] = WIFVersion
    92  
    93  	s = base58.CheckEncode(compr)
    94  	_, err = WIFDecode(s, 0)
    95  	require.NoError(t, err)
    96  
    97  	s = base58.CheckEncode(uncompr)
    98  	_, err = WIFDecode(s, 0)
    99  	require.NoError(t, err)
   100  }