Example #1
0
func traverseLink(addr []byte, name, key string, state *monkstate.State, dir int) ([]byte, []byte) {
	bigBase := big.NewInt(0)

	obj := state.GetStateObject(addr)
	base := VariName(name)

	// key should be trailing 20 bytes
	if l := len(key); l > 20 {
		key = key[l-20:]
	}

	// get slot for this keyed element of linked list
	keyBytes := monkutil.PackTxDataArgs2(key)
	keyBytesShift := append(keyBytes, []byte{1, 0, 0}...)[3:]
	slotBig := bigBase.Add(monkutil.BigD(base), monkutil.BigD(keyBytesShift))

	// next locator is this slot plus 2
	// prev locator is this slot plus 1
	slotNextLoc := bigBase.Add(slotBig, big.NewInt(int64(dir)))
	slotNext := obj.GetStorage(slotNextLoc)
	if slotNext.IsNil() {
		slotNextLoc = monkutil.BigD(append(base[:len(base)-1], byte(StdVarSize+1)))
		slotNext = obj.GetStorage(slotNextLoc)
	}

	keyB := slotNext.Bytes()
	keyB = keyB[9:29]
	// value is right at slot
	v := obj.GetStorage(slotNext.BigInt())
	return keyB, v.Bytes()
}
Example #2
0
// key must come as hex!!!!!!
// Return an element from keyed array type
func GetKeyedArrayElement(addr []byte, name, key string, index int, state *monkstate.State) []byte {
	bigBase := big.NewInt(0)
	bigBase2 := big.NewInt(0)

	obj := state.GetStateObject(addr)
	base := VariName(name)

	// how big are the elements stored in this array:
	sizeLocator := make([]byte, len(base))
	copy(sizeLocator, base)
	sizeLocator = append(sizeLocator[:31], byte(StdVarSize+1))
	elementSizeBytes := (obj.GetStorage(monkutil.BigD(sizeLocator))).Bytes()
	elementSize := monkutil.BigD(elementSizeBytes).Uint64()

	// key should be trailing 20 bytes
	if len(key) >= 2 && key[:2] == "0x" {
		key = key[2:]
	}
	if l := len(key); l > 40 {
		key = key[l-40:]
	}

	// what slot does the array start at:
	keyBytes := monkutil.PackTxDataArgs2("0x" + key)
	keyBytesShift := append(keyBytes[3:], []byte{1, 0, 0}...)
	slotBig := bigBase.Add(monkutil.BigD(base), monkutil.BigD(keyBytesShift))

	//numElements := obj.GetStorage(slotBig)

	// which slot (row), and where in that slot (col) is the element we want:
	entriesPerRow := int64(256 / elementSize)
	rowN := int64(index) / entriesPerRow
	colN := int64(index) % entriesPerRow

	row := bigBase.Add(big.NewInt(1), bigBase.Add(slotBig, big.NewInt(rowN))).Bytes()
	rowStorage := (obj.GetStorage(monkutil.BigD(row))).Bytes()
	rowStorageBig := monkutil.BigD(rowStorage)

	elSizeBig := monkutil.BigD(elementSizeBytes)
	// row storage gives us a big number, from which we need to pull
	// an element of size elementsize.
	// so divide it by 2^(colN*elSize) and take modulo 2^elsize
	// divide row storage by 2^(colN*elSize)
	colBig := bigBase.Exp(big.NewInt(2), bigBase.Mul(elSizeBig, big.NewInt(colN)), nil)
	r := bigBase.Div(rowStorageBig, colBig)
	w := bigBase2.Exp(big.NewInt(2), elSizeBig, nil)
	v := bigBase.Mod(r, w)
	return v.Bytes()
}
Example #3
0
// Return an element from a linked list
func GetLinkedListElement(addr []byte, name, key string, state *monkstate.State) []byte {

	bigBase := big.NewInt(0)

	obj := state.GetStateObject(addr)
	base := VariName(name)

	// key should be trailing 20 bytes
	if l := len(key); l > 20 {
		key = key[l-20:]
	}

	// get slot for this keyed element of linked list
	keyBytes := monkutil.PackTxDataArgs2(key)
	keyBytesShift := append(keyBytes, []byte{1, 0, 0}...)[3:]
	slotBig := bigBase.Add(monkutil.BigD(base), monkutil.BigD(keyBytesShift))

	// value is right at slot
	v := obj.GetStorage(slotBig)
	return v.Bytes()
}
Example #4
0
// location of a var is 1 followed by the first 8 bytes of its sha3
func VariName(name string) []byte {
	h := monkcrypto.Sha3Bin(monkutil.PackTxDataArgs2(name))
	base := append([]byte{1}, h[:8]...)
	base = append(base, bytes.Repeat([]byte{0}, 32-len(base))...)
	return base
}