public void Can_estimate_with_stipend()
{
byte[] initByteCode = Prepare.EvmCode
.CallWithValue(Address.Zero, 0, 1)
.Op(Instruction.STOP)
.Done;
long gasLimit = 100000;
Transaction tx = Build.A.Transaction.SignedAndResolved(_ethereumEcdsa, TestItem.PrivateKeyA, _isEip155Enabled).WithInit(initByteCode).WithGasLimit(gasLimit).TestObject;
Block block = Build.A.Block.WithNumber(MainnetSpecProvider.MuirGlacierBlockNumber).WithTransactions(tx).WithGasLimit(2 * gasLimit).TestObject;
IntrinsicGasCalculator gasCalculator = new IntrinsicGasCalculator();
long intrinsic = gasCalculator.Calculate(tx, MuirGlacier.Instance);
GethLikeTxTracer gethTracer = new GethLikeTxTracer(GethTraceOptions.Default);
_transactionProcessor.CallAndRestore(tx, block.Header, gethTracer);
TestContext.WriteLine(new EthereumJsonSerializer().Serialize(gethTracer.BuildResult(), true));
EstimateGasTracer tracer = new EstimateGasTracer();
_transactionProcessor.CallAndRestore(tx, block.Header, tracer);
long actualIntrinsic = tx.GasLimit - tracer.IntrinsicGasAt;
actualIntrinsic.Should().Be(intrinsic);
tracer.CalculateAdditionalGasRequired(tx).Should().Be(2300);
tracer.GasSpent.Should().Be(85669L);
long estimate = tracer.CalculateEstimate(tx);
estimate.Should().Be(87969L);
ConfirmEnoughEstimate(tx, block, estimate);
}
private void ConfirmEnoughEstimate(Transaction tx, Block block, long estimate)
{
CallOutputTracer outputTracer = new CallOutputTracer();
tx.GasLimit = estimate;
TestContext.WriteLine(tx.GasLimit);
GethLikeTxTracer gethTracer = new GethLikeTxTracer(GethTraceOptions.Default);
_transactionProcessor.CallAndRestore(tx, block.Header, gethTracer);
string traceEnoughGas = new EthereumJsonSerializer().Serialize(gethTracer.BuildResult(), true);
_transactionProcessor.CallAndRestore(tx, block.Header, outputTracer);
traceEnoughGas.Should().NotContain("OutOfGas");
outputTracer = new CallOutputTracer();
tx.GasLimit = Math.Min(estimate - 1, estimate * 63 / 64);
TestContext.WriteLine(tx.GasLimit);
gethTracer = new GethLikeTxTracer(GethTraceOptions.Default);
_transactionProcessor.CallAndRestore(tx, block.Header, gethTracer);
string traceOutOfGas = new EthereumJsonSerializer().Serialize(gethTracer.BuildResult(), true);
TestContext.WriteLine(traceOutOfGas);
_transactionProcessor.CallAndRestore(tx, block.Header, outputTracer);
bool failed = traceEnoughGas.Contains("failed") || traceEnoughGas.Contains("OutOfGas");
failed.Should().BeTrue();
}
protected GethLikeTxTrace ExecuteAndTrace(long blockNumber, long gasLimit, params byte[] code)
{
GethLikeTxTracer tracer = new GethLikeTxTracer(GethTraceOptions.Default);
(var block, var transaction) = PrepareTx(blockNumber, gasLimit, code);
_processor.Execute(transaction, block.Header, tracer);
return(tracer.BuildResult());
}
protected GethLikeTxTrace ExecuteAndTrace(params byte[] code)
{
GethLikeTxTracer tracer = new GethLikeTxTracer();
(var block, var transaction) = PrepareTx(BlockNumber, 100000, code);
_processor.Execute(transaction, block.Header, tracer);
return(tracer.BuildResult());
}
public void Can_Run_Smoke_test()
{
var code = Bytes.FromHexString("0x600060000100");
GethLikeTxTracer txTracer = RunVirtualMachine(code);
EthereumJsonSerializer serializer = new EthereumJsonSerializer();
var trace = txTracer.BuildResult();
_testOutputHelper.WriteLine(serializer.Serialize(trace, true));
}
public void Can_Invoke_Address()
{
var code = Bytes.FromHexString("0x3000");
GethLikeTxTracer txTracer = RunVirtualMachine(code);
EthereumJsonSerializer serializer = new EthereumJsonSerializer();
var trace = txTracer.BuildResult();
_testOutputHelper.WriteLine(serializer.Serialize(trace, true));
trace.Failed.Should().Be(false);
trace.Entries.Last().Stack.Count.Should().Be(1);
trace.Entries.Last().Stack.Last().Should().Be(VirtualMachine.BytesZero32.ToHexString());
}
public void Can_Invoke_Gas_Limit()
{
var code = Bytes.FromHexString("0x4500");
GethLikeTxTracer txTracer = RunVirtualMachine(code);
EthereumJsonSerializer serializer = new EthereumJsonSerializer();
var trace = txTracer.BuildResult();
_testOutputHelper.WriteLine(serializer.Serialize(trace, true));
trace.Failed.Should().Be(false);
trace.Entries.Last().Stack.Count.Should().Be(1);
trace.Entries.Last().Stack.Last().Should().Be("f4240".PadLeft(64, '0'));
}
public void Can_Invoke_Range_Proof_Precompile()
{
var code = Bytes.FromHexString("0x60008080806201000062050000F400");
GethLikeTxTracer txTracer = RunVirtualMachine(code);
EthereumJsonSerializer serializer = new EthereumJsonSerializer();
GethLikeTxTrace trace = txTracer.BuildResult();
TestContext.WriteLine(serializer.Serialize(trace, true));
trace.Failed.Should().Be(false);
trace.Entries.Last().Stack.Count.Should().Be(1);
trace.Entries.Last().Stack.Last().Should().Be(VirtualMachine.BytesOne32.ToHexString());
}
public void Blake_precompile()
{
Address blakeAddress = Address.FromNumber(1 + KatVirtualMachine.CatalystPrecompilesAddressingSpace);
string addressCode = blakeAddress.Bytes.ToHexString(false);
var code = Bytes.FromHexString("0x602060006080600073" + addressCode + "45fa00");
GethLikeTxTracer txTracer = RunVirtualMachine(code);
EthereumJsonSerializer serializer = new EthereumJsonSerializer();
GethLikeTxTrace trace = txTracer.BuildResult();
TestContext.WriteLine(serializer.Serialize(trace, true));
trace.Entries.Last().Stack.First().Should().Be("0000000000000000000000000000000000000000000000000000000000000001");
trace.Entries.Last().Memory.First().Should().Be("378d0caaaa3855f1b38693c1d6ef004fd118691c95c959d4efa950d6d6fcf7c1");
}
public void Ed25519_precompile_can_verify_correct_sig()
{
HashProvider hashProvider = new HashProvider(HashingAlgorithm.GetAlgorithmMetadata("blake2b-256"));
FfiWrapper cryptoContext = new FfiWrapper();
IPrivateKey signingPrivateKey = cryptoContext.GeneratePrivateKey();
var signingPublicKeyBytes = signingPrivateKey.GetPublicKey().Bytes;
var byteCode = PrepareEd25519PrecompileCall(hashProvider, cryptoContext, signingPrivateKey, signingPrivateKey);
GethLikeTxTracer txTracer = RunVirtualMachine(byteCode);
EthereumJsonSerializer serializer = new EthereumJsonSerializer();
GethLikeTxTrace trace = txTracer.BuildResult();
TestContext.WriteLine(serializer.Serialize(trace, true));
trace.Entries.Last().Stack.First().Should().Be("0000000000000000000000000000000000000000000000000000000000000001");
trace.Entries.Last().Memory.First().Should().StartWith("01");
}
public void Ed25519_precompile_can_report_too_long_input()
{
var byteCode = Bytes.FromHexString(
// PUSH1 32 PUSH1 0 PUSH1 192 PUSH1 0 PUSH20 address GAS STATICCALL
// make a call to precompile and pass invalid [0,192) bytes of memory as an input
// and store result at [0,1) of memory array
// allow precompile to use all the gas required
"6001600060c0600073" +
GetEd25519PrecompileAddressAsHex() +
"45fa00");
GethLikeTxTracer txTracer = RunVirtualMachine(byteCode);
EthereumJsonSerializer serializer = new EthereumJsonSerializer();
GethLikeTxTrace trace = txTracer.BuildResult();
TestContext.WriteLine(serializer.Serialize(trace, true));
trace.Entries.Last().Stack.First().Should().Be("0000000000000000000000000000000000000000000000000000000000000000");
}
public void Can_estimate_with_refund()
{
byte[] initByteCode = Prepare.EvmCode
.PushData(1)
.PushData(1)
.Op(Instruction.SSTORE)
.PushData(0)
.PushData(1)
.Op(Instruction.SSTORE)
.Op(Instruction.STOP)
.Done;
long gasLimit = 100000;
Transaction tx = Build.A.Transaction.SignedAndResolved(_ethereumEcdsa, TestItem.PrivateKeyA, 1).WithInit(initByteCode).WithGasLimit(gasLimit).TestObject;
Block block = Build.A.Block.WithNumber(MainnetSpecProvider.MuirGlacierBlockNumber).WithTransactions(tx).WithGasLimit(2 * gasLimit).TestObject;
IntrinsicGasCalculator gasCalculator = new IntrinsicGasCalculator();
long intrinsic = gasCalculator.Calculate(tx, MuirGlacier.Instance);
GethLikeTxTracer gethTracer = new GethLikeTxTracer(GethTraceOptions.Default);
_transactionProcessor.CallAndRestore(tx, block.Header, gethTracer);
TestContext.WriteLine(new EthereumJsonSerializer().Serialize(gethTracer.BuildResult(), true));
EstimateGasTracer tracer = new EstimateGasTracer();
_transactionProcessor.CallAndRestore(tx, block.Header, tracer);
long actualIntrinsic = tx.GasLimit - tracer.IntrinsicGasAt;
actualIntrinsic.Should().Be(intrinsic);
tracer.CalculateAdditionalGasRequired(tx).Should().Be(RefundOf.SSetReversedEip2200 + GasCostOf.CallStipend - GasCostOf.SStoreNetMeteredEip2200 + 1);
tracer.GasSpent.Should().Be(54764L);
long estimate = tracer.CalculateEstimate(tx);
estimate.Should().Be(75465L);
ConfirmEnoughEstimate(tx, block, estimate);
}
public void Can_estimate_with_destroy_refund_and_below_intrinsic()
{
byte[] initByteCode = Prepare.EvmCode.ForInitOf(Prepare.EvmCode.PushData(Address.Zero).Op(Instruction.SELFDESTRUCT).Done).Done;
Address contractAddress = ContractAddress.From(TestItem.PrivateKeyA.Address, 0);
byte[] byteCode = Prepare.EvmCode
.Call(contractAddress, 46179)
.Op(Instruction.STOP).Done;
long gasLimit = 100000;
Transaction initTx = Build.A.Transaction.SignedAndResolved(_ethereumEcdsa, TestItem.PrivateKeyA, _isEip155Enabled).WithInit(initByteCode).WithGasLimit(gasLimit).TestObject;
Transaction tx = Build.A.Transaction.SignedAndResolved(_ethereumEcdsa, TestItem.PrivateKeyA, _isEip155Enabled).WithInit(byteCode).WithGasLimit(gasLimit).WithNonce(1).TestObject;
Block block = Build.A.Block.WithNumber(MainnetSpecProvider.MuirGlacierBlockNumber).WithTransactions(tx).WithGasLimit(2 * gasLimit).TestObject;
IntrinsicGasCalculator gasCalculator = new IntrinsicGasCalculator();
long intrinsic = gasCalculator.Calculate(tx, MuirGlacier.Instance);
_transactionProcessor.Execute(initTx, block.Header, NullTxTracer.Instance);
EstimateGasTracer tracer = new EstimateGasTracer();
GethLikeTxTracer gethTracer = new GethLikeTxTracer(GethTraceOptions.Default);
_transactionProcessor.CallAndRestore(tx, block.Header, tracer);
_transactionProcessor.CallAndRestore(tx, block.Header, gethTracer);
TestContext.WriteLine(new EthereumJsonSerializer().Serialize(gethTracer.BuildResult(), true));
long actualIntrinsic = tx.GasLimit - tracer.IntrinsicGasAt;
actualIntrinsic.Should().Be(intrinsic);
tracer.CalculateAdditionalGasRequired(tx).Should().Be(24080);
tracer.GasSpent.Should().Be(35228L);
long estimate = tracer.CalculateEstimate(tx);
estimate.Should().Be(59308);
ConfirmEnoughEstimate(tx, block, estimate);
}
