diff --git a/common/random.go b/common/random.go
index f70d6477..a2237487 100644
--- a/common/random.go
+++ b/common/random.go
@@ -16,7 +16,7 @@ const (
 
 type Rand struct {
 	sync.Mutex
-	*mrand.Rand
+	rand *mrand.Rand
 }
 
 var grand *Rand
@@ -43,7 +43,7 @@ func (r *Rand) init() {
 }
 
 func (r *Rand) reset(seed int64) {
-	r.Rand = mrand.New(mrand.NewSource(seed))
+	r.rand = mrand.New(mrand.NewSource(seed))
 }
 
 //----------------------------------------
@@ -54,79 +54,79 @@ func Seed(seed int64) {
 }
 
 func RandStr(length int) string {
-	return grand.RandStr(length)
+	return grand.Str(length)
 }
 
 func RandUint16() uint16 {
-	return grand.RandUint16()
+	return grand.Uint16()
 }
 
 func RandUint32() uint32 {
-	return grand.RandUint32()
+	return grand.Uint32()
 }
 
 func RandUint64() uint64 {
-	return grand.RandUint64()
+	return grand.Uint64()
 }
 
 func RandUint() uint {
-	return grand.RandUint()
+	return grand.Uint()
 }
 
 func RandInt16() int16 {
-	return grand.RandInt16()
+	return grand.Int16()
 }
 
 func RandInt32() int32 {
-	return grand.RandInt32()
+	return grand.Int32()
 }
 
 func RandInt64() int64 {
-	return grand.RandInt64()
+	return grand.Int64()
 }
 
 func RandInt() int {
-	return grand.RandInt()
+	return grand.Int()
 }
 
 func RandInt31() int32 {
-	return grand.RandInt31()
+	return grand.Int31()
 }
 
 func RandInt63() int64 {
-	return grand.RandInt63()
+	return grand.Int63()
 }
 
 func RandUint16Exp() uint16 {
-	return grand.RandUint16Exp()
+	return grand.Uint16Exp()
 }
 
 func RandUint32Exp() uint32 {
-	return grand.RandUint32Exp()
+	return grand.Uint32Exp()
 }
 
 func RandUint64Exp() uint64 {
-	return grand.RandUint64Exp()
+	return grand.Uint64Exp()
 }
 
 func RandFloat32() float32 {
-	return grand.RandFloat32()
+	return grand.Float32()
 }
 
 func RandTime() time.Time {
-	return grand.RandTime()
+	return grand.Time()
 }
 
 func RandBytes(n int) []byte {
-	return grand.RandBytes(n)
+	return grand.Bytes(n)
 }
 
 func RandIntn(n int) int {
-	return grand.RandIntn(n)
+	return grand.Intn(n)
 }
 
 func RandPerm(n int) []int {
-	return grand.RandPerm(n)
+	return grand.Perm(n)
 }
 
 //----------------------------------------
@@ -140,11 +140,11 @@ func (r *Rand) Seed(seed int64) {
 
 // Constructs an alphanumeric string of given length.
 // It is not safe for cryptographic usage.
-func (r *Rand) RandStr(length int) string {
+func (r *Rand) Str(length int) string {
 	chars := []byte{}
 MAIN_LOOP:
 	for {
-		val := r.RandInt63()
+		val := r.Int63()
 		for i := 0; i < 10; i++ {
 			v := int(val & 0x3f) // rightmost 6 bits
 			if v >= 62 {         // only 62 characters in strChars
@@ -164,127 +164,127 @@ MAIN_LOOP:
 }
 
 // It is not safe for cryptographic usage.
-func (r *Rand) RandUint16() uint16 {
-	return uint16(r.RandUint32() & (1<<16 - 1))
+func (r *Rand) Uint16() uint16 {
+	return uint16(r.rand.Uint32() & (1<<16 - 1))
 }
 
 // It is not safe for cryptographic usage.
-func (r *Rand) RandUint32() uint32 {
+func (r *Rand) Uint32() uint32 {
 	r.Lock()
-	u32 := r.Uint32()
+	u32 := r.rand.Uint32()
 	r.Unlock()
 	return u32
 }
 
 // It is not safe for cryptographic usage.
-func (r *Rand) RandUint64() uint64 {
-	return uint64(r.RandUint32())<<32 + uint64(r.RandUint32())
+func (r *Rand) Uint64() uint64 {
+	return uint64(r.rand.Uint32())<<32 + uint64(r.rand.Uint32())
 }
 
 // It is not safe for cryptographic usage.
-func (r *Rand) RandUint() uint {
+func (r *Rand) Uint() uint {
 	r.Lock()
-	i := r.Int()
+	i := r.rand.Int()
 	r.Unlock()
 	return uint(i)
 }
 
 // It is not safe for cryptographic usage.
-func (r *Rand) RandInt16() int16 {
-	return int16(r.RandUint32() & (1<<16 - 1))
+func (r *Rand) Int16() int16 {
+	return int16(r.rand.Uint32() & (1<<16 - 1))
 }
 
 // It is not safe for cryptographic usage.
-func (r *Rand) RandInt32() int32 {
-	return int32(r.RandUint32())
+func (r *Rand) Int32() int32 {
+	return int32(r.rand.Uint32())
 }
 
 // It is not safe for cryptographic usage.
-func (r *Rand) RandInt64() int64 {
-	return int64(r.RandUint64())
+func (r *Rand) Int64() int64 {
+	return int64(r.rand.Uint64())
 }
 
 // It is not safe for cryptographic usage.
-func (r *Rand) RandInt() int {
+func (r *Rand) Int() int {
 	r.Lock()
-	i := r.Int()
+	i := r.rand.Int()
 	r.Unlock()
 	return i
 }
 
 // It is not safe for cryptographic usage.
-func (r *Rand) RandInt31() int32 {
+func (r *Rand) Int31() int32 {
 	r.Lock()
-	i31 := r.Int31()
+	i31 := r.rand.Int31()
 	r.Unlock()
 	return i31
 }
 
 // It is not safe for cryptographic usage.
-func (r *Rand) RandInt63() int64 {
+func (r *Rand) Int63() int64 {
 	r.Lock()
-	i63 := r.Int63()
+	i63 := r.rand.Int63()
 	r.Unlock()
 	return i63
 }
 
 // Distributed pseudo-exponentially to test for various cases
 // It is not safe for cryptographic usage.
-func (r *Rand) RandUint16Exp() uint16 {
-	bits := r.RandUint32() % 16
+func (r *Rand) Uint16Exp() uint16 {
+	bits := r.rand.Uint32() % 16
 	if bits == 0 {
 		return 0
 	}
 	n := uint16(1 << (bits - 1))
-	n += uint16(r.RandInt31()) & ((1 << (bits - 1)) - 1)
+	n += uint16(r.rand.Int31()) & ((1 << (bits - 1)) - 1)
 	return n
 }
 
 // Distributed pseudo-exponentially to test for various cases
 // It is not safe for cryptographic usage.
-func (r *Rand) RandUint32Exp() uint32 {
-	bits := r.RandUint32() % 32
+func (r *Rand) Uint32Exp() uint32 {
+	bits := r.rand.Uint32() % 32
 	if bits == 0 {
 		return 0
 	}
 	n := uint32(1 << (bits - 1))
-	n += uint32(r.RandInt31()) & ((1 << (bits - 1)) - 1)
+	n += uint32(r.rand.Int31()) & ((1 << (bits - 1)) - 1)
 	return n
 }
 
 // Distributed pseudo-exponentially to test for various cases
 // It is not safe for cryptographic usage.
-func (r *Rand) RandUint64Exp() uint64 {
-	bits := r.RandUint32() % 64
+func (r *Rand) Uint64Exp() uint64 {
+	bits := r.rand.Uint32() % 64
 	if bits == 0 {
 		return 0
 	}
 	n := uint64(1 << (bits - 1))
-	n += uint64(r.RandInt63()) & ((1 << (bits - 1)) - 1)
+	n += uint64(r.rand.Int63()) & ((1 << (bits - 1)) - 1)
 	return n
 }
 
 // It is not safe for cryptographic usage.
-func (r *Rand) RandFloat32() float32 {
+func (r *Rand) Float32() float32 {
 	r.Lock()
-	f32 := r.Float32()
+	f32 := r.rand.Float32()
 	r.Unlock()
 	return f32
 }
 
 // It is not safe for cryptographic usage.
-func (r *Rand) RandTime() time.Time {
-	return time.Unix(int64(r.RandUint64Exp()), 0)
+func (r *Rand) Time() time.Time {
+	return time.Unix(int64(r.Uint64Exp()), 0)
 }
 
 // RandBytes returns n random bytes from the OS's source of entropy ie. via crypto/rand.
 // It is not safe for cryptographic usage.
-func (r *Rand) RandBytes(n int) []byte {
+func (r *Rand) Bytes(n int) []byte {
 	// cRandBytes isn't guaranteed to be fast so instead
 	// use random bytes generated from the internal PRNG
 	bs := make([]byte, n)
 	for i := 0; i < len(bs); i++ {
-		bs[i] = byte(r.RandInt() & 0xFF)
+		bs[i] = byte(r.rand.Int() & 0xFF)
 	}
 	return bs
 }
@@ -292,18 +292,18 @@ func (r *Rand) RandBytes(n int) []byte {
 // RandIntn returns, as an int, a non-negative pseudo-random number in [0, n).
 // It panics if n <= 0.
 // It is not safe for cryptographic usage.
-func (r *Rand) RandIntn(n int) int {
+func (r *Rand) Intn(n int) int {
 	r.Lock()
-	i := r.Intn(n)
+	i := r.rand.Intn(n)
 	r.Unlock()
 	return i
 }
 
 // RandPerm returns a pseudo-random permutation of n integers in [0, n).
 // It is not safe for cryptographic usage.
-func (r *Rand) RandPerm(n int) []int {
+func (r *Rand) Perm(n int) []int {
 	r.Lock()
-	perm := r.Perm(n)
+	perm := r.rand.Perm(n)
 	r.Unlock()
 	return perm
 }