// If deposits are eligable to refund (deposit is expired / consumer hasn't consumed all units yet etc.)
// background proccessor will try to refund them every single block proccesed.
public void Will_try_to_refund_deposit_while_expired_and_not_consumed()
{
_processor.Init();
var blockProccesed = Build.A.Block.TestObject;
_accountService.GetAddress().Returns(TestItem.AddressB);
var dataAsset = new DataAsset(Keccak.OfAnEmptyString, "test", "test", 1,
DataAssetUnitType.Unit, 0, 10, new DataAssetRules(new DataAssetRule(1)),
new DataAssetProvider(Address.Zero, "test"));
_refundClaimant.TryClaimEarlyRefundAsync(Arg.Any <DepositDetails>(), TestItem.AddressB)
.Returns(new RefundClaimStatus(Keccak.Zero, true));
var consumedDeposit = new Deposit(Keccak.Zero, 10, 1, 1);
var consumedDepositDetails = new DepositDetails(consumedDeposit, dataAsset, null, null, 1, null);
consumedDepositDetails.SetConsumedUnits(9);
var refundsResult = PagedResult <DepositDetails> .Create(
new List <DepositDetails> {
consumedDepositDetails
},
1,
1,
1,
1);
_depositRepository.BrowseAsync(Arg.Any <GetDeposits>()).Returns(Task.FromResult(refundsResult));
_blockProcessor.BlockProcessed += Raise.EventWith(new BlockProcessedEventArgs(blockProccesed, Array.Empty <TxReceipt>()));
_consumerNotifier.Received().SendClaimedEarlyRefundAsync(Arg.Any <Keccak>(), Arg.Any <string>(), Arg.Any <Keccak>());
}
private static DepositDetails BuildDummyDepositDetails()
{
Deposit deposit = new Deposit(TestItem.KeccakA, 100, 100, 100);
DataAssetProvider provider = new DataAssetProvider(TestItem.AddressA, "provider");
DataAsset dataAsset = new DataAsset(TestItem.KeccakA, "data_asset", "desc", 1, DataAssetUnitType.Time, 1000, 10000, new DataAssetRules(new DataAssetRule(1), null), provider, null, QueryType.Stream, DataAssetState.Published, null, false, null);
DepositDetails details = new DepositDetails(
deposit,
dataAsset,
TestItem.AddressA,
Array.Empty <byte>(),
10,
Array.Empty <TransactionInfo>(),
9,
false,
false,
null,
Array.Empty <TransactionInfo>(),
false,
false,
null,
0,
6);
return(details);
}
public void AllFinished()
{
finishcount++;
if (finishcount != 10)
{
return;
}
for (int i = 0; i < cars.Length; i++)
{
cars[i].RunStop();
ranking[i, 0] = i;
ranking[i, 1] = cars[i].score;
cars[i].transform.position = carPos.position;
cars[i].transform.rotation = carPos.rotation;
}
SortRancing();
father = dataAsset[ranking[0, 0]];
mother = dataAsset[ranking[1, 0]];
for (int i = 0; i < 10; i++)
{
cars[i].score = 0;
cars[i].ItemClear();
}
CrossOver();
Mutate();
generation++;
mmui.GenTxt("Gen: " + generation);
if (mmui.myui.istogglevalue == true)
{
AllRun();
}
}
IResourceSource <Texture2D> MakeResourceSource(DataAsset resource)
{
if (resource == null)
{
return(null);
}
return(new AssetResourceSource <Texture2D>(resource));
}
public void SendDataAsset(DataAsset dataAsset)
{
if (Logger.IsTrace)
{
Logger.Trace($"{Session.RemoteNodeId} NDM sending: dataasset");
}
Send(new DataAssetMessage(dataAsset));
}
public void Setup()
{
DataAssetProvider provider = new DataAssetProvider(_providerAddress, "provider");
_asset = new DataAsset(Keccak.Compute("1"), "name", "desc", 1, DataAssetUnitType.Unit, 1000, 10000, new DataAssetRules(new DataAssetRule(1)), provider, state: DataAssetState.Published);
_deposit = new Deposit(Keccak.Zero, 1, 2, 3);
_details = new DepositDetails(_deposit, _asset, Address.Zero, new byte[0], 1, new TransactionInfo[0]);
}
public async Task Can_browse()
{
IMongoDatabase database = MongoForTest.Provider.GetDatabase();
var repo = new DataAssetMongoRepository(database);
DataAsset dataAsset = BuildDummyDataAsset();
await repo.AddAsync(dataAsset);
await repo.BrowseAsync(new GetDataAssets());
}
public async Task Can_check_if_exists()
{
IMongoDatabase database = MongoForTest.Provider.GetDatabase();
var repo = new DataAssetMongoRepository(database);
DataAsset dataAsset = BuildDummyDataAsset();
await repo.AddAsync(dataAsset);
(await repo.ExistsAsync(dataAsset.Id)).Should().BeTrue();
}
public Consumer(Keccak depositId, uint verificationTimestamp, DataRequest dataRequest,
DataAsset dataAsset, bool hasAvailableUnits = true)
{
DepositId = depositId;
VerificationTimestamp = verificationTimestamp;
DataRequest = dataRequest;
DataAsset = dataAsset;
HasAvailableUnits = hasAvailableUnits;
}
public void Setup()
{
DataAssetProvider provider = new DataAssetProvider(_providerAddress, "provider");
_asset = new DataAsset(Keccak.Compute("1"), "name", "desc", 1, DataAssetUnitType.Unit, 1000, 10000, new DataAssetRules(new DataAssetRule(1)), provider, state: DataAssetState.Published);
IConsumerDepositApprovalRepository repository = new ConsumerDepositApprovalInMemoryRepository();
_kycVerifier = new KycVerifier(repository, LimboLogs.Instance);
}
public async Task Can_get_by_id()
{
IMongoDatabase database = MongoForTest.Provider.GetDatabase();
var repo = new DataAssetMongoRepository(database);
DataAsset dataAsset = BuildDummyDataAsset();
await repo.AddAsync(dataAsset);
DataAsset result = await repo.GetAsync(dataAsset.Id);
result.Should().BeEquivalentTo(dataAsset);
}
public async Task Can_browse_null_query()
{
IMongoDatabase database = MongoForTest.Provider.GetDatabase();
var repo = new DataAssetMongoRepository(database);
DataAsset dataAsset = BuildDummyDataAsset();
await repo.AddAsync(dataAsset);
var result = await repo.BrowseAsync(null);
result.Items.Should().HaveCount(0);
}
private void Init()
{
mMesh = new Mesh();
mMesh.name = "Cylinder Quad";
GetComponent <MeshFilter> ().sharedMesh = mMesh;
if (!File.Exists("Assets/CircularData.asset"))
{
m_CircleData = ScriptableObject.CreateInstance <DataAsset> ();
List <Vertex> vertices = new List <Vertex> ();
for (int i = 0; i < m_FaceDetailLevel; i++)
{
float t = i / (float)m_FaceDetailLevel;
float angleInRad = t * Maths.TAU;
Vertex currentPoint = new Vertex();
currentPoint.points.x = Mathf.Cos(angleInRad) * m_Radius;
currentPoint.points.y = Mathf.Sin(angleInRad) * m_Radius;
currentPoint.normals = currentPoint.points.normalized;
//2 because of hard edge
vertices.Add(currentPoint);
Vertex oppPoint = new Vertex();
oppPoint.points = currentPoint.points;
oppPoint.normals = -currentPoint.normals;
vertices.Add(oppPoint);
// Vertex nextPoint = new Vertex ();
// nextPoint.points = currentPoint.points;
// nextPoint.normals = new Vector2 (Mathf.Cos (angleInRad + (Maths.TAU / 4)), Mathf.Sin (angleInRad + (Maths.TAU / 4)));
// vertices.Add (currentPoint);
}
List <int> lineIndices = new List <int> ();
for (int i = 0; i < m_FaceDetailLevel * 2; i++)
{
lineIndices.Add((i + 1) % (m_FaceDetailLevel * 2));
}
m_CircleData.vertices = vertices.ToArray();
m_CircleData.lineIndices = lineIndices.ToArray();
AssetDatabase.CreateAsset(m_CircleData, "Assets/CircularData.asset");
}
else
{
m_CircleData = AssetDatabase.LoadAssetAtPath <DataAsset> ("Assets/CircularData.asset");
}
}
/// <summary> Called when the data provider is selected </summary>
public override void NfoFieldFocus(plyDataObject data, EditorWindow ed)
{
// make sure the Component that handles the Rewards is registered to be added to DiaQ
EdGlobal.RemoveAutoComponent("DiaQ", typeof(plyRPGDiaQRewardHandler).AssemblyQualifiedName); // make sure old one is not present as it causes problems
EdGlobal.RegisterAutoComponent("DiaQ", typeof(InventoryProDiaQRewardHandler).AssemblyQualifiedName);
_selected = 0;
int.TryParse(data.nfo[0], out _selected);
if (_attribsAsset == null)
{
if (_dataAsset == null)
{
_dataAsset = EdGlobal.GetDataAsset();
}
_attribsAsset = (ActorAttributesAsset)_dataAsset.GetAsset <ActorAttributesAsset>();
if (_attribsAsset == null)
{
_attribsAsset = (ActorAttributesAsset)EdGlobal.LoadOrCreateAsset <ActorAttributesAsset>(plyEdUtil.DATA_PATH_SYSTEM + "attributes.asset", null);
}
}
if (_itemsAsset == null)
{
if (_dataAsset == null)
{
_dataAsset = EdGlobal.GetDataAsset();
}
_itemsAsset = (ItemsAsset)_dataAsset.GetAsset <ItemsAsset>();
if (_itemsAsset == null)
{
_itemsAsset = (ItemsAsset)EdGlobal.LoadOrCreateAsset <ItemsAsset>(plyEdUtil.DATA_PATH_SYSTEM + "items.asset", null);
}
_itemsAsset.UpdateItemCache();
}
_selectedIdent = -1;
_attribNames = new string[_attribsAsset.attributes.Count];
for (int i = 0; i < _attribsAsset.attributes.Count; i++)
{
_attribNames[i] = _attribsAsset.attributes[i].def.screenName;
if (_selected == 1 && _selectedIdent < 0)
{
if (data.nfo[1].Equals(_attribsAsset.attributes[i].id.ToString()))
{
_selectedIdent = i;
data.nfo[2] = _attribsAsset.attributes[_selectedIdent].ToString(); // update cached name just in case it has changed
GUI.changed = true;
}
}
}
}
public void Message_have_valid_protocol_and_can_serialize_and_deserialize()
{
DataAsset dataAsset = new DataAsset(Keccak.OfAnEmptyString, "name", "description", 1, DataAssetUnitType.Time, 1000, 10000, new DataAssetRules(new DataAssetRule(1), new DataAssetRule(2)), new DataAssetProvider(Address.SystemUser, "provider"));
Signature signature = new Signature(UInt256.One, UInt256.One, 27);
Session session = new Session(Keccak.EmptyTreeHash, Keccak.OfAnEmptyString, Keccak.OfAnEmptySequenceRlp, Address.SystemUser, TestItem.PublicKeyA, TestItem.AddressB, TestItem.PublicKeyB, SessionState.ProviderDisconnected, 1, 2, 3, 4, 5, 6, 7, 8);
Test(new ConsumerAddressChangedMessage(Address.SystemUser));
Test(new DataAssetDataMessage(Keccak.OfAnEmptySequenceRlp, "client", "data", 1));
Test(new DataAssetMessage(dataAsset));
Test(new DataAssetRemovedMessage(Keccak.OfAnEmptyString));
Test(new DataAssetsMessage(new[] { dataAsset, dataAsset }));
Test(new DataAssetStateChangedMessage(Keccak.OfAnEmptyString, DataAssetState.Archived));
Test(new DataAssetStateChangedMessage(Keccak.OfAnEmptyString, DataAssetState.UnderMaintenance));
Test(new DataAssetStateChangedMessage(Keccak.OfAnEmptyString, DataAssetState.Unavailable));
Test(new DataAssetStateChangedMessage(Keccak.OfAnEmptyString, DataAssetState.Published));
Test(new DataAssetStateChangedMessage(Keccak.OfAnEmptyString, DataAssetState.Unpublished));
Test(new DataAvailabilityMessage(Keccak.OfAnEmptyString, DataAvailability.Available));
Test(new DataAvailabilityMessage(Keccak.OfAnEmptyString, DataAvailability.Unknown));
Test(new DataAvailabilityMessage(Keccak.OfAnEmptyString, DataAvailability.SubscriptionEnded));
Test(new DataAvailabilityMessage(Keccak.OfAnEmptyString, DataAvailability.UnitsExceeded));
Test(new DataAvailabilityMessage(Keccak.OfAnEmptyString, DataAvailability.ExpiryRuleExceeded));
Test(new DataAvailabilityMessage(Keccak.OfAnEmptyString, DataAvailability.DataDeliveryReceiptInvalid));
Test(new DataAvailabilityMessage(Keccak.OfAnEmptyString, DataAvailability.DataDeliveryReceiptNotProvided));
Test(new DataDeliveryReceiptMessage(Keccak.OfAnEmptyString, new DataDeliveryReceipt(StatusCodes.Error, 1, 2, signature)));
Test(new DataRequestMessage(new DataRequest(Keccak.OfAnEmptyString, 1, 2, 3, new byte[] { 4 }, Address.SystemUser, TestItem.AddressA, signature), 5));
Test(new DataRequestResultMessage(Keccak.OfAnEmptyString, DataRequestResult.DepositUnverified));
Test(new DataStreamDisabledMessage(Keccak.OfAnEmptyString, "client"));
Test(new DataStreamEnabledMessage(Keccak.OfAnEmptyString, "client", new string[] { "a", "b", "c" }));
Test(new DepositApprovalConfirmedMessage(Keccak.OfAnEmptyString, Address.SystemUser));
Test(new DepositApprovalRejectedMessage(Keccak.OfAnEmptyString, Address.SystemUser));
Test(new DepositApprovalsMessage(new DepositApproval[] { new DepositApproval(Keccak.EmptyTreeHash, Keccak.OfAnEmptyString, "asset", "kyc", Address.SystemUser, TestItem.AddressA, 1, DepositApprovalState.Confirmed) }));
Test(new DisableDataStreamMessage(Keccak.OfAnEmptyString, "client"));
Test(new EarlyRefundTicketMessage(new EarlyRefundTicket(Keccak.OfAnEmptyString, 1, signature), RefundReason.InvalidDataAsset));
Test(new EnableDataStreamMessage(Keccak.OfAnEmptyString, "client", new string[] { "a", "b", "c" }));
Test(new EthRequestedMessage(new FaucetResponse(FaucetRequestStatus.FaucetDisabled, FaucetRequestDetails.Empty)));
Test(new FinishSessionMessage(Keccak.OfAnEmptyString));
Test(new GetDataAssetsMessage());
Test(new GetDepositApprovalsMessage());
Test(new GraceUnitsExceededMessage(Keccak.EmptyTreeHash, 1, 2));
Test(new HiMessage(1, TestItem.AddressA, TestItem.AddressB, TestItem.PublicKeyA, signature));
Test(new InvalidDataMessage(Keccak.OfAnEmptyString, InvalidDataReason.InvalidResult));
Test(new ProviderAddressChangedMessage(Address.SystemUser));
Test(new RequestDataDeliveryReceiptMessage(new DataDeliveryReceiptRequest(1, Keccak.OfAnEmptyString, new UnitsRange(2, 3), true, new [] { new DataDeliveryReceiptToMerge(new UnitsRange(7, 8), signature) })));
Test(new RequestDepositApprovalMessage(Keccak.OfAnEmptyString, Address.SystemUser, "kyc"));
Test(new RequestEthMessage(Address.SystemUser, UInt256.One));
Test(new SessionFinishedMessage(session));
Test(new SessionStartedMessage(session));
}
public async Task Can_browse_with_query_and_pagination()
{
IMongoDatabase database = MongoForTest.Provider.GetDatabase();
var repo = new DataAssetMongoRepository(database);
DataAsset dataAsset = BuildDummyDataAsset();
await repo.AddAsync(dataAsset);
GetDataAssets query = new GetDataAssets();
query.OnlyPublishable = true;
query.Page = 0;
query.Results = 10;
await repo.BrowseAsync(query);
}
public async Task Can_remove_async()
{
IMongoDatabase database = MongoForTest.Provider.GetDatabase();
var repo = new DataAssetMongoRepository(database);
DataAsset dataAsset = BuildDummyDataAsset();
await repo.AddAsync(dataAsset);
await repo.RemoveAsync(dataAsset.Id);
(await repo.ExistsAsync(dataAsset.Id)).Should().BeFalse();
DataAsset result = await repo.GetAsync(dataAsset.Id);
result.Should().BeNull();
}
private DataAsset SetAssetsValues(string[] values)
{
DataAsset dataAsset = new DataAsset();
try
{
dataAsset.Product = values[0];
dataAsset.Asset = values[1];
}
catch (Exception ex)
{
throw new DataAccessException(ex.Message, ex.InnerException);
}
return(dataAsset);
}
public void Setup()
{
DataAssetProvider provider = new DataAssetProvider(_providerAddress, "provider");
_asset = new DataAsset(Keccak.Compute("1"), "name", "desc", 1, DataAssetUnitType.Unit, 1000, 10000, new DataAssetRules(new DataAssetRule(1)), provider, state: DataAssetState.Published);
_deposit = new Deposit(Keccak.Zero, 1, 2, 3);
_details = new DepositDetails(_deposit, _asset, Address.Zero, new byte[0], 1, new TransactionInfo[0]);
DepositDetailsInMemoryRepository repository = new DepositDetailsInMemoryRepository(new DepositsInMemoryDb());
repository.AddAsync(_details);
ConsumerSessionInMemoryRepository sessionInMemoryRepository = new ConsumerSessionInMemoryRepository();
_depositProvider = new DepositProvider(repository, new DepositUnitsCalculator(sessionInMemoryRepository, Timestamper.Default), LimboLogs.Instance);
}
public DataAssetForRpc(DataAsset dataAsset)
{
Id = dataAsset.Id;
Name = dataAsset.Name;
Description = dataAsset.Description;
UnitPrice = dataAsset.UnitPrice;
UnitType = dataAsset.UnitType.ToString().ToLowerInvariant();
QueryType = dataAsset.QueryType.ToString().ToLowerInvariant();
MinUnits = dataAsset.MinUnits;
MaxUnits = dataAsset.MaxUnits;
Rules = new DataAssetRulesForRpc(dataAsset.Rules);
Provider = new DataAssetProviderForRpc(dataAsset.Provider);
File = dataAsset.File;
State = dataAsset.State.ToString().ToLowerInvariant();
TermsAndConditions = dataAsset.TermsAndConditions;
KycRequired = dataAsset.KycRequired;
Plugin = dataAsset.Plugin;
}
public void Setup()
{
IConsumerNotifier notifier = new ConsumerNotifier(Substitute.For <INdmNotifier>());
DepositsInMemoryDb db = new DepositsInMemoryDb();
IProviderRepository providerRepository = new ProviderInMemoryRepository(db);
DataAssetProvider provider = new DataAssetProvider(_providerAddress, "provider");
DataAssetService dataAssetService = new DataAssetService(providerRepository, notifier, LimboLogs.Instance);
_asset1 = new DataAsset(_asset1Id, "name", "desc", 1, DataAssetUnitType.Unit, 1000, 10000, new DataAssetRules(new DataAssetRule(1), new DataAssetRule(100)), provider, state: DataAssetState.Published);
dataAssetService.AddDiscovered(_asset1, _ndmPeer);
_deposit1 = new Deposit(_deposit1Id, 1, 2, 3);
_details1 = new DepositDetails(_deposit1, _asset1, Address.Zero, new byte[0], 1, new TransactionInfo[0], 1);
_asset2 = new DataAsset(_asset2Id, "name", "desc", 1, DataAssetUnitType.Time, 1000, 10000, new DataAssetRules(new DataAssetRule(1)), provider, state: DataAssetState.Published);
dataAssetService.AddDiscovered(_asset2, _ndmPeer);
_deposit2 = new Deposit(_deposit2Id, 1, 2, 3);
_details2 = new DepositDetails(_deposit2, _asset2, Address.Zero, new byte[0], 1, new TransactionInfo[0], 2);
_closed = new DataAsset(_closedId, "name", "desc", 1, DataAssetUnitType.Unit, 1000, 10000, new DataAssetRules(new DataAssetRule(1)), provider, state: DataAssetState.Closed);
dataAssetService.AddDiscovered(_closed, _ndmPeer);
_depositForClosed = new Deposit(_depositForClosedId, 1, 2, 3);
_depositForClosedDetails = new DepositDetails(_depositForClosed, _closed, Address.Zero, new byte[0], 1, new TransactionInfo[0]);
_missingAsset = new DataAsset(_missingAssetId, "name", "desc", 1, DataAssetUnitType.Unit, 1000, 10000, new DataAssetRules(new DataAssetRule(1)), provider, state: DataAssetState.Published);
_depositForMissing = new Deposit(_depositForMissingId, 1, 2, 3);
_depositForMissingDetails = new DepositDetails(_depositForMissing, _missingAsset, Address.Zero, new byte[0], 1, new TransactionInfo[0]);
IDepositProvider depositProvider = Substitute.For <IDepositProvider>();
depositProvider.GetAsync(_deposit1Id).Returns(_details1);
depositProvider.GetAsync(_deposit2Id).Returns(_details2);
depositProvider.GetAsync(_depositForMissingId).Returns(_depositForMissingDetails);
depositProvider.GetAsync(_depositForClosedId).Returns(_depositForClosedDetails);
_ndmPeer = Substitute.For <INdmPeer>();
_ndmPeer.ProviderAddress.Returns(_providerAddress);
_ndmPeer.NodeId.Returns(_providerNodeId);
_providerService = new ProviderService(providerRepository, notifier, LimboLogs.Instance);
_providerService.Add(_ndmPeer);
_sessionRepository = new ConsumerSessionInMemoryRepository();
_sessionService = new SessionService(_providerService, depositProvider, dataAssetService, _sessionRepository, Timestamper.Default, notifier, LimboLogs.Instance);
}
public void Setup()
{
DataAssetProvider provider = new DataAssetProvider(_providerAddress, "provider");
_asset = new DataAsset(Keccak.Compute("1"), "name", "desc", 1, DataAssetUnitType.Unit, 1000, 10000, new DataAssetRules(new DataAssetRule(1)), provider, state: DataAssetState.Published);
_closedAsset = new DataAsset(Keccak.Compute("2"), "name", "desc", 1, DataAssetUnitType.Unit, 1000, 10000, new DataAssetRules(new DataAssetRule(1)), provider, state: DataAssetState.Closed);
_assetUnderMaintenance = new DataAsset(Keccak.Compute("3"), "name", "desc", 1, DataAssetUnitType.Unit, 1000, 10000, new DataAssetRules(new DataAssetRule(1)), provider, state: DataAssetState.UnderMaintenance);
_withKyc = new DataAsset(Keccak.Compute("4"), "name", "desc", 1, DataAssetUnitType.Unit, 1000, 10000, new DataAssetRules(new DataAssetRule(1)), provider, state: DataAssetState.Published, kycRequired: true);
_deposit = new Deposit(Keccak.Zero, 1, 2, 3);
_details = new DepositDetails(_deposit, _asset, Address.Zero, new byte[0], 1, new TransactionInfo[0]);
INdmBlockchainBridge blockchainBridge = BlockchainBridgeBuilder.BuildABridge();
_wallet = new DevWallet(new WalletConfig(), LimboLogs.Instance);
DepositService depositService = new DepositService(blockchainBridge, new AbiEncoder(), _wallet, Address.Zero);
IConsumerSessionRepository sessionRepository = new ConsumerSessionInMemoryRepository();
DepositUnitsCalculator unitsCalculator = new DepositUnitsCalculator(sessionRepository, Timestamper.Default);
DepositsInMemoryDb depositsInMemoryDb = new DepositsInMemoryDb();
depositsInMemoryDb.Add(_details);
IProviderRepository providerRepository = new ProviderInMemoryRepository(depositsInMemoryDb);
IConsumerNotifier notifier = new ConsumerNotifier(Substitute.For <INdmNotifier>());
DataAssetService dataAssetService = new DataAssetService(providerRepository, notifier, LimboLogs.Instance);
IDepositUnitsCalculator depositUnitsCalculator = Substitute.For <IDepositUnitsCalculator>();
INdmPeer peer = Substitute.For <INdmPeer>();
peer.NodeId.Returns(TestItem.PublicKeyB);
peer.ProviderAddress.Returns(_providerAddress);
dataAssetService.AddDiscovered(_asset, peer);
dataAssetService.AddDiscovered(_closedAsset, peer);
dataAssetService.AddDiscovered(_assetUnderMaintenance, peer);
dataAssetService.AddDiscovered(_withKyc, peer);
_kycVerifier = Substitute.For <IKycVerifier>();
ProviderService providerService = new ProviderService(providerRepository, notifier, LimboLogs.Instance);
providerService.Add(peer);
_depositManager = new DepositManager(depositService, unitsCalculator, dataAssetService, _kycVerifier, providerService, new AbiEncoder(), new CryptoRandom(), _wallet, Substitute.For <IGasPriceService>(), new DepositDetailsInMemoryRepository(depositsInMemoryDb, depositUnitsCalculator), Timestamper.Default, LimboLogs.Instance, 6, false);
}
public void Setup()
{
INdmPeer peer = Substitute.For <INdmPeer>();
peer.ProviderAddress.Returns(_providerAddress);
_providerId = TestItem.PublicKeyB;
peer.NodeId.Returns(_providerId);
DataAssetProvider provider = new DataAssetProvider(_providerAddress, "name");
DataAsset newPendingAsset = new DataAsset(_newPendingAssetId, "name", "desc", 1, DataAssetUnitType.Unit, 1000, 10000, new DataAssetRules(new DataAssetRule(1), null), provider);
DataAsset pendingAsset = new DataAsset(_pendingAssetId, "name", "desc", 1, DataAssetUnitType.Unit, 1000, 10000, new DataAssetRules(new DataAssetRule(1), null), provider);
DataAsset rejectedAsset = new DataAsset(_rejectedAssetId, "name", "desc", 1, DataAssetUnitType.Unit, 1000, 10000, new DataAssetRules(new DataAssetRule(1), null), provider);
DataAsset confirmedAsset = new DataAsset(_confirmedAssetId, "name", "desc", 1, DataAssetUnitType.Unit, 1000, 10000, new DataAssetRules(new DataAssetRule(1), null), provider);
DepositsInMemoryDb db = new DepositsInMemoryDb();
ProviderInMemoryRepository providerRepository = new ProviderInMemoryRepository(db);
_cdaRepo = new ConsumerDepositApprovalInMemoryRepository();
_ndmNotifier = Substitute.For <INdmNotifier>();
ConsumerNotifier notifier = new ConsumerNotifier(_ndmNotifier);
DataAssetService dataAssetService = new DataAssetService(providerRepository, notifier, LimboLogs.Instance);
dataAssetService.AddDiscovered(newPendingAsset, peer);
dataAssetService.AddDiscovered(pendingAsset, peer);
dataAssetService.AddDiscovered(rejectedAsset, peer);
dataAssetService.AddDiscovered(confirmedAsset, peer);
_providerService = new ProviderService(providerRepository, notifier, LimboLogs.Instance);
_providerService.Add(peer);
_service = new DepositApprovalService(dataAssetService, _providerService, _cdaRepo, Timestamper.Default, notifier, LimboLogs.Instance);
_confirmedApproval = new DepositApproval(Keccak.Compute(Rlp.Encode(Rlp.Encode(_confirmedAssetId), Rlp.Encode(_consumerAddress)).Bytes), _confirmedAssetId, "asset", "kyc", _consumerAddress, _providerAddress, 1, DepositApprovalState.Confirmed);
_pendingApproval = new DepositApproval(Keccak.Compute(Rlp.Encode(Rlp.Encode(_pendingAssetId), Rlp.Encode(_consumerAddress)).Bytes), _pendingAssetId, "asset", "kyc", _consumerAddress, _providerAddress, 1, DepositApprovalState.Pending);
_rejectedApproval = new DepositApproval(Keccak.Compute(Rlp.Encode(Rlp.Encode(_rejectedAssetId), Rlp.Encode(_consumerAddress)).Bytes), _rejectedAssetId, "asset", "kyc", _consumerAddress, _providerAddress, 1, DepositApprovalState.Rejected);
_cdaRepo.AddAsync(_confirmedApproval);
_cdaRepo.AddAsync(_pendingApproval);
_cdaRepo.AddAsync(_rejectedApproval);
}
public DepositDetails(Deposit deposit, DataAsset dataAsset, Address consumer, byte[] pepper, uint timestamp,
Keccak transactionHash, uint confirmationTimestamp = 0, bool rejected = false,
EarlyRefundTicket earlyRefundTicket = null, Keccak claimedRefundTransactionHash = null,
bool refundClaimed = false, string kyc = null, uint confirmations = 0, uint requiredConfirmations = 0)
{
Id = deposit.Id;
Deposit = deposit;
DataAsset = dataAsset;
Consumer = consumer;
Pepper = pepper;
Timestamp = timestamp;
TransactionHash = transactionHash;
SetConfirmationTimestamp(confirmationTimestamp);
Rejected = rejected;
EarlyRefundTicket = earlyRefundTicket;
SetClaimedRefundTransactionHash(claimedRefundTransactionHash);
RefundClaimed = refundClaimed;
Kyc = kyc;
Confirmations = confirmations;
RequiredConfirmations = requiredConfirmations;
}
public void Setup()
{
DataAssetProvider provider = new DataAssetProvider(_providerAddress, "provider");
_asset = new DataAsset(Keccak.Compute("1"), "name", "desc", 1, DataAssetUnitType.Unit, 1000, 10000, new DataAssetRules(new DataAssetRule(1)), provider, state: DataAssetState.Published);
_deposit = new Deposit(Keccak.Zero, 1, 2, 3);
_details = new DepositDetails(_deposit, _asset, Address.Zero, new byte[0], 1, new TransactionInfo[0]);
IAccountService accountService = Substitute.For <IAccountService>();
IRefundClaimant refundClaimant = Substitute.For <IRefundClaimant>();
IDepositConfirmationService depositConfirmationService = Substitute.For <IDepositConfirmationService>();
IEthPriceService ethPriceService = Substitute.For <IEthPriceService>();
IGasPriceService gasPriceService = Substitute.For <IGasPriceService>();
_blockProcessor = Substitute.For <IBlockProcessor>();
IConsumerNotifier notifier = new ConsumerNotifier(Substitute.For <INdmNotifier>());
IDepositDetailsRepository repository = new DepositDetailsInMemoryRepository(new DepositsInMemoryDb());
repository.AddAsync(_details);
_processor = new ConsumerServicesBackgroundProcessor(accountService, refundClaimant, depositConfirmationService, ethPriceService, gasPriceService, _blockProcessor, repository, notifier, LimboLogs.Instance);
}
public DepositDetails(Deposit deposit, DataAsset dataAsset, Address consumer, byte[] pepper, uint timestamp,
TransactionInfo transaction, uint confirmationTimestamp = 0, bool rejected = false,
EarlyRefundTicket earlyRefundTicket = null, TransactionInfo claimedRefundTransaction = null,
bool refundClaimed = false, string kyc = null, uint confirmations = 0, uint requiredConfirmations = 0)
{
Id = deposit.Id;
Deposit = deposit;
DataAsset = dataAsset;
Consumer = consumer;
Pepper = pepper;
Timestamp = timestamp;
Transaction = transaction;
ConfirmationTimestamp = confirmationTimestamp;
Rejected = rejected;
EarlyRefundTicket = earlyRefundTicket;
ClaimedRefundTransaction = claimedRefundTransaction;
RefundClaimed = refundClaimed;
Kyc = kyc;
Confirmations = confirmations;
RequiredConfirmations = requiredConfirmations;
}
private DepositDetails CreateDeposit(DataAssetUnitType type)
{
var deposit = new Deposit(Keccak.Zero, units: 100, expiryTime: 100, value: 10);
var dataAsset = new DataAsset(Keccak.OfAnEmptyString,
name: "TestAsset",
description: "Test",
unitPrice: 10,
unitType: type,
minUnits: 1,
maxUnits: 100,
rules: new DataAssetRules(new DataAssetRule(1)),
provider: new DataAssetProvider(TestItem.AddressA, "provider"));
return(new DepositDetails(deposit,
dataAsset,
consumer: TestItem.AddressB,
pepper: Array.Empty <byte>(),
timestamp: 50,
transactions: Array.Empty <TransactionInfo>()));
}
public DepositDetails Decode(RlpStream rlpStream, RlpBehaviors rlpBehaviors = RlpBehaviors.None)
{
rlpStream.ReadSequenceLength();
Deposit deposit = Serialization.Rlp.Rlp.Decode <Deposit>(rlpStream);
DataAsset dataAsset = Serialization.Rlp.Rlp.Decode <DataAsset>(rlpStream);
Address consumer = rlpStream.DecodeAddress();
var pepper = rlpStream.DecodeByteArray();
uint timestamp = rlpStream.DecodeUInt();
var transactions = Serialization.Rlp.Rlp.DecodeArray <TransactionInfo>(rlpStream);
uint confirmationTimestamp = rlpStream.DecodeUInt();
bool rejected = rlpStream.DecodeBool();
bool cancelled = rlpStream.DecodeBool();
EarlyRefundTicket earlyRefundTicket = Serialization.Rlp.Rlp.Decode <EarlyRefundTicket>(rlpStream);
var claimedRefundTransactions = Serialization.Rlp.Rlp.DecodeArray <TransactionInfo>(rlpStream);
bool refundClaimed = rlpStream.DecodeBool();
bool refundCancelled = rlpStream.DecodeBool();
string kyc = rlpStream.DecodeString();
uint confirmations = rlpStream.DecodeUInt();
uint requiredConfirmations = rlpStream.DecodeUInt();
return(new DepositDetails(deposit, dataAsset, consumer, pepper, timestamp, transactions,
confirmationTimestamp, rejected, cancelled, earlyRefundTicket, claimedRefundTransactions,
refundClaimed, refundCancelled, kyc, confirmations, requiredConfirmations));
}
public void AddDiscoveredDataAsset(DataAsset dataAsset, INdmPeer peer) => _dataAssetService.AddDiscovered(dataAsset, peer);
internal void ReadParameters(AssetLoader loader, FolderAsset textureFolder)
{
var reader = loader.Reader;
int startIndex = ParameterStartIndex;
for (int index = 0; index < ParameterCount; index++)
{
ParametersList.Add(new ModelMaterialParameter(this, index, startIndex + index, loader));
}
if (textureFolder != null)
{
foreach (ModelMaterialParameter parameter in Parameters)
{
if (string.IsNullOrEmpty(parameter.Value))
{
continue;
}
string name = Path.GetFileNameWithoutExtension(parameter.Value);
DataAsset resource = null;
foreach (DataAsset archiveAsset in textureFolder.Children)
{
var extension = Path.GetExtension(archiveAsset.Name);
if (extension != ".tpf" && extension != ".tpfbhd")
{
continue;
}
FolderAsset archive = archiveAsset.Contents as FolderAsset;
if (archive == null)
{
continue;
}
foreach (DataAsset compare in archive.Children)
{
if (compare.Name.StartsWith(name) && (compare.Name.Length == name.Length || compare.Name[name.Length] == '.'))
{
if (compare.Name.EndsWith(".tpf.dcx"))
{
FolderAsset textureArchive = (FolderAsset)compare.Contents;
resource = (DataAsset)textureArchive.Children[0];
}
else
{
resource = compare;
}
break;
}
}
if (resource != null)
{
break;
}
}
parameter.TextureSource = MakeResourceSource(resource);
/*if (parameter.Name == "g_Diffuse")
* ModelMaterial.DiffuseMap = MakeResourceSource(resource);
* else if (parameter.Name == "g_Specular")
* ModelMaterial.SpecularMap = MakeResourceSource(resource);
* else if (parameter.Name == "g_Bumpmap")
* ModelMaterial.NormalMap = MakeResourceSource(resource);*/
}
}
}
/// <summary> Called when the data provider is selected </summary>
public override void NfoFieldFocus(plyDataObject data, EditorWindow ed)
{
// make sure the Component that handles the Rewards is registered to be added to DiaQ
EdGlobal.RegisterAutoComponent("DiaQ", "plyRPGDiaQRewardHandler");
selected = 0;
int.TryParse(data.nfo[0], out selected);
if (attribsAsset == null)
{
if (dataAsset == null) dataAsset = EdGlobal.GetDataAsset();
attribsAsset = (ActorAttributesAsset)dataAsset.GetAsset<ActorAttributesAsset>();
if (attribsAsset == null) attribsAsset = (ActorAttributesAsset)EdGlobal.LoadOrCreateAsset<ActorAttributesAsset>(EdGlobal.DATA_PATH_SYSTEM + "attributes.asset", null);
}
if (itemsAsset == null)
{
if (dataAsset == null) dataAsset = EdGlobal.GetDataAsset();
itemsAsset = (ItemsAsset)dataAsset.GetAsset<ItemsAsset>();
if (itemsAsset == null) itemsAsset = (ItemsAsset)EdGlobal.LoadOrCreateAsset<ItemsAsset>(EdGlobal.DATA_PATH_SYSTEM + "items.asset", null);
itemsAsset.UpdateItemCache();
}
selectedIdent = -1;
attribNames = new string[attribsAsset.attributes.Count];
for (int i = 0; i < attribsAsset.attributes.Count; i++)
{
attribNames[i] = attribsAsset.attributes[i].def.screenName;
if (selected == 1 && selectedIdent < 0)
{
if (data.nfo[1].Equals(attribsAsset.attributes[i].id.ToString()))
{
selectedIdent = i;
data.nfo[2] = attribsAsset.attributes[selectedIdent].def.screenName; // update cached name just in case it has changed
GUI.changed = true;
}
}
}
if (data.nfo[0] == "2")
{
if (null == itemsAsset.GetDefinition(new UniqueID(data.nfo[1])))
{
data.nfo[1] = "";
data.nfo[2] = "";
GUI.changed = true;
}
}
}
/// <summary> Called when the data provider is selected </summary>
public override void NfoFieldFocus(plyDataObject data, EditorWindow ed)
{
// make sure the Component that handles the Rewards is registered to be added to DiaQ
EdGlobal.RemoveAutoComponent("DiaQ", typeof(plyRPGDiaQRewardHandler).AssemblyQualifiedName); // make sure old one is not present as it causes problems
EdGlobal.RegisterAutoComponent("DiaQ", typeof(InventoryProDiaQRewardHandler).AssemblyQualifiedName);
selected = 0;
int.TryParse(data.nfo[0], out selected);
if (attribsAsset == null)
{
if (dataAsset == null) dataAsset = EdGlobal.GetDataAsset();
attribsAsset = (ActorAttributesAsset)dataAsset.GetAsset<ActorAttributesAsset>();
if (attribsAsset == null) attribsAsset = (ActorAttributesAsset)EdGlobal.LoadOrCreateAsset<ActorAttributesAsset>(plyEdUtil.DATA_PATH_SYSTEM + "attributes.asset", null);
}
if (itemsAsset == null)
{
if (dataAsset == null) dataAsset = EdGlobal.GetDataAsset();
itemsAsset = (ItemsAsset)dataAsset.GetAsset<ItemsAsset>();
if (itemsAsset == null) itemsAsset = (ItemsAsset)EdGlobal.LoadOrCreateAsset<ItemsAsset>(plyEdUtil.DATA_PATH_SYSTEM + "items.asset", null);
itemsAsset.UpdateItemCache();
}
selectedIdent = -1;
attribNames = new string[attribsAsset.attributes.Count];
for (int i = 0; i < attribsAsset.attributes.Count; i++)
{
attribNames[i] = attribsAsset.attributes[i].def.screenName;
if (selected == 1 && selectedIdent < 0)
{
if (data.nfo[1].Equals(attribsAsset.attributes[i].id.ToString()))
{
selectedIdent = i;
data.nfo[2] = attribsAsset.attributes[selectedIdent].ToString(); // update cached name just in case it has changed
GUI.changed = true;
}
}
}
}
