org.ethereum.util.Value Java Examples

/**
 * Helper method to retrieve the actual node
 * If the node is not a list and length is > 32
 * bytes get the actual node from the db
 *
 * @param node -
 * @return
 */
private Value getNode(Object node) {

    Value val = new Value(node);

    // in that case we got a node
    // so no need to encode it
    if (!val.isBytes()) {
        return val;
    }

    byte[] keyBytes = val.asBytes();
    if (keyBytes.length == 0) {
        return val;
    } else if (keyBytes.length < 32) {
        return new Value(keyBytes);
    }
    return this.cache.get(keyBytes);
}
 

/****************************************
 * 			Private functions			*
 ****************************************/

private Object get(Object node, byte[] key) {

    // Return the node if key is empty (= found)
    if (key.length == 0 || isEmptyNode(node)) {
        return node;
    }

    Value currentNode = this.getNode(node);
    if (currentNode == null) return null;

    if (currentNode.length() == PAIR_SIZE) {
        // Decode the key
        byte[] k = unpackToNibbles(currentNode.get(0).asBytes());
        Object v = currentNode.get(1).asObj();

        if (key.length >= k.length && Arrays.equals(k, copyOfRange(key, 0, k.length))) {
            return this.get(v, copyOfRange(key, k.length, key.length));
        } else {
            return "";
        }
    } else {
        return this.get(currentNode.get(key[0]).asObj(), copyOfRange(key, 1, key.length));
    }
}
 

public String getTrieDump() {

        String root = "";
        TraceAllNodes traceAction = new TraceAllNodes();
        this.scanTree(this.getRootHash(), traceAction);

        if (this.getRoot() instanceof Value) {
            root = "root: " + Hex.toHexString(getRootHash()) +  " => " + this.getRoot() +  "\n";
        } else {
            root = "root: " + Hex.toHexString(getRootHash()) + "\n";
        }
        return root + traceAction.getOutput();
    }
 

private Object[] copyNode(Value currentNode) {
    Object[] itemList = emptyStringSlice(LIST_SIZE);
    for (int i = 0; i < LIST_SIZE; i++) {
        Object cpy = currentNode.get(i).asObj();
        if (cpy != null)
            itemList[i] = cpy;
    }
    return itemList;
}
 

/**
 * Put the node in the cache if RLP encoded value is longer than 32 bytes
 * 
 * @param o the Node which could be a pair-, multi-item Node or single Value  
 * @return sha3 hash of RLP encoded node if length > 32 otherwise return node itself
 */
public Object put(Object o) {
	Value value = new Value(o);
	byte[] enc = value.encode();
	if (enc.length >= 32) {
		byte[] sha = HashUtil.sha3(enc);
		this.nodes.put(new ByteArrayWrapper(sha), new Node(value, true));
		this.isDirty = true;
		return sha;
	}
	return value;
}
 

private List<byte[]> collect() {
	if (this.trie.getRoot() == "") {
		return null;
	}
	this.getNode(new Value(this.trie.getRoot()).asBytes());
	return this.shas;
}
 

private void workNode(Value currentNode) {
	if (currentNode.length() == 2) {
		byte[] k = unpackToNibbles(currentNode.get(0).asBytes());

		if (currentNode.get(1).asString() == "") {
			this.workNode(currentNode.get(1));
		} else {
			if (k[k.length-1] == 16) {
				this.values.add(currentNode.get(1).asString());
			} else {
				this.shas.add(currentNode.get(1).asBytes());
				this.getNode(currentNode.get(1).asBytes());
			}
		}
	} else {
		for (int i = 0; i < currentNode.length(); i++) {
			if (i == 16 && currentNode.get(i).length() != 0) {
				this.values.add(currentNode.get(i).asString());
			} else {
				if (currentNode.get(i).asString() == "") {
					this.workNode(currentNode.get(i));
				} else {
					String val = currentNode.get(i).asString();
					if (val != "") {
						this.shas.add(currentNode.get(1).asBytes());
						this.getNode(val.getBytes());
					}
				}
			}
		}
	}
}
 

public Value get(byte[] key) {
	ByteArrayWrapper keyObj = new ByteArrayWrapper(key);
	// First check if the key is the cache
	if (this.nodes.get(keyObj) != null) {
		return this.nodes.get(keyObj).getValue();
	}

	// Get the key of the database instead and cache it
	byte[] data = this.db.get(key);
	Value value = Value.fromRlpEncoded(data);
	// Create caching node
	this.nodes.put(keyObj, new Node(value, false));

	return value;
}
 

@Override
public byte[] get(byte[] key) {
    if (logger.isDebugEnabled()) 
    	logger.debug("Retrieving key {}", Hex.toHexString(key));
    byte[] k = binToNibbles(key);
    Value c = new Value(this.get(this.root, k));

    return (c == null)? null : c.asBytes();
}
 

@Override
public byte[] getRootHash() {
    if (root == null
            || (root instanceof byte[] && ((byte[]) root).length == 0)
            || (root instanceof String && "".equals((String) root))) {
        return ByteUtil.EMPTY_BYTE_ARRAY;
    } else if (root instanceof byte[]) {
        return (byte[]) this.getRoot();
    } else {
        Value rootValue = new Value(this.getRoot());
        byte[] val = rootValue.encode();
        return HashUtil.sha3(val);
    }
}
 

@Override
public void doOnNode(byte[] hash, Value node) {
    nodes.add(hash);
}
 

private boolean isEmptyNode(Object node) {
    Value n = new Value(node);
    return (node == null || (n.isString() && (n.asString() == "" || n.get(0).isNull())) || n.length() == 0);
}
 

@Override
public void doOnNode(byte[] hash, Value node) {
    ++counted;
}
 

private void getNode(byte[] node) {
	Value currentNode = this.trie.getCache().get(node);
	this.workNode(currentNode);
}
 

public Node(Value val) {
	this(val, false);
}
 

public Node(Value val, boolean dirty) {
	this.value = val;
	this.dirty = dirty;
}
 

public Value getValue() {
	return value;
}
 

@Override
public void doOnNode(byte[] hash, Value node) {

    output.append(Hex.toHexString(hash)).append(" ==> ").append(node.toString()).append("\n");
}
 

@Override
public byte[] serialize(Value object) {
    return object.asBytes();
}
 

public Value getValue() {
    return value;
}
 

public Node(Value val, boolean dirty) {
    this.value = val;
    this.dirty = dirty;
}
 

public Node(Value val) {
    this(val, false);
}
 

@Override
public Value deserialize(byte[] stream) {
    return new Value(stream);
}
 

@Override
public byte[] serialize(Value object) {
    return object.asBytes();
}
 

public Value getValue() {
    return value;
}
 

public Node(Value val, boolean dirty) {
    this.value = val;
    this.dirty = dirty;
}
 

public Node(Value val) {
    this(val, false);
}
 

@Override
public Value deserialize(byte[] stream) {
    return new Value(stream);
}
 

public void doOnNode(byte[] hash, Value node);