private async Task <byte[]> CallReadOnlyAsync(Transaction tx)
{
var chainContext = await GetChainContextAsync();
var trace = await _transactionReadOnlyExecutionService.ExecuteAsync(chainContext, tx,
DateTime.UtcNow.ToTimestamp());
if (!string.IsNullOrEmpty(trace.Error))
{
throw new Exception(trace.Error);
}
return(trace.ReturnValue.ToByteArray());
}
private async Task UpdateSmartContractAddressesAsync(BlockHeader blockHeader,
ISmartContractAddressNameProvider smartContractAddressNameProvider)
{
var t = new Transaction()
{
From = _smartContractAddressService.GetZeroSmartContractAddress(),
To = _smartContractAddressService.GetZeroSmartContractAddress(),
MethodName = nameof(Acs0.ACS0Container.ACS0Stub.GetContractAddressByName),
Params = smartContractAddressNameProvider.ContractName.ToByteString()
};
var transactionResult =
(await _transactionExecutingService.ExecuteAsync(
new ChainContext()
{
BlockHash = blockHeader.GetHash(), BlockHeight = blockHeader.Height
}, t,
TimestampHelper.GetUtcNow()));
if (!transactionResult.IsSuccessful())
{
throw new InvalidOperationException();
}
var address = Address.Parser.ParseFrom(transactionResult.ReturnValue);
if (!address.Value.IsEmpty)
{
_smartContractAddressService.SetAddress(smartContractAddressNameProvider.ContractName, address);
}
}
public async Task <RequiredAcs> GetRequiredAcsInContractsAsync(Hash blockHash, long blockHeight)
{
var tx = new Transaction
{
From = FromAddress,
To = ConfigurationContractAddress,
MethodName = nameof(ConfigurationContainer.ConfigurationStub.GetConfiguration),
Params = new StringValue {
Value = RequiredAcsInContractsConfigurationNameProvider.Name
}.ToByteString(),
Signature = ByteString.CopyFromUtf8(KernelConstants.SignaturePlaceholder)
};
var returned = await _transactionReadOnlyExecutionService.ExecuteAsync <BytesValue>(
new ChainContext
{
BlockHash = blockHash,
BlockHeight = blockHeight
}, tx, TimestampHelper.GetUtcNow(), false);
var requiredAcsInContracts = new RequiredAcsInContracts();
requiredAcsInContracts.MergeFrom(returned.Value);
return(new RequiredAcs
{
AcsList = requiredAcsInContracts.AcsList.ToList(),
RequireAll = requiredAcsInContracts.RequireAll
});
}
private async Task <ByteString> CallContractMethodAsync(Address contractAddress, string methodName,
IMessage input)
{
var tx = new Transaction
{
From = FromAddress,
To = contractAddress,
MethodName = methodName,
Params = input.ToByteString(),
Signature = ByteString.CopyFromUtf8("SignaturePlaceholder")
};
var chain = await _blockchainService.GetChainAsync();
if (chain == null)
{
return(ByteString.Empty);
}
var transactionTrace = await _transactionReadOnlyExecutionService.ExecuteAsync(new ChainContext
{
BlockHash = chain.LastIrreversibleBlockHash,
BlockHeight = chain.LastIrreversibleBlockHeight
}, tx, TimestampHelper.GetUtcNow());
return(transactionTrace.ReturnValue);
}
public IMethodStub <TInput, TOutput> Create <TInput, TOutput>(Method <TInput, TOutput> method)
where TInput : IMessage <TInput>, new() where TOutput : IMessage <TOutput>, new()
{
Task <IExecutionResult <TOutput> > SendAsync(TInput input)
{
throw new NotSupportedException();
}
async Task <TOutput> CallAsync(TInput input)
{
var chainContext = _chainContext;
var transaction = new Transaction()
{
From = FromAddress,
To = ConsensusContractAddress,
MethodName = method.Name,
Params = ByteString.CopyFrom(method.RequestMarshaller.Serializer(input))
};
var trace =
await _transactionReadOnlyExecutionService.ExecuteAsync(chainContext, transaction,
_contextService.GetBlockTime());
return(trace.IsSuccessful()
? method.ResponseMarshaller.Deserializer(trace.ReturnValue.ToByteArray())
: default);
public IMethodStub <TInput, TOutput> Create <TInput, TOutput>(Method <TInput, TOutput> method)
where TInput : IMessage <TInput>, new() where TOutput : IMessage <TOutput>, new()
{
Task <IExecutionResult <TOutput> > SendAsync(TInput input)
{
throw new NotSupportedException();
}
async Task <TOutput> CallAsync(TInput input)
{
var chainContext = _chainContext;
var transaction = new Transaction()
{
From = FromAddress,
To = CrossChainContractMethodAddress,
MethodName = method.Name,
Params = ByteString.CopyFrom(method.RequestMarshaller.Serializer(input))
};
var trace =
await _transactionReadOnlyExecutionService.ExecuteAsync(chainContext, transaction, TimestampHelper.GetUtcNow());
if (trace.IsSuccessful())
{
return(method.ResponseMarshaller.Deserializer(trace.ReturnValue.ToByteArray()));
}
return(default(TOutput));
}
return(new MethodStub <TInput, TOutput>(method, SendAsync, CallAsync));
}
public async Task Fibonacci16()
{
_transactionTrace = await _transactionReadOnlyExecutionService.ExecuteAsync(new ChainContext
{
BlockHash = _chain.BestChainHash,
BlockHeight = _chain.BestChainHeight
},
_transaction,
DateTime.UtcNow);
}
public async Task LoopDivAdd10M()
{
_transactionTrace = await _transactionReadOnlyExecutionService.ExecuteAsync(new ChainContext
{
BlockHash = _chain.BestChainHash,
BlockHeight = _chain.BestChainHeight
},
_transaction,
TimestampHelper.GetUtcNow());
}
public async Task <ByteString> ExecuteReadOnlyAsync(Transaction transaction, Hash blockHash, long blockHeight)
{
var transactionTrace = await _transactionReadOnlyExecutionService.ExecuteAsync(new ChainContext
{
BlockHash = blockHash,
BlockHeight = blockHeight
},
transaction,
DateTime.UtcNow.ToTimestamp());
return(transactionTrace.ReturnValue);
}
public async Task <T> ExecuteContractAsync <T>(IChainContext chainContext, string consensusMethodName,
IMessage input, DateTime dateTime) where T : class, IMessage <T>, new()
{
var tx = new Transaction
{
From = Address.Generate(),
To = _smartContractAddressService.GetAddressByContractName(ConsensusSmartContractAddressNameProvider
.Name),
MethodName = consensusMethodName,
Params = input?.ToByteString() ?? ByteString.Empty
};
return(await _transactionReadOnlyExecutionService.ExecuteAsync <T>(chainContext, tx, dateTime));
}
public async Task <SmartContractRegistration> GetSmartContractRegistrationAsync(IChainContext chainContext, Address address)
{
var zeroAddress = _defaultContractZeroCodeProvider.ContractZeroAddress;
var tx = new Transaction
{
From = zeroAddress,
To = zeroAddress,
MethodName = nameof(ACS0Container.ACS0Stub.GetSmartContractRegistrationByAddress),
Params = address.ToByteString()
};
return(await _transactionReadOnlyExecutionService.ExecuteAsync <SmartContractRegistration>(
chainContext, tx, TimestampHelper.GetUtcNow(), false));
}
private async Task <Address> GetSmartContractAddressFromStateAsync(IChainContext chainContext, string name)
{
var zeroAddress = _defaultContractZeroCodeProvider.ContractZeroAddress;
var tx = new Transaction
{
From = zeroAddress,
To = zeroAddress,
MethodName = nameof(ACS0Container.ACS0Stub.GetContractAddressByName),
Params = Hash.LoadFromBase64(name).ToByteString()
};
var address = await _transactionReadOnlyExecutionService.ExecuteAsync <Address>(
chainContext, tx, TimestampHelper.GetUtcNow(), false);
return(address == null || address.Value.IsEmpty ? null : address);
}
private async Task <ByteString> GetBlockTransactionLimitAsync(IChainContext chainContext)
{
var tx = new Transaction
{
From = FromAddress,
To = ConfigurationContractAddress,
MethodName = nameof(ConfigurationContainer.ConfigurationStub.GetBlockTransactionLimit),
Params = new Empty().ToByteString(),
Signature = ByteString.CopyFromUtf8("SignaturePlaceholder")
};
var transactionTrace =
await _transactionReadOnlyExecutionService.ExecuteAsync(chainContext, tx, TimestampHelper.GetUtcNow());
return(transactionTrace.ReturnValue);
}
private async Task <T> ReadByTransactionAsync <T>(Transaction readOnlyTransaction, Hash blockHash, long blockHeight)
where T : IMessage <T>, new()
{
var chainContext = GenerateChainContext(blockHash, blockHeight);
var trace =
await _transactionReadOnlyExecutionService.ExecuteAsync(chainContext, readOnlyTransaction, DateTime.UtcNow);
if (trace.IsSuccessful())
{
var obj = new T();
obj.MergeFrom(trace.ReturnValue);
return(obj);
}
return(default(T));
}
private async Task UpdateSmartContractAddressesAsync(BlockHeader blockHeader,
ISmartContractAddressNameProvider smartContractAddressNameProvider)
{
var transaction = new Transaction()
{
From = _smartContractAddressService.GetZeroSmartContractAddress(),
To = _smartContractAddressService.GetZeroSmartContractAddress(),
MethodName = nameof(Acs0.ACS0Container.ACS0Stub.GetContractAddressByName),
Params = smartContractAddressNameProvider.ContractName.ToByteString()
};
var address = await _transactionExecutingService.ExecuteAsync <Address>(
new ChainContext { BlockHash = blockHeader.GetHash(), BlockHeight = blockHeader.Height }, transaction,
TimestampHelper.GetUtcNow(), true);
if (!address.Value.IsEmpty)
{
_smartContractAddressService.SetAddress(smartContractAddressNameProvider.ContractName, address);
}
}
public static async Task <T> ExecuteAsync <T>(
this ITransactionReadOnlyExecutionService transactionReadOnlyExecutionService,
IChainContext chainContext, Transaction transaction,
Timestamp currentBlockTime, bool failedThrowException) where T : class, IMessage <T>, new()
{
var trace = await transactionReadOnlyExecutionService.ExecuteAsync(chainContext, transaction, currentBlockTime);
if (trace.IsSuccessful())
{
var obj = new T();
obj.MergeFrom(trace.ReturnValue);
return(obj);
}
if (failedThrowException)
{
throw new SmartContractExecutingException(trace.Error);
}
return(default(T));
}
private async Task <ByteString> CallContractMethodAsync(Address contractAddress, string methodName,
IMessage input)
{
var tx = new Transaction
{
From = FromAddress,
To = contractAddress,
MethodName = methodName,
Params = input.ToByteString(),
Signature = ByteString.CopyFromUtf8("SignaturePlaceholder")
};
var preBlock = await _blockchainService.GetBestChainLastBlockHeaderAsync();
var transactionTrace = await _transactionReadOnlyExecutionService.ExecuteAsync(new ChainContext
{
BlockHash = preBlock.GetHash(),
BlockHeight = preBlock.Height
}, tx, TimestampHelper.GetUtcNow());
return(transactionTrace.ReturnValue);
}
public async Task ExecuteAsync_Test()
{
var chain = await _smartContractHelper.CreateChainWithGenesisContractAsync();
var chainContext = new ChainContext
{
BlockHash = chain.BestChainHash,
BlockHeight = chain.BestChainHeight
};
var transaction = new Transaction
{
From = SampleAddress.AddressList[0],
To = SampleAddress.AddressList[0],
MethodName = "NotExistMethod",
Params = ByteString.Empty
};
_transactionReadOnlyExecutionService.ExecuteAsync(chainContext, transaction, TimestampHelper.GetUtcNow())
.ShouldThrow <SmartContractFindRegistrationException>();
_transactionReadOnlyExecutionService.ExecuteAsync <Address>(chainContext, transaction, TimestampHelper.GetUtcNow(), false)
.ShouldThrow <SmartContractFindRegistrationException>();
transaction = new Transaction
{
From = SampleAddress.AddressList[0],
To = _defaultContractZeroCodeProvider.ContractZeroAddress,
MethodName = "NotExistMethod",
Params = ByteString.Empty
};
var trace = await _transactionReadOnlyExecutionService.ExecuteAsync(chainContext, transaction,
TimestampHelper.GetUtcNow());
trace.Error.ShouldContain("Failed to find handler for NotExistMethod");
trace.ExecutionStatus.ShouldBe(ExecutionStatus.SystemError);
var hash = await _transactionReadOnlyExecutionService.ExecuteAsync <Hash>(chainContext, transaction,
TimestampHelper.GetUtcNow(), false);
hash.ShouldBeNull();
_transactionReadOnlyExecutionService.ExecuteAsync <Hash>(chainContext, transaction,
TimestampHelper.GetUtcNow(), true).ShouldThrow <SmartContractExecutingException>();
_smartContractExecutiveProvider.GetPool(_defaultContractZeroCodeProvider.ContractZeroAddress).Single()
.ContractHash.ShouldBe(_defaultContractZeroCodeProvider.DefaultContractZeroRegistration.CodeHash);
transaction = new Transaction
{
From = SampleAddress.AddressList[0],
To = _defaultContractZeroCodeProvider.ContractZeroAddress,
MethodName = nameof(ACS0Container.ACS0Stub.GetSmartContractRegistrationByAddress),
Params = _defaultContractZeroCodeProvider.ContractZeroAddress.ToByteString()
};
trace = await _transactionReadOnlyExecutionService.ExecuteAsync(chainContext, transaction,
TimestampHelper.GetUtcNow());
trace.ExecutionStatus.ShouldBe(ExecutionStatus.Executed);
var smartContractRegistration = SmartContractRegistration.Parser.ParseFrom(trace.ReturnValue);
CheckSmartContractRegistration(smartContractRegistration);
_smartContractExecutiveProvider.GetPool(_defaultContractZeroCodeProvider.ContractZeroAddress).Single()
.ContractHash.ShouldBe(_defaultContractZeroCodeProvider.DefaultContractZeroRegistration.CodeHash);
smartContractRegistration = await _transactionReadOnlyExecutionService.ExecuteAsync <SmartContractRegistration>(chainContext, transaction,
TimestampHelper.GetUtcNow(), true);
CheckSmartContractRegistration(smartContractRegistration);
_smartContractExecutiveProvider.GetPool(_defaultContractZeroCodeProvider.ContractZeroAddress).Single()
.ContractHash.ShouldBe(_defaultContractZeroCodeProvider.DefaultContractZeroRegistration.CodeHash);
}
