github.com/Finschia/finschia-sdk@v0.48.1/types/address/hash_test.go (about)

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