public static ChainData GetBlockByID(int id)
{
try
{
var client = new HttpClient();
//todo: wait api
var requestUrl = $"{url}/getBlockbyID/{id.ToString()}";
var response = client.GetAsync(requestUrl).Result;
if (response.IsSuccessStatusCode == false)
{
return(default(ChainData));
}
var resultJSON = response.Content.ReadAsStringAsync().Result;
client.Dispose();
dynamic data = JObject.Parse(resultJSON);
var timeStamp = (int)data.result.timestamp;
var transactionNumber = data.result.transaction.Count;
var chainData = new ChainData
{
Timestamp = timeStamp,
TransactionNumber = transactionNumber
};
return(chainData);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
return(default(ChainData));
}
public IEnumerable <ChainData> GetChainData()
{
Dictionary <int, ChainData> list = new Dictionary <int, ChainData>();
lock (this.locker)
{
using (var iterator = this.leveldb.CreateIterator())
{
iterator.SeekToFirst();
while (iterator.IsValid() && iterator.Key()[0] == ChainTableName)
{
var height = BitConverter.ToInt32(iterator.Key().AsSpan(1));
byte[] bytes = iterator.Value();
var data = new ChainData();
data.FromBytes(bytes, this.network.Consensus.ConsensusFactory);
list.Add(height, data);
iterator.Next();
}
}
}
// Order by height and return new array with ChainData.
return(list.OrderBy(c => c.Key).Select(c => c.Value));
}
public void OnFightPressed()
{
ChainData.RefreshChain();
foreach (var item in ChainInspector.Chain)
{
if (!item.name.Equals("empty"))
{
ChainData.chain.Add(new LinkData(item));
}
}
var saveData = JsonMapper.ToJson(ChainData.chain);
// Debug.Log(saveData);
if (enemyScene)
{
File.WriteAllText(Application.dataPath + "/StreamingAssets/Enemy.json", saveData);
SceneManager.LoadScene(1);
}
else
{
File.WriteAllText(Application.dataPath + "/StreamingAssets/Player.json", saveData);
SceneManager.LoadScene(0);
}
}
protected override ChainData Divide(ChainData data)
{
MathChainData mathData = data as MathChainData;
float a = this.Data / mathData.Data;
return(new MathChainData(a));
}
protected override ChainData Multiply(ChainData data)
{
MathChainData mathData = data as MathChainData;
float a = this.Data * mathData.Data;
return(new MathChainData(a));
}
protected override ChainData Subtract(ChainData data)
{
MathChainData mathData = data as MathChainData;
float a = this.Data - mathData.Data;
return(new MathChainData(a));
}
public int FindLongestChain(int[][] pairs)
{
List <ChainData> chainDatas = new List <ChainData>();
for (int i = 0; i < pairs.Length; i++)
{
ChainData chainData = new ChainData();
chainData.start_value = pairs[i][0];
chainData.end_value = pairs[i][1];
chainDatas.Add(chainData);
}
int cnt = 0;
chainDatas.Sort((ChainData a, ChainData b) => { return(a.end_value - b.end_value); });
ChainData lastChainData = chainDatas[0];
foreach (ChainData chainData in chainDatas)
{
if (cnt == 0 || chainData.end_value > lastChainData.end_value)
{
cnt++;
}
}
return(cnt);
}
public BlockValidationTests()
{
_address = new Address("test1".Hash());
_feedback = new NullFeedBack();
_cryptography = new Cryptography();
_minerFactory = new MinerFactory(_cryptography);
_chainData = new ChainData(_feedback, _cryptography);
}
public void CarHandlerTest()
{
CarHandler headHandler = new HeadHandler();
CarHandler bodyHandler = new BodyHandler();
CarHandler tailHandler = new TailHandler();
headHandler.SetNextHandler(bodyHandler).SetNextHandler(tailHandler);
headHandler.Handler();
var chainList = ChainData.Instance().GetChainList();
Assert.True(chainList[0] == "Head" &&
chainList[1] == "Body" &&
chainList[2] == "Tail");
}
public override void Prosess()
{
ChainData a = Inputs [0].Data;
ChainData b = Inputs [1].Data;
if (a != null && b != null)
{
Data = a + b;
for (int i = 0; i < _outputs.Count; i++)
{
_outputs [i].Prosess();
}
}
}
/// <inheritdoc />
public Task <ChainedHeader> LoadAsync(ChainedHeader genesisHeader)
{
Task <ChainedHeader> task = Task.Run(() =>
{
ChainedHeader tip = null;
ChainData data = this.chainStore.GetChainData(0);
if (data == null)
{
genesisHeader.SetChainStore(this.chainStore);
return(genesisHeader);
}
Guard.Assert(data.Hash == genesisHeader.HashBlock); // can't swap networks
int index = 0;
while (true)
{
data = this.chainStore.GetChainData((index));
if (data == null)
{
break;
}
tip = new ChainedHeader(data.Hash, data.Work, tip);
if (tip.Height == 0)
{
tip.SetChainStore(this.chainStore);
}
index++;
}
if (tip == null)
{
genesisHeader.SetChainStore(this.chainStore);
tip = genesisHeader;
}
this.locator = tip.GetLocator();
return(tip);
});
return(task);
}
void Start()
{
cubes = GetComponent <SphereGenerator> ().GetTransforms();
depth = GetDepth(cubes[0]);
entityManager = World.Active.GetExistingManager <EntityManager> ();
entityArchetype = entityManager.CreateArchetype(
ComponentType.Create <ChainRoot> (),
ComponentType.FixedArray(typeof(ChainData), depth)
);
var time = Time.realtimeSinceStartup;
for (int i = 0; i < cubes.Length; i++)
{
var entity = entityManager.CreateEntity(entityArchetype);
entityManager.SetComponentData(entity, new ChainRoot()
{
Length = depth
});
var chain = cubes[i].GetComponentsInChildren <Transform> ();
var chainDatas = entityManager.GetFixedArray <ChainData> (entity);
for (int j = 0; j < depth; j++)
{
chainDatas[j] = new ChainData()
{
InitLocalPosition = chain[j].localPosition
};
}
for (int j = 0; j < depth; j++)
{
// var subEntity = chain[j].gameObject.AddComponent<GameObjectEntity> ().Entity;
var subEntity = GameObjectEntity.AddToEntityManager(entityManager, chain[j].gameObject); // faster initialization
entityManager.AddComponentData(subEntity, new Owner()
{
Value = entity, Index = j
});
}
}
Debug.Log(Time.realtimeSinceStartup - time);
}
public ChainData GetChainData(int height)
{
byte[] bytes = null;
lock (this.locker)
{
bytes = this.leveldb.Get(DBH.Key(ChainTableName, BitConverter.GetBytes(height)));
}
if (bytes == null)
{
return(null);
}
var data = new ChainData();
data.FromBytes(bytes, this.network.Consensus.ConsensusFactory);
return(data);
}
private ComputeBuffer GetChainDataBuffer()
{
ComputeBuffer ret = new ComputeBuffer(ChainLinkCount, ChainDataBufferStride);
ChainData[] data = new ChainData[ChainLinkCount];
for (int i = 0; i < ChainLinkCount; i++)
{
data[i].Position = new Vector3(0, i, 0);
data[i].LinkNormal = new Vector3(0, 1, 0);
if (i % 2 < 1)
{
data[i].LinkBinormal = new Vector3(0, 0, 1);
}
else
{
data[i].LinkBinormal = new Vector3(1, 0, 0);
}
}
ret.SetData(data);
return(ret);
}
public void AddChainLink()
{
var windowManager = new WindowManager();
var context = new AddLinkWindowViewModel();
windowManager.ShowDialog(context);
if (context.Result.HasValue)
{
int insertIndex = ChainLinks.Count;
LinkBase link;
switch (context.Result.Value)
{
case LinkType.InputLayer:
if (ChainLinks.Count > 0)
{
if (ChainData.CountLinksOfType(typeof(InputLayer)) > 0)
{
MessageBox.Show("Only one Input Layer is allowed (or useful) per chain.");
return;
}
}
insertIndex = 0;
link = new InputLayer(ChainData, String.Format("Input Layer"));
//TODO: Fix
((InputDataParameter)link.Parameters[0]).InputDataValue = _parent.NetworkArchitectureData.Problem.Inputs[0];
break;
case LinkType.ActivationLayer:
link = new ActivationLayer(ChainData, String.Format("Activation Layer"));
break;
case LinkType.Convolution1DLayer:
link = new Convolution1DLayer(ChainData, String.Format("1D Convolution Layer"));
break;
case LinkType.Convolution2DLayer:
link = new Convolution2DLayer(ChainData, String.Format("2D Convolution Layer"));
break;
case LinkType.Convolution3DLayer:
link = new Convolution3DLayer(ChainData, String.Format("3D Convolution Layer"));
break;
default:
case LinkType.DenseLayer:
link = new DenseLayer(ChainData, String.Format("Dense Layer"));
break;
case LinkType.DropoutLayer:
link = new DropoutLayer(ChainData, String.Format("Dropout Layer"));
break;
case LinkType.FlattenLayer:
link = new FlattenLayer(ChainData, String.Format("Flatten Layer"));
break;
case LinkType.ReshapeLayer:
link = new ReshapeLayer(ChainData, String.Format("Reshape Layer"));
break;
case LinkType.MergeLayer:
link = new MergeLayer(ChainData, String.Format("Merge Layer"));
break;
case LinkType.BatchNormalizationLayer:
link = new BatchNormalizationLayer(ChainData, String.Format("Batch Normalization Layer"));
break;
case LinkType.LinearTransformationLayer:
link = new LinearTransformationLayer(ChainData, String.Format("Linear Transformation"));
break;
}
ChainData.ChainLinks.Insert(insertIndex, link);
ValidateInputCompatibility();
refreshLinks();
}
}
public async Task <bool> RequestMinecraftChain(AuthResponse <XuiDisplayClaims <XstsXui> > token, AsymmetricCipherKeyPair key)
{
var b = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(MinecraftKeyPair.Public).GetEncoded().EncodeBase64();
var body = new MCChainPostData()
{
IdentityPublicKey = b
};
var client = GetClient();
//using (var client = new HttpClient())
{
using (var r = new HttpRequestMessage(HttpMethod.Post,
MinecraftAuthUrl))
{
//r.Headers.Add("x-xbl-contract-version", "1");
r.Content = SetHttpContent(body, out var jsonData);
r.Headers.Add("Authorization", $"XBL3.0 x={token.DisplayClaims.Xui[0].Uhs};{token.Token}");
r.Headers.Add("User-Agent", "MCPE/UWP");
r.Headers.Add("Client-Version", McpeProtocolInfo.ProtocolVersion.ToString());
//Sign(r, jsonData);
try
{
using (var response = await client
.SendAsync(r, HttpCompletionOption.ResponseContentRead)
.ConfigureAwait(false))
{
response.EnsureSuccessStatusCode();
var rawResponse = await response.Content.ReadAsStringAsync();
DecodedChain = new ChainData();
dynamic a = JObject.Parse(rawResponse);
var chain = ((JArray)a.chain).Values <string>().ToArray();
DecodedChain.Chain = new CertificateData[chain.Length];
for (int i = 0; i < chain.Length; i++)
{
var element = chain[i];
try
{
DecodedChain.Chain[i] = JWT.Payload <CertificateData>(element);
}
catch (Exception ex)
{
Log.Error($"Could not parse chain element: {ex.ToString()}");
}
}
//DecodedChain = JsonConvert.DeserializeObject<ChainData>(rawResponse);
MinecraftChain = Encoding.UTF8.GetBytes(rawResponse);
// //Log.Debug($"Chain: {rawResponse}");
}
}
catch (Exception ex)
{
Log.Warn($"AHHH: {ex.ToString()}");
return(false);
}
}
}
// //Log.Debug($"Xbox login processed!");
return(true);
}
/// <inheritdoc />
public Task <ChainedHeader> LoadAsync(ChainedHeader genesisHeader)
{
Task <ChainedHeader> task = Task.Run(() =>
{
ChainedHeader tip = null;
ChainData data = this.chainStore.GetChainData(0);
if (data == null)
{
genesisHeader.SetChainStore(this.chainStore);
return(genesisHeader);
}
Guard.Assert(data.Hash == genesisHeader.HashBlock); // can't swap networks
int height = 0;
while (true)
{
data = this.chainStore.GetChainData(height);
if (data == null)
{
break;
}
tip = new ChainedHeader(data.Hash, data.Work, tip);
if (tip.Height == 0)
{
tip.SetChainStore(this.chainStore);
}
if (height % 50_000 == 0)
{
if (this.signals != null)
{
this.signals.Publish(new FullNodeEvent()
{
Message = $"Loading chain at height {height}.", State = FullNodeState.Initializing.ToString()
});
}
this.logger.LogInformation($"Loading chain at height {height}.");
}
height++;
}
if (tip == null)
{
genesisHeader.SetChainStore(this.chainStore);
tip = genesisHeader;
}
else
{
// Confirm that the chain tip exists in the headers table.
this.chainStore.GetHeader(tip, tip.HashBlock);
}
this.locator = tip.GetLocator();
return(tip);
});
return(task);
}
