コード例 #1
0
  @Override
  public DataWord get(DataWord key) {

    DataWord value = storage.get(key);
    if (value != null) value = value.clone();
    return value;
  }
コード例 #2
0
  @Test
  public void testAddPerformance() {
    boolean enabled = false;

    if (enabled) {
      byte[] one =
          new byte[] {
            0x01, 0x31, 0x54, 0x41, 0x01, 0x31, 0x54, 0x41, 0x01, 0x31, 0x54, 0x41, 0x01, 0x31,
            0x54, 0x41, 0x01, 0x31, 0x54, 0x41, 0x01, 0x31, 0x54, 0x41, 0x01, 0x31, 0x54, 0x41,
            0x01, 0x31, 0x54, 0x41
          }; // Random value

      int ITERATIONS = 10000000;

      long now1 = System.currentTimeMillis();
      for (int i = 0; i < ITERATIONS; i++) {
        DataWord x = new DataWord(one);
        x.add(x);
      }
      System.out.println("Add1: " + (System.currentTimeMillis() - now1) + "ms");

      long now2 = System.currentTimeMillis();
      for (int i = 0; i < ITERATIONS; i++) {
        DataWord x = new DataWord(one);
        x.add2(x);
      }
      System.out.println("Add2: " + (System.currentTimeMillis() - now2) + "ms");
    } else {
      System.out.println("ADD performance test is disabled.");
    }
  }
コード例 #3
0
  @Test(expected = IndexOutOfBoundsException.class)
  public void testSignExtendException2() {

    byte k = 32;
    DataWord x = new DataWord();

    x.signExtend(k); // should throw an exception
  }
コード例 #4
0
  @Test
  public void testSignExtend2() {
    DataWord x = new DataWord(Hex.decode("f2"));
    byte k = 1;
    String expected = "00000000000000000000000000000000000000000000000000000000000000f2";

    x.signExtend(k);
    System.out.println(x.toString());
    assertEquals(expected, x.toString());
  }
コード例 #5
0
  @Test
  public void testSignExtend7() {

    byte k = 3;
    DataWord x = new DataWord(Hex.decode("ab82345678"));
    String expected = "ffffffffffffffffffffffffffffffffffffffffffffffffffffffff82345678";

    x.signExtend(k);
    System.out.println(x.toString());
    assertEquals(expected, x.toString());
  }
コード例 #6
0
  @Override
  public byte[] getStorageHash() {

    SecureTrie storageTrie = new SecureTrie(null);

    for (DataWord key : storage.keySet()) {

      DataWord value = storage.get(key);

      storageTrie.update(key.getData(), RLP.encodeElement(value.getNoLeadZeroesData()));
    }

    return storageTrie.getRootHash();
  }
コード例 #7
0
  @Test
  public void testMul() {
    byte[] one = new byte[32];
    one[31] = 0x1; // 0x0000000000000000000000000000000000000000000000000000000000000001

    byte[] two = new byte[32];
    two[11] = 0x1; // 0x0000000000000000000000010000000000000000000000000000000000000000

    DataWord x = new DataWord(one); // System.out.println(x.value());
    DataWord y = new DataWord(two); // System.out.println(y.value());
    x.mul(y);
    assertEquals(32, y.getData().length);
    assertEquals(
        "0000000000000000000000010000000000000000000000000000000000000000",
        Hex.toHexString(y.getData()));
  }
コード例 #8
0
  @Test
  public void testAdd3() {
    byte[] three = new byte[32];
    for (int i = 0; i < three.length; i++) {
      three[i] = (byte) 0xff;
    }

    DataWord x = new DataWord(three);
    x.add(new DataWord(three));
    assertEquals(32, x.getData().length);
    System.out.println(Hex.toHexString(x.getData()));

    // FAIL
    //		DataWord y = new DataWord(three);
    //		y.add2(new DataWord(three));
    //		System.out.println(Hex.toHexString(y.getData()));
  }
コード例 #9
0
  @Test
  public void testMod() {
    String expected = "000000000000000000000000000000000000000000000000000000000000001a";

    byte[] one = new byte[32];
    one[31] = 0x1e; // 0x000000000000000000000000000000000000000000000000000000000000001e

    byte[] two = new byte[32];
    for (int i = 0; i < two.length; i++) {
      two[i] = (byte) 0xff;
    }
    two[31] = 0x56; // 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff56

    DataWord x = new DataWord(one); // System.out.println(x.value());
    DataWord y = new DataWord(two); // System.out.println(y.value());
    y.mod(x);
    assertEquals(32, y.getData().length);
    assertEquals(expected, Hex.toHexString(y.getData()));
  }
コード例 #10
0
  @Override
  public void put(DataWord key, DataWord value) {

    if (value.equals(DataWord.ZERO)) {
      storage.remove(key);
    } else {

      storage.put(key, value);
    }

    this.setDirty(true);
  }
コード例 #11
0
  @Override
  public byte[] getEncoded() {

    byte[][] keys = new byte[storage.size()][];
    byte[][] values = new byte[storage.size()][];

    int i = 0;
    for (DataWord key : storage.keySet()) {

      DataWord value = storage.get(key);

      keys[i] = RLP.encodeElement(key.getData());
      values[i] = RLP.encodeElement(value.getNoLeadZeroesData());

      ++i;
    }

    byte[] rlpKeysList = RLP.encodeList(keys);
    byte[] rlpValuesList = RLP.encodeList(values);
    byte[] rlpCode = RLP.encodeElement(code);

    return RLP.encodeList(rlpKeysList, rlpValuesList, rlpCode);
  }
コード例 #12
0
  @Test
  public void testAdd2() {
    byte[] two = new byte[32];
    two[31] = (byte) 0xff; // 0x000000000000000000000000000000000000000000000000000000000000ff

    DataWord x = new DataWord(two);
    x.add(new DataWord(two));
    System.out.println(Hex.toHexString(x.getData()));

    DataWord y = new DataWord(two);
    y.add2(new DataWord(two));
    System.out.println(Hex.toHexString(y.getData()));
  }
コード例 #13
0
 @Override
 public byte[] getStorageSlot(byte[] slot) {
   DataWord ret =
       getBlockchain().getRepository().getContractDetails(contractAddr).get(new DataWord(slot));
   return ret.getData();
 }