/// <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;
using (IContractModuleDefinition moduleDefinition = this.moduleDefinitionReader.Read(contractCode))
{
moduleDefinition.InjectMethodGas(typeName, methodCall);
code = moduleDefinition.ToByteCode();
}
Result <IContract> contractLoadResult = this.Load(
code,
typeName,
contractState.Message.ContractAddress.ToUint160(this.network),
contractState);
if (!contractLoadResult.IsSuccess)
{
// TODO this is temporary until we improve error handling overloads
var exception = new Exception(contractLoadResult.Error);
LogException(exception);
this.logger.LogTrace("(-)[LOAD_CONTRACT_FAILED]");
return(VmExecutionResult.Error(exception));
}
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(VmExecutionResult.Error(new Exception("Method invocation failed!")));
}
this.logger.LogTrace("[CALL_CONTRACT_INSTANTIATION_SUCCEEDED]");
this.logger.LogTrace("(-)");
return(VmExecutionResult.Success(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.Error(new ContractErrorMessage(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(VmExecutionResult.Error(invocationResult.ErrorMessage));
}
this.logger.LogTrace("[CALL_CONTRACT_INSTANTIATION_SUCCEEDED]");
this.logger.LogTrace("(-)");
return(VmExecutionResult.Success(invocationResult.Return, typeName));
}
/// <summary>
/// Creates a new instance of a smart contract by invoking the contract's constructor
/// </summary>
public VmExecutionResult Create(byte[] contractCode,
ISmartContractExecutionContext context,
IGasMeter gasMeter,
IPersistentState persistentState,
IContractStateRepository repository)
{
this.logger.LogTrace("()");
byte[] gasInjectedCode = SmartContractGasInjector.AddGasCalculationToConstructor(contractCode);
Type contractType = Load(gasInjectedCode);
var internalTransferList = new List <TransferInfo>();
IInternalTransactionExecutor internalTransactionExecutor = this.internalTransactionExecutorFactory.Create(repository, internalTransferList);
var balanceState = new BalanceState(repository, context.Message.Value, internalTransferList);
var contractState = new SmartContractState(
context.Block,
context.Message,
persistentState,
gasMeter,
internalTransactionExecutor,
new InternalHashHelper(),
() => balanceState.GetBalance(context.ContractAddress));
// Invoke the constructor of the provided contract code
LifecycleResult result = SmartContractConstructor.Construct(contractType, contractState, context.Parameters);
if (!result.Success)
{
LogException(result.Exception);
this.logger.LogTrace("(-)[CREATE_CONTRACT_INSTANTIATION_FAILED]:{0}={1}", nameof(gasMeter.GasConsumed), gasMeter.GasConsumed);
return(VmExecutionResult.Error(gasMeter.GasConsumed, result.Exception.InnerException ?? result.Exception));
}
else
{
this.logger.LogTrace("[CREATE_CONTRACT_INSTANTIATION_SUCCEEDED]");
}
this.logger.LogTrace("(-):{0}={1}", nameof(gasMeter.GasConsumed), gasMeter.GasConsumed);
return(VmExecutionResult.Success(internalTransferList, gasMeter.GasConsumed, result.Object));
}
/// <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>
/// Invokes a method on an existing smart contract
/// </summary>
public VmExecutionResult ExecuteMethod(
IGasMeter gasMeter,
IContractStateRepository repository,
ICallData callData,
ITransactionContext transactionContext)
{
this.logger.LogTrace("(){0}:{1}", nameof(callData.MethodName), callData.MethodName);
if (callData.MethodName == null)
{
this.logger.LogTrace("(-)[CALLCONTRACT_METHODNAME_NOT_GIVEN]");
return(VmExecutionResult.Error(gasMeter.GasConsumed, null));
}
byte[] contractExecutionCode = repository.GetCode(callData.ContractAddress);
string typeName = repository.GetContractType(callData.ContractAddress);
if (contractExecutionCode == null)
{
return(VmExecutionResult.Error(gasMeter.GasConsumed, new SmartContractDoesNotExistException(callData.MethodName)));
}
byte[] gasInjectedCode = SmartContractGasInjector.AddGasCalculationToContractMethod(contractExecutionCode, typeName, callData.MethodName);
Type contractType = Load(gasInjectedCode, typeName);
if (contractType == null)
{
this.logger.LogTrace("(-)[CALLCONTRACT_CONTRACTTYPE_NULL]");
return(VmExecutionResult.Error(gasMeter.GasConsumed, null));
}
uint160 contractAddress = callData.ContractAddress;
IPersistenceStrategy persistenceStrategy = new MeteredPersistenceStrategy(repository, gasMeter, new BasicKeyEncodingStrategy());
IPersistentState persistentState = new PersistentState(persistenceStrategy, contractAddress, this.network);
var internalTransferList = new List <TransferInfo>();
IInternalTransactionExecutor internalTransactionExecutor = this.internalTransactionExecutorFactory.Create(this, repository, internalTransferList, transactionContext);
var balanceState = new BalanceState(repository, transactionContext.Amount, internalTransferList);
var contractState = new SmartContractState(
new Block(
transactionContext.BlockHeight,
transactionContext.Coinbase.ToAddress(this.network)
),
new Message(
callData.ContractAddress.ToAddress(this.network),
transactionContext.From.ToAddress(this.network),
transactionContext.Amount
),
persistentState,
gasMeter,
internalTransactionExecutor,
new InternalHashHelper(),
() => balanceState.GetBalance(callData.ContractAddress));
LogExecutionContext(this.logger, contractState.Block, contractState.Message, contractAddress, callData);
LifecycleResult result = SmartContractRestorer.Restore(contractType, contractState);
if (!result.Success)
{
LogException(result.Exception);
this.logger.LogTrace("(-)[CALLCONTRACT_INSTANTIATION_FAILED]:{0}={1}", nameof(gasMeter.GasConsumed), gasMeter.GasConsumed);
return(VmExecutionResult.Error(gasMeter.GasConsumed, result.Exception.InnerException ?? result.Exception));
}
else
{
this.logger.LogTrace("[CALL_CONTRACT_INSTANTIATION_SUCCEEDED]");
}
object methodResult = null;
try
{
MethodInfo methodToInvoke = contractType.GetMethod(callData.MethodName);
if (methodToInvoke == null)
{
throw new ArgumentException(string.Format("[CALLCONTRACT_METHODTOINVOKE_NULL_DOESNOT_EXIST]:{0}={1}", nameof(callData.MethodName), callData.MethodName));
}
if (methodToInvoke.IsConstructor)
{
throw new ConstructorInvocationException("[CALLCONTRACT_CANNOT_INVOKE_CTOR]");
}
SmartContract smartContract = result.Object;
methodResult = methodToInvoke.Invoke(smartContract, callData.MethodParameters);
}
catch (ArgumentException argumentException)
{
LogException(argumentException);
return(VmExecutionResult.Error(gasMeter.GasConsumed, argumentException));
}
catch (TargetInvocationException targetException)
{
LogException(targetException);
return(VmExecutionResult.Error(gasMeter.GasConsumed, targetException.InnerException ?? targetException));
}
catch (TargetParameterCountException parameterException)
{
LogException(parameterException);
}
catch (ConstructorInvocationException constructorInvocationException)
{
LogException(constructorInvocationException);
return(VmExecutionResult.Error(gasMeter.GasConsumed, constructorInvocationException));
}
this.logger.LogTrace("(-):{0}={1}", nameof(gasMeter.GasConsumed), gasMeter.GasConsumed);
return(VmExecutionResult.Success(internalTransferList, gasMeter.GasConsumed, methodResult));
}
/// <summary>
/// Invokes a method on an existing smart contract
/// </summary>
public VmExecutionResult ExecuteMethod(byte[] contractCode,
string contractMethodName,
ISmartContractExecutionContext context,
IGasMeter gasMeter,
IPersistentState persistentState,
IContractStateRepository repository)
{
this.logger.LogTrace("(){0}:{1}", nameof(contractMethodName), contractMethodName);
ISmartContractExecutionResult executionResult = new SmartContractExecutionResult();
if (contractMethodName == null)
{
this.logger.LogTrace("(-)[CALLCONTRACT_METHODNAME_NOT_GIVEN]");
return(VmExecutionResult.Error(gasMeter.GasConsumed, null));
}
byte[] gasInjectedCode = SmartContractGasInjector.AddGasCalculationToContractMethod(contractCode, contractMethodName);
Type contractType = Load(gasInjectedCode);
if (contractType == null)
{
this.logger.LogTrace("(-)[CALLCONTRACT_CONTRACTTYPE_NULL]");
return(VmExecutionResult.Error(gasMeter.GasConsumed, null));
}
var internalTransferList = new List <TransferInfo>();
IInternalTransactionExecutor internalTransactionExecutor = this.internalTransactionExecutorFactory.Create(repository, internalTransferList);
var balanceState = new BalanceState(repository, context.Message.Value, internalTransferList);
var contractState = new SmartContractState(
context.Block,
context.Message,
persistentState,
gasMeter,
internalTransactionExecutor,
new InternalHashHelper(),
() => balanceState.GetBalance(context.ContractAddress));
LifecycleResult result = SmartContractRestorer.Restore(contractType, contractState);
if (!result.Success)
{
LogException(result.Exception);
this.logger.LogTrace("(-)[CALLCONTRACT_INSTANTIATION_FAILED]:{0}={1}", nameof(gasMeter.GasConsumed), gasMeter.GasConsumed);
executionResult.Exception = result.Exception.InnerException ?? result.Exception;
executionResult.GasConsumed = gasMeter.GasConsumed;
return(VmExecutionResult.Error(gasMeter.GasConsumed, result.Exception.InnerException ?? result.Exception));
}
else
{
this.logger.LogTrace("[CALL_CONTRACT_INSTANTIATION_SUCCEEDED]");
}
object methodResult = null;
try
{
MethodInfo methodToInvoke = contractType.GetMethod(contractMethodName);
if (methodToInvoke == null)
{
throw new ArgumentException(string.Format("[CALLCONTRACT_METHODTOINVOKE_NULL_DOESNOT_EXIST]:{0}={1}", nameof(contractMethodName), contractMethodName));
}
if (methodToInvoke.IsConstructor)
{
throw new ConstructorInvocationException("[CALLCONTRACT_CANNOT_INVOKE_CTOR]");
}
SmartContract smartContract = result.Object;
methodResult = methodToInvoke.Invoke(smartContract, context.Parameters);
}
catch (ArgumentException argumentException)
{
LogException(argumentException);
return(VmExecutionResult.Error(gasMeter.GasConsumed, argumentException));
}
catch (TargetInvocationException targetException)
{
LogException(targetException);
return(VmExecutionResult.Error(gasMeter.GasConsumed, targetException.InnerException ?? targetException));
}
catch (TargetParameterCountException parameterException)
{
LogException(parameterException);
}
catch (ConstructorInvocationException constructorInvocationException)
{
LogException(constructorInvocationException);
return(VmExecutionResult.Error(gasMeter.GasConsumed, constructorInvocationException));
}
this.logger.LogTrace("(-):{0}={1}", nameof(gasMeter.GasConsumed), gasMeter.GasConsumed);
return(VmExecutionResult.Success(internalTransferList, gasMeter.GasConsumed, methodResult));
}
/// <summary>
/// Invokes a method on an existing smart contract
/// </summary>
public VmExecutionResult ExecuteMethod(
IGasMeter gasMeter,
IContractState repository,
ICallData callData,
ITransactionContext transactionContext)
{
this.logger.LogTrace("(){0}:{1}", nameof(callData.MethodName), callData.MethodName);
if (callData.MethodName == null)
{
this.logger.LogTrace("(-)[CALLCONTRACT_METHODNAME_NOT_GIVEN]");
return(VmExecutionResult.Error(gasMeter.GasConsumed, null));
}
byte[] contractExecutionCode = repository.GetCode(callData.ContractAddress);
string typeName = repository.GetContractType(callData.ContractAddress);
if (contractExecutionCode == null)
{
return(VmExecutionResult.Error(gasMeter.GasConsumed, new SmartContractDoesNotExistException(callData.MethodName)));
}
// TODO consolidate this with CallData.
MethodCall methodCall = new MethodCall(callData.MethodName, callData.MethodParameters);
ContractByteCode code;
using (IContractModuleDefinition moduleDefinition = this.moduleDefinitionReader.Read(contractExecutionCode))
{
moduleDefinition.InjectMethodGas(typeName, methodCall);
code = moduleDefinition.ToByteCode();
}
var internalTransferList = new List <TransferInfo>();
var contractLogger = new ContractLogHolder(this.network);
ISmartContractState contractState = this.SetupState(contractLogger, internalTransferList, gasMeter, repository, transactionContext, callData.ContractAddress);
Result <IContract> contractLoadResult = this.Load(
code,
typeName,
callData.ContractAddress,
contractState);
if (!contractLoadResult.IsSuccess)
{
// TODO this is temporary until we improve error handling overloads
var exception = new Exception(contractLoadResult.Error);
LogException(exception);
this.logger.LogTrace("(-)[LOAD_CONTRACT_FAILED]:{0}={1}", nameof(gasMeter.GasConsumed), gasMeter.GasConsumed);
return(VmExecutionResult.Error(gasMeter.GasConsumed, exception));
}
IContract contract = contractLoadResult.Value;
LogExecutionContext(this.logger, contract.State.Block, contract.State.Message, contract.Address, callData);
IContractInvocationResult invocationResult = contract.Invoke(methodCall);
if (!invocationResult.IsSuccess)
{
this.logger.LogTrace("(-)[CALLCONTRACT_INSTANTIATION_FAILED]:{0}={1}", nameof(gasMeter.GasConsumed), gasMeter.GasConsumed);
return(VmExecutionResult.Error(gasMeter.GasConsumed, new Exception("Method invocation failed!")));
}
this.logger.LogTrace("[CALL_CONTRACT_INSTANTIATION_SUCCEEDED]");
this.logger.LogTrace("(-):{0}={1}", nameof(gasMeter.GasConsumed), gasMeter.GasConsumed);
return(VmExecutionResult.Success(internalTransferList, gasMeter.GasConsumed, invocationResult.Return, contractLogger.GetRawLogs()));
}
/// <summary>
/// Creates a new instance of a smart contract by invoking the contract's constructor
/// </summary>
public VmExecutionResult Create(IContractState repository, ISmartContractState contractState, byte[] contractCode, object[] parameters, string typeName = null)
{
this.logger.LogTrace("()");
string typeToInstantiate;
ContractByteCode code;
// Decompile the contract execution code and validate it.
using (IContractModuleDefinition moduleDefinition = this.moduleDefinitionReader.Read(contractCode))
{
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.Error(new SmartContractValidationException(validation.Errors)));
}
typeToInstantiate = typeName ?? moduleDefinition.ContractType.Name;
moduleDefinition.InjectConstructorGas();
code = moduleDefinition.ToByteCode();
}
Result <IContract> contractLoadResult = this.Load(
code,
typeToInstantiate,
contractState.Message.ContractAddress.ToUint160(this.network),
contractState);
if (!contractLoadResult.IsSuccess)
{
// TODO this is temporary until we improve error handling overloads
var exception = new Exception(contractLoadResult.Error);
LogException(exception);
this.logger.LogTrace("(-)[LOAD_CONTRACT_FAILED]");
return(VmExecutionResult.Error(exception));
}
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(new Exception("Constructor invocation failed!")));
}
this.logger.LogTrace("[CREATE_CONTRACT_INSTANTIATION_SUCCEEDED]");
this.logger.LogTrace("(-):{0}={1}", nameof(contract.Address), contract.Address);
return(VmExecutionResult.Success(invocationResult.Return, typeToInstantiate));
}