public DepositDetailsForRpc(DepositDetails deposit, uint timestamp)
{
Id = deposit.Id;
Deposit = new DepositForRpc(deposit.Deposit);
DataAsset = new DataAssetForRpc(deposit.DataAsset);
Consumer = deposit.Consumer;
Timestamp = deposit.Timestamp;
Transaction = deposit.Transaction is null ? null : new TransactionInfoForRpc(deposit.Transaction);
Transactions = deposit.Transactions?.Select(t => new TransactionInfoForRpc(t)).OrderBy(t => t.Timestamp) ??
Enumerable.Empty <TransactionInfoForRpc>();
ConfirmationTimestamp = deposit.ConfirmationTimestamp;
Confirmed = deposit.Confirmed;
Rejected = deposit.Rejected;
Cancelled = deposit.Cancelled;
Expired = deposit.IsExpired(timestamp);
RefundClaimed = deposit.RefundClaimed;
ClaimedRefundTransaction = deposit.ClaimedRefundTransaction is null
? null
: new TransactionInfoForRpc(deposit.ClaimedRefundTransaction);
ClaimedRefundTransactions = deposit.ClaimedRefundTransactions?.Select(t => new TransactionInfoForRpc(t))
.OrderBy(t => t.Timestamp) ??
Enumerable.Empty <TransactionInfoForRpc>();
RefundCancelled = deposit.RefundCancelled;
ConsumedUnits = deposit.ConsumedUnits;
Kyc = deposit.Kyc;
Confirmations = deposit.Confirmations;
RequiredConfirmations = deposit.RequiredConfirmations;
}
public async Task <ResultWrapper <Keccak> > ndm_addDataAsset(DataAssetForRpc dataAsset)
{
if (dataAsset.UnitPrice == null)
{
throw new InvalidDataException("Data asset is missing unit price.");
}
if (dataAsset.UnitType == null)
{
throw new InvalidDataException("Data asset is missing unit type.");
}
if (dataAsset.Rules == null)
{
throw new InvalidDataException("Data asset is missing basic rules definitions.");
}
if (dataAsset.Description == null)
{
throw new InvalidDataException("Data asset is missing description.");
}
if (dataAsset.Name == null)
{
throw new InvalidDataException("Data asset is missing name.");
}
if (dataAsset.Rules.Expiry == null)
{
throw new InvalidDataException("Data asset is missing expiry rule.");
}
Keccak?id = await _providerService.AddDataAssetAsync(dataAsset.Name,
dataAsset.Description, (UInt256)dataAsset.UnitPrice,
Enum.Parse <DataAssetUnitType>(dataAsset.UnitType, true),
dataAsset.MinUnits, dataAsset.MaxUnits,
new DataAssetRules(new DataAssetRule((UInt256)dataAsset.Rules.Expiry.Value),
dataAsset.Rules.UpfrontPayment is null
? null
: new DataAssetRule((UInt256)dataAsset.Rules.UpfrontPayment.Value)),
dataAsset.File, dataAsset.Data,
string.IsNullOrWhiteSpace(dataAsset.QueryType)
?QueryType.Stream
: Enum.Parse <QueryType>(dataAsset.QueryType, true),
dataAsset.TermsAndConditions, dataAsset.KycRequired ?? false, dataAsset.Plugin);
return(id is null
? ResultWrapper <Keccak> .Fail($"Data asset: '{dataAsset.Name}' already exists.")
: ResultWrapper <Keccak> .Success(id));
}
public DepositDetailsForRpc(DepositDetails deposit, uint timestamp)
{
Id = deposit.Id;
Deposit = new DepositForRpc(deposit.Deposit);
DataAsset = new DataAssetForRpc(deposit.DataAsset);
Consumer = deposit.Consumer;
Timestamp = deposit.Timestamp;
TransactionHash = deposit.TransactionHash;
ConfirmationTimestamp = deposit.ConfirmationTimestamp;
Confirmed = deposit.Confirmed;
Rejected = deposit.Rejected;
Expired = deposit.IsExpired(timestamp);
RefundClaimed = deposit.RefundClaimed;
ClaimedRefundTransactionHash = deposit.ClaimedRefundTransactionHash;
ConsumedUnits = deposit.ConsumedUnits;
Kyc = deposit.Kyc;
Confirmations = deposit.Confirmations;
RequiredConfirmations = deposit.RequiredConfirmations;
}
private static void VerifyDataAsset(DataAssetForRpc dataAsset)
{
dataAsset.Should().NotBeNull();
dataAsset.Id.Should().NotBeNull();
dataAsset.Name.Should().Be("test");
dataAsset.Description.Should().Be("test");
dataAsset.UnitPrice.Should().Be(1);
dataAsset.UnitType.Should().Be(DataAssetUnitType.Unit.ToString().ToLowerInvariant());
dataAsset.QueryType.Should().Be(QueryType.Stream.ToString().ToLowerInvariant());
dataAsset.MinUnits.Should().Be(0);
dataAsset.MaxUnits.Should().Be(10);
dataAsset.Rules.Should().NotBeNull();
dataAsset.Rules.Expiry.Should().NotBeNull();
dataAsset.Rules.Expiry.Value.Should().Be(1);
dataAsset.Rules.UpfrontPayment.Should().BeNull();
dataAsset.Provider.Address.Should().Be(Address.Zero);
dataAsset.Provider.Name.Should().Be("test");
dataAsset.File.Should().BeNullOrEmpty();
dataAsset.Data.Should().BeNullOrEmpty();
dataAsset.State.Should().Be(DataAssetState.Unpublished.ToString().ToLowerInvariant());
dataAsset.TermsAndConditions.Should().BeNullOrEmpty();
dataAsset.KycRequired.Should().BeFalse();
}
public async Task RunAsync()
{
Separator();
var jsonRpcAvailable = false;
while (!jsonRpcAvailable)
{
Log("* Verifying JSON RPC availability *");
var chainId = await ExecuteAsync <long>("eth_chainId");
if (chainId > 0)
{
jsonRpcAvailable = true;
Log($"* JSON RPC is available *");
Separator();
}
else
{
const int delay = 2000;
Log($"* JSON RPC is not responding, retrying in: {delay} ms *");
await Task.Delay(delay);
Separator();
}
}
Log("* Creating an account *");
var account = await ExecuteAsync <Address>("personal_newAccount", Password);
Log($"* Created an account: {account} *");
Separator();
Log($"* Unlocking an account: {account} *");
var unlockedResult = await ExecuteAsync <bool>("personal_unlockAccount", account, Password);
Log($"* Unlocked an account: {account}, {unlockedResult} *");
Separator();
Log($"* Changing NDM provider account: {account} *");
var addressChanged = await ExecuteAsync <Address>("ndm_changeProviderAddress", account);
Log($"* Changed NDM provider account: {account}, {addressChanged} *");
Separator();
Log($"* Changing NDM provider cold wallet account: {account} *");
var coldWalletChanged = await ExecuteAsync <Address>("ndm_changeProviderColdWalletAddress", account);
Log($"* Changed NDM provider cold wallet account: {account}, {coldWalletChanged} *");
Separator();
Log("* Adding the the data asset *");
var addDataAsset = new DataAssetForRpc
{
Name = "Sample Web API",
Description = "Sample Web API test",
UnitPrice = 1.GWei(),
UnitType = DataAssetUnitType.Unit.ToString(),
QueryType = QueryType.Query.ToString(),
Plugin = "sample-web-api",
MinUnits = 1,
MaxUnits = 1000000,
Rules = new DataAssetRulesForRpc
{
Expiry = new DataAssetRuleForRpc
{
Value = 1000000
}
}
};
var dataAssetId = await ExecuteAsync <Keccak>("ndm_addDataAsset", addDataAsset);
Log($"* Added the data asset: {dataAssetId} *");
Separator();
var state = DataAssetState.Published.ToString();
Log($"* Changing the data asset state to: {state}*");
var changedState = await ExecuteAsync <bool>("ndm_changeDataAssetState", dataAssetId, state);
Log($"* Changed the data asset state to: {state}, {changedState}*");
Separator();
Log($"* NDM provider is now ready to accept the data requests *");
Separator();
}
public ConsumerDetailsForRpc(Consumer consumer, uint unclaimedUnits) : base(consumer)
{
DataRequest = new DataRequestForRpc(consumer.DataRequest);
DataAsset = new DataAssetForRpc(consumer.DataAsset);
UnclaimedUnits = unclaimedUnits;
}
