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()
}
// 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()
}
// 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()
}
// 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
}