github.com/Finschia/finschia-sdk@v0.48.1/crypto/hd/fundraiser_test.go (about)

     1  package hd_test
     2  
     3  import (
     4  	"encoding/hex"
     5  	"encoding/json"
     6  	"fmt"
     7  	"os"
     8  	"testing"
     9  
    10  	"github.com/stretchr/testify/require"
    11  
    12  	bip39 "github.com/cosmos/go-bip39"
    13  
    14  	"github.com/Finschia/ostracon/crypto"
    15  
    16  	"github.com/Finschia/finschia-sdk/crypto/hd"
    17  	"github.com/Finschia/finschia-sdk/crypto/keys/secp256k1"
    18  )
    19  
    20  type addrData struct {
    21  	Mnemonic string
    22  	Master   string
    23  	Seed     string
    24  	Priv     string
    25  	Pub      string
    26  	Addr     string
    27  }
    28  
    29  func TestFullFundraiserPath(t *testing.T) {
    30  	require.Equal(t, "m/44'/118'/0'/0/0", hd.NewFundraiserParams(0, 118, 0).String())
    31  }
    32  
    33  func initFundraiserTestVectors(t *testing.T) []addrData {
    34  	// NOTE: atom fundraiser address
    35  	// var hdPath string = "m/44'/118'/0'/0/0"
    36  	var hdToAddrTable []addrData
    37  
    38  	b, err := os.ReadFile("testdata/test.json")
    39  	if err != nil {
    40  		t.Fatalf("could not read fundraiser test vector file (testdata/test.json): %s", err)
    41  	}
    42  
    43  	err = json.Unmarshal(b, &hdToAddrTable)
    44  	if err != nil {
    45  		t.Fatalf("could not decode test vectors (testdata/test.json): %s", err)
    46  	}
    47  	return hdToAddrTable
    48  }
    49  
    50  func TestFundraiserCompatibility(t *testing.T) {
    51  	hdToAddrTable := initFundraiserTestVectors(t)
    52  
    53  	for i, d := range hdToAddrTable {
    54  		privB, _ := hex.DecodeString(d.Priv)
    55  		pubB, _ := hex.DecodeString(d.Pub)
    56  		addrB, _ := hex.DecodeString(d.Addr)
    57  		seedB, _ := hex.DecodeString(d.Seed)
    58  		masterB, _ := hex.DecodeString(d.Master)
    59  
    60  		seed := bip39.NewSeed(d.Mnemonic, "")
    61  
    62  		t.Log("================================")
    63  		t.Logf("ROUND: %d MNEMONIC: %s", i, d.Mnemonic)
    64  
    65  		master, ch := hd.ComputeMastersFromSeed(seed)
    66  		priv, err := hd.DerivePrivateKeyForPath(master, ch, "m/44'/118'/0'/0/0")
    67  		require.NoError(t, err)
    68  
    69  		privKey := &secp256k1.PrivKey{Key: priv}
    70  		pub := privKey.PubKey()
    71  
    72  		t.Log("\tNODEJS GOLANG\n")
    73  		t.Logf("SEED \t%X %X\n", seedB, seed)
    74  		t.Logf("MSTR \t%X %X\n", masterB, master)
    75  		t.Logf("PRIV \t%X %X\n", privB, priv)
    76  		t.Logf("PUB  \t%X %X\n", pubB, pub)
    77  
    78  		require.Equal(t, seedB, seed)
    79  		require.Equal(t, master[:], masterB, fmt.Sprintf("Expected masters to match for %d", i))
    80  		require.Equal(t, priv[:], privB, "Expected priv keys to match")
    81  		pubBFixed := make([]byte, secp256k1.PubKeySize)
    82  		copy(pubBFixed, pubB)
    83  		require.Equal(t, pub, &secp256k1.PubKey{Key: pubBFixed}, fmt.Sprintf("Expected pub keys to match for %d", i))
    84  
    85  		addr := pub.Address()
    86  		t.Logf("ADDR  \t%X %X\n", addrB, addr)
    87  		require.Equal(t, addr, crypto.Address(addrB), fmt.Sprintf("Expected addresses to match %d", i))
    88  
    89  	}
    90  }