github.com/cosmos/cosmos-sdk@v0.50.10/types/address/hash_test.go (about)

     1  package address
     2  
     3  import (
     4  	"crypto/sha256"
     5  	"testing"
     6  
     7  	"github.com/cometbft/cometbft/crypto/tmhash"
     8  	"github.com/stretchr/testify/assert"
     9  	"github.com/stretchr/testify/suite"
    10  )
    11  
    12  func TestAddressSuite(t *testing.T) {
    13  	suite.Run(t, new(AddressSuite))
    14  }
    15  
    16  type AddressSuite struct{ suite.Suite }
    17  
    18  func (suite *AddressSuite) TestHash() {
    19  	assert := suite.Assert()
    20  	typ := "1"
    21  	key := []byte{1}
    22  	part1 := sha256.Sum256([]byte(typ))
    23  	expected := sha256.Sum256(append(part1[:], key...))
    24  	received := Hash(typ, key)
    25  	assert.Equal(expected[:], received, "must create a correct address")
    26  
    27  	received = Hash("other", key)
    28  	assert.NotEqual(expected[:], received, "must create a correct address")
    29  	assert.Len(received, Len, "must have correct length")
    30  }
    31  
    32  func (suite *AddressSuite) TestComposed() {
    33  	assert := suite.Assert()
    34  	a1 := addrMock{[]byte{11, 12}}
    35  	a2 := addrMock{[]byte{21, 22}}
    36  
    37  	typ := "multisig"
    38  	ac, err := Compose(typ, []Addressable{a1, a2})
    39  	assert.NoError(err)
    40  	assert.Len(ac, Len)
    41  
    42  	// check if optimizations work
    43  	checkingKey := append([]byte{}, a1.AddressWithLen(suite.T())...)
    44  	checkingKey = append(checkingKey, a2.AddressWithLen(suite.T())...)
    45  	ac2 := Hash(typ, checkingKey)
    46  	assert.Equal(ac, ac2, "NewComposed works correctly")
    47  
    48  	// changing order of addresses shouldn't impact a composed address
    49  	ac2, err = Compose(typ, []Addressable{a2, a1})
    50  	assert.NoError(err)
    51  	assert.Len(ac2, Len)
    52  	assert.Equal(ac, ac2, "NewComposed is not sensitive for order")
    53  
    54  	// changing a type should change composed address
    55  	ac2, err = Compose(typ+"other", []Addressable{a2, a1})
    56  	assert.NoError(err)
    57  	assert.NotEqual(ac, ac2, "NewComposed must be sensitive to type")
    58  
    59  	// changing order of addresses shouldn't impact a composed address
    60  	_, err = Compose(typ, []Addressable{a1, addrMock{make([]byte, 300)}})
    61  	assert.Error(err)
    62  	assert.Contains(err.Error(), "should be max 255 bytes, got 300")
    63  }
    64  
    65  func (suite *AddressSuite) TestModule() {
    66  	assert := suite.Assert()
    67  	modName, key := "myModule", []byte{1, 2}
    68  
    69  	addrLegacy := Module(modName)
    70  	assert.Equal(tmhash.SumTruncated([]byte(modName)), addrLegacy,
    71  		"when no derivation keys, we fall back to the legacy module address using sha256 of the module name")
    72  
    73  	addr := Module(modName, key)
    74  	assert.Len(addr, Len, "must have correct address length")
    75  	assert.NotEqual(addrLegacy, addr,
    76  		"when derivation key is specified, it must generate non legacy module address")
    77  
    78  	addr2 := Module("myModule2", key)
    79  	assert.NotEqual(addr, addr2, "changing module name must change address")
    80  
    81  	k1 := []byte{1, 2, 3}
    82  	addr3 := Module(modName, k1)
    83  	assert.NotEqual(addr, addr3, "changing key must change address")
    84  	assert.NotEqual(addr2, addr3, "changing key must change address")
    85  
    86  	addr4 := Module(modName, k1, k1)
    87  	assert.Equal(Derive(addr3, k1), addr4)
    88  
    89  	k2 := []byte{0, 0, 7}
    90  	addr5 := Module(modName, k1, k1, k2)
    91  	assert.Equal(Derive(addr4, k2), addr5)
    92  }
    93  
    94  func (suite *AddressSuite) TestDerive() {
    95  	assert := suite.Assert()
    96  	addr, key1, key2 := []byte{1, 2}, []byte{3, 4}, []byte{1, 2}
    97  	d1 := Derive(addr, key1)
    98  	d2 := Derive(addr, key2)
    99  	d3 := Derive(key1, key2)
   100  	assert.Len(d1, Len)
   101  	assert.Len(d2, Len)
   102  	assert.Len(d3, Len)
   103  
   104  	assert.NotEqual(d1, d2)
   105  	assert.NotEqual(d1, d3)
   106  	assert.NotEqual(d2, d3)
   107  }
   108  
   109  type addrMock struct {
   110  	Addr []byte
   111  }
   112  
   113  func (a addrMock) Address() []byte {
   114  	return a.Addr
   115  }
   116  
   117  func (a addrMock) AddressWithLen(t *testing.T) []byte {
   118  	addr, err := LengthPrefix(a.Addr)
   119  	assert.NoError(t, err)
   120  	return addr
   121  }