public void hash160()
{
var data = new byte[] { 1, 2, 3, 4 };
uint160 result = Hashes.Hash160(data);
Assert.Equal("706ea1768da7f0c489bf931b362c2d26d8cbd2ec", result.ToString());
}
public string ToString(bool longForm)
{
if (longForm)
{
return(_Id.ToString());
}
return(_Id.GetLow64().ToString());
}
private void AssertNotDuplicateQuery(int cycleId, uint160 channelId, [CallerMemberName] string name = null)
{
var h = Hashes.Hash160(Encoding.UTF8.GetBytes(channelId.ToString() + name));
if (!Repository.MarkUsedNonce(cycleId, h))
{
throw new ActionResultException(BadRequest("duplicate-query"));
}
}
public void methods()
{
Assert.True(R1L.GetHex() == R1L.ToString());
Assert.True(R2L.GetHex() == R2L.ToString());
Assert.True(OneL.GetHex() == OneL.ToString());
Assert.True(MaxL.GetHex() == MaxL.ToString());
uint256 TmpL = new uint256(R1L);
Assert.True(TmpL == R1L);
TmpL.SetHex(R2L.ToString());
Assert.True(TmpL == R2L);
TmpL.SetHex(ZeroL.ToString());
Assert.True(TmpL == 0);
TmpL.SetHex(HalfL.ToString());
Assert.True(TmpL == HalfL);
TmpL.SetHex(R1L.ToString());
AssertEx.CollectionEquals(R1L.ToBytes(), R1Array);
AssertEx.CollectionEquals(TmpL.ToBytes(), R1Array);
AssertEx.CollectionEquals(R2L.ToBytes(), R2Array);
AssertEx.CollectionEquals(ZeroL.ToBytes(), ZeroArray);
AssertEx.CollectionEquals(OneL.ToBytes(), OneArray);
Assert.True(R1L.Size == 32);
Assert.True(R2L.Size == 32);
Assert.True(ZeroL.Size == 32);
Assert.True(MaxL.Size == 32);
//No sense in .NET
//Assert.True(R1L.begin() + 32 == R1L.end());
//Assert.True(R2L.begin() + 32 == R2L.end());
//Assert.True(OneL.begin() + 32 == OneL.end());
//Assert.True(MaxL.begin() + 32 == MaxL.end());
//Assert.True(TmpL.begin() + 32 == TmpL.end());
Assert.True(R1L.GetLow64() == R1LLow64);
Assert.True(HalfL.GetLow64() == 0x0000000000000000UL);
Assert.True(OneL.GetLow64() == 0x0000000000000001UL);
Assert.True(R1L.GetSerializeSize(0, ProtocolVersion.PROTOCOL_VERSION) == 32);
Assert.True(ZeroL.GetSerializeSize(0, ProtocolVersion.PROTOCOL_VERSION) == 32);
MemoryStream ss = new MemoryStream();
R1L.Serialize(ss, 0, ProtocolVersion.PROTOCOL_VERSION);
Assert.True(ArrayToString(ss.ToArray()) == ArrayToString(R1Array));
TmpL.Unserialize(ss, 0, ProtocolVersion.PROTOCOL_VERSION);
Assert.True(R1L == TmpL);
ss = new MemoryStream();
ZeroL.Serialize(ss, 0, ProtocolVersion.PROTOCOL_VERSION);
Assert.True(ArrayToString(ss.ToArray()) == ArrayToString(ZeroArray));
ss.Position = 0;
TmpL.Unserialize(ss, 0, ProtocolVersion.PROTOCOL_VERSION);
Assert.True(ZeroL == TmpL);
ss = new MemoryStream();
MaxL.Serialize(ss, 0, ProtocolVersion.PROTOCOL_VERSION);
Assert.True(ArrayToString(ss.ToArray()) == ArrayToString(MaxArray));
ss.Position = 0;
TmpL.Unserialize(ss, 0, ProtocolVersion.PROTOCOL_VERSION);
Assert.True(MaxL == TmpL);
ss = new MemoryStream();
Assert.True(R1S.GetHex() == R1S.ToString());
Assert.True(R2S.GetHex() == R2S.ToString());
Assert.True(OneS.GetHex() == OneS.ToString());
Assert.True(MaxS.GetHex() == MaxS.ToString());
uint160 TmpS = new uint160(R1S);
Assert.True(TmpS == R1S);
TmpS.SetHex(R2S.ToString());
Assert.True(TmpS == R2S);
TmpS.SetHex(ZeroS.ToString());
Assert.True(TmpS == 0);
TmpS.SetHex(HalfS.ToString());
Assert.True(TmpS == HalfS);
TmpS.SetHex(R1S.ToString());
Assert.True(ArrayToString(R1S.ToBytes()) == ArrayToString(R1Array.Take(20).ToArray()));
Assert.True(ArrayToString(TmpS.ToBytes()) == ArrayToString(R1Array.Take(20).ToArray()));
Assert.True(ArrayToString(R2S.ToBytes()) == ArrayToString(R2Array.Take(20).ToArray()));
Assert.True(ArrayToString(ZeroS.ToBytes()) == ArrayToString(ZeroArray.Take(20).ToArray()));
Assert.True(ArrayToString(OneS.ToBytes()) == ArrayToString(OneArray.Take(20).ToArray()));
Assert.True(R1S.Size == 20);
Assert.True(R2S.Size == 20);
Assert.True(ZeroS.Size == 20);
Assert.True(MaxS.Size == 20);
//No sense in .NET
//Assert.True(R1S.begin() + 20 == R1S.end());
//Assert.True(R2S.begin() + 20 == R2S.end());
//Assert.True(OneS.begin() + 20 == OneS.end());
//Assert.True(MaxS.begin() + 20 == MaxS.end());
//Assert.True(TmpS.begin() + 20 == TmpS.end());
Assert.True(R1S.GetLow64() == R1LLow64);
Assert.True(HalfS.GetLow64() == 0x0000000000000000UL);
Assert.True(OneS.GetLow64() == 0x0000000000000001UL);
Assert.True(R1S.GetSerializeSize(0, ProtocolVersion.PROTOCOL_VERSION) == 20);
Assert.True(ZeroS.GetSerializeSize(0, ProtocolVersion.PROTOCOL_VERSION) == 20);
R1S.Serialize(ss, 0, ProtocolVersion.PROTOCOL_VERSION);
Assert.True(ArrayToString(ss.ToArray()) == ArrayToString(R1Array.Take(20).ToArray()));
ss.Position = 0;
TmpS.Unserialize(ss, 0, ProtocolVersion.PROTOCOL_VERSION);
Assert.True(R1S == TmpS);
ss = new MemoryStream();
ZeroS.Serialize(ss, 0, ProtocolVersion.PROTOCOL_VERSION);
Assert.True(ArrayToString(ss.ToArray()) == ArrayToString(ZeroArray.Take(20).ToArray()));
ss.Position = 0;
TmpS.Unserialize(ss, 0, ProtocolVersion.PROTOCOL_VERSION);
Assert.True(ZeroS == TmpS);
ss = new MemoryStream();
MaxS.Serialize(ss, 0, ProtocolVersion.PROTOCOL_VERSION);
Assert.True(ArrayToString(ss.ToArray()) == ArrayToString(MaxArray.Take(20).ToArray()));
ss.Position = 0;
TmpS.Unserialize(ss, 0, ProtocolVersion.PROTOCOL_VERSION);
Assert.True(MaxS == TmpS);
ss = new MemoryStream();
//for(int i = 0 ; i < 255 ; ++i)
//{
// Assert.True((OneL << i).GetDouble() == Math.Pow(1.0, i));
// if(i < 160)
// Assert.True((OneS << i).GetDouble() == Math.Pow(1.0, i));
//}
//Assert.True(ZeroL.GetDouble() == 0.0);
//Assert.True(ZeroS.GetDouble() == 0.0);
//for(int i = 256 ; i > 53 ; --i)
// Assert.True(almostEqual((R1L >> (256 - i)).GetDouble(), Math.Pow(R1Ldouble, i)));
//for(int i = 160 ; i > 53 ; --i)
// Assert.True(almostEqual((R1S >> (160 - i)).GetDouble(), Math.Pow(R1Sdouble, i)));
//ulong R1L64part = (R1L >> 192).GetLow64();
//ulong R1S64part = (R1S >> 96).GetLow64();
//for(int i = 53 ; i > 0 ; --i) // doubles can store all integers in {0,...,2^54-1} exactly
//{
// Assert.True((R1L >> (256 - i)).GetDouble() == (double)(R1L64part >> (64 - i)));
// Assert.True((R1S >> (160 - i)).GetDouble() == (double)(R1S64part >> (64 - i)));
//}
}
public SolverServerSession GetSolverServerSession(int cycleId, uint160 channelId)
{
var session = Repository.Get <SolverServerSession.State>(GetCyclePartition(cycleId), channelId.ToString());
if (session == null)
{
return(null);
}
return(new SolverServerSession(_Network, _Runtime.TumblerKey,
_Runtime.ClassicTumblerParameters.CreateSolverParamaters(),
session));
}
public PromiseServerSession GetPromiseServerSession(int cycleId, uint160 channelId)
{
var session = Repository.Get <PromiseServerSession.State>(GetCyclePartition(cycleId), channelId.ToString());
if (session == null)
{
return(null);
}
return(new PromiseServerSession(session,
_Runtime.ClassicTumblerParameters.CreatePromiseParamaters()));
}
public override string ToString()
{
return(_Value.ToString());
}
public void basics()
{
//Assert.True(new uint256("ababdc10a3").ToString().EndsWith("0" + "ababdc10a3"));
Assert.True(1 == 0 + 1);
// constructor uint256(vector<char>):
Assert.True(R1L.ToString() == ArrayToString(R1Array));
Assert.True(R1S.ToString() == ArrayToString(R1Array.Take(20).ToArray()));
Assert.True(R2L.ToString() == ArrayToString(R2Array));
Assert.True(R2S.ToString() == ArrayToString(R2Array.Take(20).ToArray()));
Assert.True(ZeroL.ToString() == ArrayToString(ZeroArray));
Assert.True(ZeroS.ToString() == ArrayToString(ZeroArray.Take(20).ToArray()));
Assert.True(OneL.ToString() == ArrayToString(OneArray));
Assert.True(OneS.ToString() == ArrayToString(OneArray.Take(20).ToArray()));
Assert.True(MaxL.ToString() == ArrayToString(MaxArray));
Assert.True(MaxS.ToString() == ArrayToString(MaxArray.Take(20).ToArray()));
Assert.True(OneL.ToString() != ArrayToString(ZeroArray));
Assert.True(OneS.ToString() != ArrayToString(ZeroArray.Take(20).ToArray()));
Assert.True(R1L != R2L && R1S != R2S);
Assert.True(ZeroL != OneL && ZeroS != OneS);
Assert.True(OneL != ZeroL && OneS != ZeroS);
Assert.True(MaxL != ZeroL && MaxS != ZeroS);
Assert.True(~MaxL == ZeroL && ~MaxS == ZeroS);
Assert.True(((R1L ^ R2L) ^ R1L) == R2L);
Assert.True(((R1S ^ R2S) ^ R1S) == R2S);
ulong Tmp64 = 0xc4dab720d9c7acaaUL;
for (int i = 0; i < 256; ++i)
{
Assert.True(ZeroL != (OneL << i));
Assert.True((OneL << i) != ZeroL);
Assert.True(R1L != (R1L ^ (OneL << i)));
Assert.True(((new uint256(Tmp64) ^ (OneL << i)) != Tmp64));
}
Assert.True(ZeroL == (OneL << 256));
for (int i = 0; i < 160; ++i)
{
Assert.True(ZeroS != (OneS << i));
Assert.True((OneS << i) != ZeroS);
Assert.True(R1S != (R1S ^ (OneS << i)));
Assert.True(((new uint160(Tmp64) ^ (OneS << i)) != Tmp64));
}
Assert.True(ZeroS == (OneS << 256));
Assert.True(uint256.Parse("0x" + R1L.ToString()) == R1L);
Assert.True(uint256.Parse("0x" + R2L.ToString()) == R2L);
Assert.True(uint256.Parse("0x" + ZeroL.ToString()) == ZeroL);
Assert.True(uint256.Parse("0x" + OneL.ToString()) == OneL);
Assert.True(uint256.Parse("0x" + MaxL.ToString()) == MaxL);
Assert.True(uint256.Parse(R1L.ToString()) == R1L);
Assert.True(uint256.Parse(" 0x" + R1L.ToString() + " ") == R1L);
Assert.True(uint256.Parse("") == ZeroL);
Assert.True(R1L == uint256.Parse(R1ArrayHex));
Assert.True(new uint256(R1L) == R1L);
Assert.True((new uint256(R1L ^ R2L) ^ R2L) == R1L);
Assert.True(new uint256(ZeroL) == ZeroL);
Assert.True(new uint256(OneL) == OneL);
Assert.True(uint160.Parse("0x" + R1S.ToString()) == R1S);
Assert.True(uint160.Parse("0x" + R2S.ToString()) == R2S);
Assert.True(uint160.Parse("0x" + ZeroS.ToString()) == ZeroS);
Assert.True(uint160.Parse("0x" + OneS.ToString()) == OneS);
Assert.True(uint160.Parse("0x" + MaxS.ToString()) == MaxS);
Assert.True(uint160.Parse(R1S.ToString()) == R1S);
Assert.True(uint160.Parse(" 0x" + R1S.ToString() + " ") == R1S);
Assert.True(uint160.Parse("") == ZeroS);
Assert.True(R1S == uint160.Parse(R1ArrayHex));
Assert.True(new uint160(R1S) == R1S);
Assert.True((new uint160(R1S ^ R2S) ^ R2S) == R1S);
Assert.True(new uint160(ZeroS) == ZeroS);
Assert.True(new uint160(OneS) == OneS);
// uint64_t constructor
Assert.True((R1L & uint256.Parse("0xffffffffffffffff")) == new uint256(R1LLow64));
Assert.True(ZeroL == new uint256(0));
Assert.True(OneL == new uint256(1));
Assert.True(uint256.Parse("0xffffffffffffffff") == new uint256(0xffffffffffffffffUL));
Assert.True((R1S & uint160.Parse("0xffffffffffffffff")) == new uint160(R1LLow64));
Assert.True(ZeroS == new uint160(0));
Assert.True(OneS == new uint160(1));
Assert.True(uint160.Parse("0xffffffffffffffff") == new uint160(0xffffffffffffffffUL));
// Assignment (from base_uint)
uint256 tmpL = ~ZeroL;
Assert.True(tmpL == ~ZeroL);
tmpL = ~OneL;
Assert.True(tmpL == ~OneL);
tmpL = ~R1L;
Assert.True(tmpL == ~R1L);
tmpL = ~R2L;
Assert.True(tmpL == ~R2L);
tmpL = ~MaxL;
Assert.True(tmpL == ~MaxL);
uint160 tmpS = ~ZeroS;
Assert.True(tmpS == ~ZeroS);
tmpS = ~OneS;
Assert.True(tmpS == ~OneS);
tmpS = ~R1S;
Assert.True(tmpS == ~R1S);
tmpS = ~R2S;
Assert.True(tmpS == ~R2S);
tmpS = ~MaxS;
Assert.True(tmpS == ~MaxS);
// Wrong length must crash, probably a bug
Assert.Throws <FormatException>(() => Assert.True(new uint256(OneArray.Take(31).ToArray()) == 0));
Assert.Throws <FormatException>(() => new uint256(OneArray.Take(20).ToArray()) == 0);
Assert.Throws <FormatException>(() => new uint160(OneArray.Take(32).ToArray()) == 0);
Assert.Throws <FormatException>(() => new uint160(OneArray.Take(19).ToArray()) == 0);
}
public Preimage GetPreimage(uint160 hash)
{
return(new Preimage(_Repo.Get <byte[]>("1", hash.ToString())));
}
