private static void PushDupPop(int times)
{
var compiler = new BytecodeCompiler();
for (int k = 0; k < times; k++)
{
compiler.Push(k);
}
compiler.Dup(times);
Machine machine = new Machine();
machine.Execute(compiler.ToBytes());
DataWord value = new DataWord(times);
Assert.AreEqual(DataWord.Zero, machine.Stack.Pop());
for (int k = 0; k < times; k++)
{
value = value.Subtract(DataWord.One);
Assert.AreEqual(value, machine.Stack.Pop());
}
Assert.AreEqual(0, machine.Stack.Size);
}
public ProgramInvoke(byte[] address, byte[] origin, byte[] caller, long balance,
long call_value, long token_value, long token_id, byte[] msg,
byte[] last_hash, byte[] coinbase, long timestamp,
long number, IDeposit deposit, long vm_start, long vm_should_end, long energy_limit)
{
this.address = new DataWord(address);
this.origin = new DataWord(origin);
this.caller = new DataWord(caller);
this.balance = new DataWord(balance);
this.call_value = new DataWord(call_value);
this.token_value = new DataWord(token_value);
this.token_id = new DataWord(token_id);
if (msg != null && msg.Length > 0)
{
Array.Copy(msg, 0, this.msg, 0, msg.Length);
}
this.prev_hash = new DataWord(last_hash);
this.coinbase = new DataWord(coinbase);
this.timestamp = new DataWord(timestamp);
this.number = new DataWord(number);
this.deposit = deposit;
this.vm_start = vm_start;
this.vm_should_end = vm_should_end;
this.energy_limit = energy_limit;
}
public void Not()
{
DataWord dw1 = new DataWord(new byte[] { 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0 });
DataWord dw2 = new DataWord(new byte[] { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f });
Assert.AreEqual(dw2, dw1.Not());
}
public override void OnStackPush(DataWord value)
{
if (this.enabled)
{
actions.AddStackPush(value);
}
}
public ProgramInvoke(DataWord address, DataWord origin, DataWord caller, DataWord balance,
DataWord call_value, DataWord token_value, DataWord token_id, byte[] msg,
DataWord last_hash, DataWord coinbase, DataWord timestamp, DataWord number,
DataWord difficulty,
IDeposit deposit, int call_deep, bool is_static_call, bool is_testing_suite,
long vm_start, long vm_should_end, long energy_limit)
{
this.address = address;
this.origin = origin;
this.caller = caller;
this.balance = balance;
this.call_value = call_value;
this.token_value = token_value;
this.token_id = token_id;
if (msg != null && msg.Length > 0)
{
Array.Copy(msg, 0, this.msg, 0, msg.Length);
}
this.prev_hash = last_hash;
this.coinbase = coinbase;
this.timestamp = timestamp;
this.number = number;
this.call_deep = call_deep;
this.deposit = deposit;
this.by_transaction = false;
this.is_static_call = is_static_call;
this.is_testing_suite = is_testing_suite;
this.vm_start = vm_start;
this.vm_should_end = vm_should_end;
this.energy_limit = energy_limit;
}
public ReturnDataCopyIllegalBoundsException(DataWord offset, DataWord size, long return_data_size)
: base(string.Format("Illegal RETURNDATACOPY arguments: offset (%s) + size (%s) > RETURNDATASIZE (%d)",
offset,
size,
return_data_size))
{
}
public void Xor()
{
DataWord dw1 = new DataWord(new byte[] { 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0 });
DataWord dw2 = new DataWord(new byte[] { 0xf1, 0x1f, 0xf1, 0x1f, 0xf1, 0x1f });
DataWord dw3 = new DataWord(new byte[] { 0xfe, 0xef, 0xfe, 0xef, 0xfe, 0xef });
Assert.AreEqual(dw3, dw1.Xor(dw2));
}
public void And()
{
DataWord dw1 = new DataWord(new byte[] { 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0 });
DataWord dw2 = new DataWord(new byte[] { 0xf1, 0x1f, 0xf1, 0x1f, 0xf1, 0x1f });
DataWord dw3 = new DataWord(new byte[] { 0x01, 0x10, 0x01, 0x10, 0x01, 0x10 });
Assert.AreEqual(dw3, dw1.And(dw2));
}
public void DivideSixIntoThree()
{
var dw = new DataWord(6);
var result = dw.Divide(new DataWord(3)).Value;
Assert.IsNotNull(result);
Assert.AreEqual(new BigInteger(2), result);
}
public void NegatePositiveInteger()
{
var dw = new DataWord(3);
var result = dw.Negate();
Assert.IsNotNull(result);
Assert.AreEqual(new DataWord(-3), result);
}
public void GetSmallIntegerAsBigInteger()
{
var dw = new DataWord(1);
var result = dw.Value;
Assert.IsNotNull(result);
Assert.AreEqual(BigInteger.One, result);
}
public void AddOneToOne()
{
var dw = new DataWord(1);
var result = dw.Add(dw).Value;
Assert.IsNotNull(result);
Assert.AreEqual(new BigInteger(2), result);
}
public void MultiplyTwoByThree()
{
var dw = new DataWord(2);
var result = dw.Multiply(new DataWord(3)).Value;
Assert.IsNotNull(result);
Assert.AreEqual(new BigInteger(6), result);
}
public void SubtractOneFromTwo()
{
var dw = new DataWord(2);
var result = dw.Subtract(new DataWord(1)).Value;
Assert.IsNotNull(result);
Assert.AreEqual(BigInteger.One, result);
}
public void SubtractMinusOneFromTwo()
{
var dw = new DataWord(2);
var result = dw.Subtract(new DataWord(-1)).Value;
Assert.IsNotNull(result);
Assert.AreEqual(new BigInteger(3), result);
}
public void AddOneToMinusOne()
{
var dw = new DataWord(1);
var dw2 = new DataWord(-1);
var result = dw.Add(dw2).Value;
Assert.IsNotNull(result);
Assert.AreEqual(BigInteger.Zero, result);
}
public SolidityMessageCall(SolidityOpCodes opCode, DataWord gas,
DataWord codeAddress, DataWord endowment, DataWord inDataOffs, DataWord inDataSize)
{
OpCode = opCode;
Gas = gas;
CodeAddress = codeAddress;
Endowment = endowment;
InDataOffs = inDataOffs;
InDataSize = inDataSize;
}
public void PutStorageValue(byte[] address, DataWord key, DataWord value)
{
if (CanListenTrace(address))
{
this.program_listener.OnStoragePut(key, value);
}
else
{
this.deposit.PutStorageValue(address, key, value);
}
}
public void Put(DataWord key, DataWord value)
{
if (this.row_cache.ContainsKey(key))
{
this.row_cache[key].Value = value;
}
else
{
byte[] row_key = Compose(key.Data, this.address_hash);
this.row_cache.Add(key, new StorageRowCapsule(row_key, value.Data));
}
}
public Op AddOp(byte code, int pc, int deep, DataWord energy, OpActions actions)
{
Op op = new Op();
op.Code = (OpCode)code;
op.PC = pc;
op.Deep = deep;
op.Energy = energy.ToBigInteger();
op.Actions = actions;
this.ops.Add(op);
return(op);
}
public IProgramInvoke CreateProgramInvoke(Program program,
DataWord to_adderess,
DataWord caller_address,
DataWord in_value,
DataWord token_value,
DataWord token_id,
long in_balance,
byte[] in_data,
IDeposit deposit,
bool is_static_call,
bool is_testing_suite,
long vm_start,
long vm_should_end,
long energy_limit)
{
DataWord address = to_adderess;
DataWord origin = program.OriginAddress;
DataWord caller = caller_address;
DataWord balance = new DataWord(in_balance);
DataWord call_value = in_value;
byte[] data = null;
Array.Copy(in_data, 0, data, 0, in_data.Length);
DataWord last_hash = program.PrevHash;
DataWord coinbase = program.Coinbase;
DataWord timestamp = program.Timestamp;
DataWord number = program.Number;
DataWord difficulty = program.Difficulty;
return(new ProgramInvoke(address,
origin,
caller,
balance,
call_value,
token_value,
token_id,
data,
last_hash,
coinbase,
timestamp,
number,
difficulty,
deposit,
program.CallDeep + 1,
is_static_call,
is_testing_suite,
vm_start,
vm_should_end,
energy_limit));
}
public override void OnStoragePut(DataWord key, DataWord value)
{
if (this.enabled)
{
if (value == DataWord.ZERO)
{
actions.AddStorageRemove(key);
}
else
{
actions.AddStoragePut(key, value);
}
}
}
public void CreateDataWordUsingNegativeInteger()
{
var dw = new DataWord(-1);
var result = dw.Bytes;
Assert.IsNotNull(result);
Assert.AreEqual(32, result.Length);
for (int k = 0; k < 32; k++)
{
Assert.AreEqual(0xff, result[k]);
}
}
public void CreateDataWordUsingBytes()
{
var dw = new DataWord(new byte[] { 0x01, 0x02 });
Assert.AreEqual(new BigInteger(258), dw.Value);
var result = dw.Bytes;
for (int k = 0; k < 30; k++)
{
Assert.AreEqual(0x00, result[k]);
}
Assert.AreEqual(0x01, result[30]);
Assert.AreEqual(0x02, result[31]);
}
public void Not()
{
DataWord dw1 = new DataWord(new byte[] { 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0 });
DataWord dw2 = new DataWord(new byte[] { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f });
var compiler = new BytecodeCompiler();
compiler.Push(dw1);
compiler.Not();
Machine machine = new Machine();
machine.Execute(compiler.ToBytes());
Assert.AreEqual(dw2, machine.Stack.Pop());
}
public void CreateDataWordUsingPositiveInteger()
{
var dw = new DataWord(1);
var result = dw.Bytes;
Assert.IsNotNull(result);
Assert.AreEqual(32, result.Length);
for (int k = 0; k < 31; k++)
{
Assert.AreEqual(0x00, result[k]);
}
Assert.AreEqual(0x01, result[31]);
}
public void CreateDataWordUsingPositiveLongInteger()
{
var dw = new DataWord(0x0100000000L);
var result = dw.Bytes;
Assert.IsNotNull(result);
Assert.AreEqual(32, result.Length);
for (int k = 0; k < 32; k++)
{
if (k != 32 - 5)
{
Assert.AreEqual(0x00, result[k]);
}
}
Assert.AreEqual(0x01, result[32 - 5]);
}
public void Equals()
{
var dw1 = new DataWord(1);
var dw2 = new DataWord(2);
var dw3 = new DataWord(1);
Assert.AreEqual(dw1, dw1);
Assert.AreEqual(dw1, dw3);
Assert.AreEqual(dw3, dw1);
Assert.IsFalse(dw1.Equals(null));
Assert.AreNotEqual(dw1, null);
Assert.AreNotEqual(dw1, "foo");
Assert.AreNotEqual(dw1, 42);
Assert.AreNotEqual(dw1, dw2);
Assert.AreEqual(dw1.GetHashCode(), dw3.GetHashCode());
}
public void PutStorageValue(byte[] address, DataWord key, DataWord value)
{
address = Wallet.ToAddAddressPrefix(address);
if (GetAccount(address) != null)
{
Key address_key = new Key(address);
VMStorage storage = null;
if (this.storage_cache.ContainsKey(address_key))
{
storage = this.storage_cache[address_key];
}
else
{
storage = GetStorage(address);
this.storage_cache.Add(address_key, storage);
}
storage.Put(key, value);
}
}
public DataWord GetDataValue(DataWord index_data)
{
BigInteger temp_index = index_data.ToBigInteger();
int index = temp_index.IntValue;
int size = 32; // maximum datavalue size
if (msg == null || index >= msg.Length ||
temp_index.CompareTo(MAX_MSG_DATA) > 0)
{
return(new DataWord());
}
if (index + size > msg.Length)
{
size = msg.Length - index;
}
byte[] data = new byte[32];
Array.Copy(msg, index, data, 0, size);
return(new DataWord(data));
}
