/// <summary>
/// Invokes a method on an existing smart contract
/// </summary>
public VmExecutionResult ExecuteMethod(ISmartContractState contractState, RuntimeObserver.IGasMeter gasMeter, MethodCall methodCall, byte[] contractCode, string typeName)
{
ContractByteCode code;
// Code we're loading from database - can assume it's valid.
using (IContractModuleDefinition moduleDefinition = this.moduleDefinitionReader.Read(contractCode).Value)
{
var observer = new Observer(gasMeter, new MemoryMeter(MemoryUnitLimit));
var rewriter = new ObserverRewriter(observer);
if (!this.Rewrite(moduleDefinition, rewriter))
{
return(VmExecutionResult.Fail(VmExecutionErrorKind.RewriteFailed, "Rewrite module failed"));
}
Result <ContractByteCode> getCodeResult = this.GetByteCode(moduleDefinition);
if (!getCodeResult.IsSuccess)
{
return(VmExecutionResult.Fail(VmExecutionErrorKind.RewriteFailed, "Serialize module failed"));
}
code = getCodeResult.Value;
}
Result <IContract> contractLoadResult = this.Load(
code,
typeName,
contractState.Message.ContractAddress.ToUint160(),
contractState);
if (!contractLoadResult.IsSuccess)
{
return(VmExecutionResult.Fail(VmExecutionErrorKind.LoadFailed, contractLoadResult.Error));
}
IContract contract = contractLoadResult.Value;
this.LogExecutionContext(contract.State.Block, contract.State.Message, contract.Address);
IContractInvocationResult invocationResult = contract.Invoke(methodCall);
if (!invocationResult.IsSuccess)
{
this.logger.LogTrace("(-)[CALLCONTRACT_INSTANTIATION_FAILED]");
return(GetInvocationVmErrorResult(invocationResult));
}
this.logger.LogTrace("[CALL_CONTRACT_INSTANTIATION_SUCCEEDED]");
return(VmExecutionResult.Ok(invocationResult.Return, typeName));
}
/// <summary>
/// Invokes a method on an existing smart contract
/// </summary>
public VmExecutionResult ExecuteMethod(ISmartContractState contractState, MethodCall methodCall, byte[] contractCode, string typeName)
{
this.logger.LogTrace("(){0}:{1}", nameof(methodCall.Name), methodCall.Name);
ContractByteCode code;
// Code we're loading from database - can assume it's valid.
using (IContractModuleDefinition moduleDefinition = this.moduleDefinitionReader.Read(contractCode).Value)
{
var observer = new Observer(contractState.GasMeter, MemoryUnitLimit);
var rewriter = new ObserverRewriter(observer);
moduleDefinition.Rewrite(rewriter);
code = moduleDefinition.ToByteCode();
}
Result <IContract> contractLoadResult = this.Load(
code,
typeName,
contractState.Message.ContractAddress.ToUint160(this.network),
contractState);
if (!contractLoadResult.IsSuccess)
{
LogErrorMessage(contractLoadResult.Error);
this.logger.LogTrace("(-)[LOAD_CONTRACT_FAILED]");
return(VmExecutionResult.Fail(VmExecutionErrorKind.LoadFailed, contractLoadResult.Error));
}
IContract contract = contractLoadResult.Value;
LogExecutionContext(this.logger, contract.State.Block, contract.State.Message, contract.Address);
IContractInvocationResult invocationResult = contract.Invoke(methodCall);
if (!invocationResult.IsSuccess)
{
this.logger.LogTrace("(-)[CALLCONTRACT_INSTANTIATION_FAILED]");
return(GetInvocationVmErrorResult(invocationResult));
}
this.logger.LogTrace("[CALL_CONTRACT_INSTANTIATION_SUCCEEDED]");
this.logger.LogTrace("(-)");
return(VmExecutionResult.Ok(invocationResult.Return, typeName));
}
public ObserverTests()
{
var context = new ContractExecutorTestContext();
this.network = context.Network;
this.TestAddress = "0x0000000000000000000000000000000000000001".HexToAddress();
this.repository = context.State;
this.moduleReader = new ContractModuleDefinitionReader();
this.assemblyLoader = new ContractAssemblyLoader();
this.gasMeter = new GasMeter((Gas)5000000);
var block = new TestBlock
{
Coinbase = this.TestAddress,
Number = 1
};
var message = new TestMessage
{
ContractAddress = this.TestAddress,
GasLimit = (Gas)GasLimit,
Sender = this.TestAddress,
Value = Value
};
var getBalance = new Func <ulong>(() => Balance);
var persistentState = new TestPersistentState();
var network = new SmartContractsRegTest();
var serializer = new ContractPrimitiveSerializer(network);
this.state = new SmartContractState(
new Stratis.SmartContracts.Block(1, this.TestAddress),
new Message(this.TestAddress, this.TestAddress, 0),
new PersistentState(new MeteredPersistenceStrategy(this.repository, this.gasMeter, new BasicKeyEncodingStrategy()),
context.Serializer, this.TestAddress.ToUint160()),
context.Serializer,
this.gasMeter,
new ContractLogHolder(),
Mock.Of <IInternalTransactionExecutor>(),
new InternalHashHelper(),
() => 1000);
this.rewriter = new ObserverRewriter(new Observer(this.gasMeter, ReflectionVirtualMachine.MemoryUnitLimit));
}
/// <summary>
/// Creates a new instance of a smart contract by invoking the contract's constructor
/// </summary>
public VmExecutionResult Create(IStateRepository repository, ISmartContractState contractState, byte[] contractCode, object[] parameters, string typeName = null)
{
this.logger.LogTrace("()");
string typeToInstantiate;
ContractByteCode code;
// Decompile the contract execution code
Result <IContractModuleDefinition> moduleResult = this.moduleDefinitionReader.Read(contractCode);
if (moduleResult.IsFailure)
{
this.logger.LogTrace("(-)[CONTRACT_BYTECODE_INVALID]");
return(VmExecutionResult.Error(new ContractErrorMessage("Contract bytecode is not valid IL.")));
}
// Validate contract execution code
using (IContractModuleDefinition moduleDefinition = moduleResult.Value)
{
SmartContractValidationResult validation = moduleDefinition.Validate(this.validator);
// If validation failed, refund the sender any remaining gas.
if (!validation.IsValid)
{
this.logger.LogTrace("(-)[CONTRACT_VALIDATION_FAILED]");
// TODO: List errors by string.
return(VmExecutionResult.Error(new ContractErrorMessage(new SmartContractValidationException(validation.Errors).ToString())));
}
typeToInstantiate = typeName ?? moduleDefinition.ContractType.Name;
var observer = new Observer(contractState.GasMeter, MemoryUnitLimit);
var rewriter = new ObserverRewriter(observer);
moduleDefinition.Rewrite(rewriter);
code = moduleDefinition.ToByteCode();
}
Result <IContract> contractLoadResult = this.Load(
code,
typeToInstantiate,
contractState.Message.ContractAddress.ToUint160(this.network),
contractState);
if (!contractLoadResult.IsSuccess)
{
LogErrorMessage(contractLoadResult.Error);
this.logger.LogTrace("(-)[LOAD_CONTRACT_FAILED]");
return(VmExecutionResult.Error(new ContractErrorMessage(contractLoadResult.Error)));
}
IContract contract = contractLoadResult.Value;
LogExecutionContext(this.logger, contract.State.Block, contract.State.Message, contract.Address);
// Set the code and the Type before the method is invoked
repository.SetCode(contract.Address, contractCode);
repository.SetContractType(contract.Address, typeToInstantiate);
// Invoke the constructor of the provided contract code
IContractInvocationResult invocationResult = contract.InvokeConstructor(parameters);
if (!invocationResult.IsSuccess)
{
this.logger.LogTrace("[CREATE_CONTRACT_INSTANTIATION_FAILED]");
return(VmExecutionResult.Error(invocationResult.ErrorMessage));
}
this.logger.LogTrace("[CREATE_CONTRACT_INSTANTIATION_SUCCEEDED]");
this.logger.LogTrace("(-):{0}={1}", nameof(contract.Address), contract.Address);
return(VmExecutionResult.Success(invocationResult.Return, typeToInstantiate));
}
/// <summary>
/// Creates a new instance of a smart contract by invoking the contract's constructor
/// </summary>
public VmExecutionResult Create(IStateRepository repository,
ISmartContractState contractState,
RuntimeObserver.IGasMeter gasMeter,
byte[] contractCode,
object[] parameters,
string typeName = null)
{
string typeToInstantiate;
ContractByteCode code;
// Decompile the contract execution code
Result <IContractModuleDefinition> moduleResult = this.moduleDefinitionReader.Read(contractCode);
if (moduleResult.IsFailure)
{
this.logger.LogTrace(moduleResult.Error);
this.logger.LogTrace("(-)[CONTRACT_BYTECODE_INVALID]");
return(VmExecutionResult.Fail(VmExecutionErrorKind.LoadFailed, "Contract bytecode is not valid IL."));
}
// Validate contract execution code
using (IContractModuleDefinition moduleDefinition = moduleResult.Value)
{
SmartContractValidationResult validation = moduleDefinition.Validate(this.validator);
// If validation failed, refund the sender any remaining gas.
if (!validation.IsValid)
{
this.logger.LogTrace("(-)[CONTRACT_VALIDATION_FAILED]");
return(VmExecutionResult.Fail(VmExecutionErrorKind.ValidationFailed, new SmartContractValidationException(validation.Errors).ToString()));
}
typeToInstantiate = typeName ?? moduleDefinition.ContractType.Name;
var observer = new Observer(gasMeter, new MemoryMeter(MemoryUnitLimit));
var rewriter = new ObserverRewriter(observer);
if (!this.Rewrite(moduleDefinition, rewriter))
{
return(VmExecutionResult.Fail(VmExecutionErrorKind.RewriteFailed, "Rewrite module failed"));
}
Result <ContractByteCode> getCodeResult = this.GetByteCode(moduleDefinition);
if (!getCodeResult.IsSuccess)
{
return(VmExecutionResult.Fail(VmExecutionErrorKind.RewriteFailed, "Serialize module failed"));
}
code = getCodeResult.Value;
}
Result <IContract> contractLoadResult = this.Load(
code,
typeToInstantiate,
contractState.Message.ContractAddress.ToUint160(),
contractState);
if (!contractLoadResult.IsSuccess)
{
return(VmExecutionResult.Fail(VmExecutionErrorKind.LoadFailed, contractLoadResult.Error));
}
IContract contract = contractLoadResult.Value;
this.LogExecutionContext(contract.State.Block, contract.State.Message, contract.Address);
// Set the code and the Type before the method is invoked
repository.SetCode(contract.Address, contractCode);
repository.SetContractType(contract.Address, typeToInstantiate);
// Invoke the constructor of the provided contract code
IContractInvocationResult invocationResult = contract.InvokeConstructor(parameters);
if (!invocationResult.IsSuccess)
{
this.logger.LogTrace("[CREATE_CONTRACT_INSTANTIATION_FAILED]");
return(GetInvocationVmErrorResult(invocationResult));
}
this.logger.LogTrace("[CREATE_CONTRACT_INSTANTIATION_SUCCEEDED]");
return(VmExecutionResult.Ok(invocationResult.Return, typeToInstantiate));
}