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