public void GetSigOpCount() { // Test CScript::GetSigOpCount() Script s1 = new Script(); Assert.Equal(s1.GetSigOpCount(false), 0U); Assert.Equal(s1.GetSigOpCount(true), 0U); uint160 dummy = new uint160(0); s1 = s1 + OpcodeType.OP_1 + dummy.ToBytes() + dummy.ToBytes() + OpcodeType.OP_2 + OpcodeType.OP_CHECKMULTISIG; Assert.Equal(s1.GetSigOpCount(true), 2U); s1 = s1 + OpcodeType.OP_IF + OpcodeType.OP_CHECKSIG + OpcodeType.OP_ENDIF; Assert.Equal(s1.GetSigOpCount(true), 3U); Assert.Equal(s1.GetSigOpCount(false), 21U); Script p2sh = PayToScriptHashTemplate.Instance.GenerateScriptPubKey(s1); Script scriptSig = PayToScriptHashTemplate.Instance.GenerateScriptSig(new[] { (Op)OpcodeType.OP_0 }, s1); Assert.Equal(p2sh.GetSigOpCount(scriptSig), 3U); PubKey[] keys = Enumerable.Range(0, 3).Select(_ => new Key(true).PubKey).ToArray(); Script s2 = PayToMultiSigTemplate.Instance.GenerateScriptPubKey(1, keys); Assert.Equal(s2.GetSigOpCount(true), 3U); Assert.Equal(s2.GetSigOpCount(false), 20U); p2sh = PayToScriptHashTemplate.Instance.GenerateScriptPubKey(s2); Assert.Equal(p2sh.GetSigOpCount(true), 0U); Assert.Equal(p2sh.GetSigOpCount(false), 0U); Script scriptSig2 = new Script(); scriptSig2 = scriptSig2 + OpcodeType.OP_1 + dummy.ToBytes() + dummy.ToBytes() + s2.ToBytes(); Assert.Equal(p2sh.GetSigOpCount(scriptSig2), 3U); }
public void SetUnspent(uint160 address, ContractUnspentOutput vin) { byte[] vinHash = Hashing.HashHelper.Keccak256(vin.ToBytes()); this.vinCache.Put(vinHash, vin); AccountState accountState = this.GetOrCreateAccountState(address); accountState.UnspentHash = vinHash; this.accountStateCache.Put(address.ToBytes(), accountState); this.vinCache.Put(address.ToBytes(), vin); }
public void SetContractType(uint160 addr, string type) { AccountState accountState = this.GetOrCreateAccountState(addr); accountState.TypeName = type; this.accountStateCache.Put(addr.ToBytes(), accountState); }
public bool Verify(byte[] signature, byte[] data, uint160 nonce) { byte[] output = new byte[256]; var msg = Utils.Combine(nonce.ToBytes(), data); Sha512Digest sha512 = new Sha512Digest(); var generator = new Mgf1BytesGenerator(sha512); generator.Init(new MgfParameters(msg)); generator.GenerateBytes(output, 0, output.Length); var input = new BigInteger(1, output); if (input.CompareTo(_Key.Modulus) >= 0) { return(false); } if (signature.Length > 256) { return(false); } var signatureInt = new BigInteger(1, signature); if (signatureInt.CompareTo(_Key.Modulus) >= 0) { return(false); } var engine = new RsaBlindedEngine(); engine.Init(false, _Key); return(input.Equals(engine.ProcessBlock(signatureInt))); }
public AccountState CreateAccount(uint160 addr) { AccountState state = new AccountState(); this.accountStateCache.Put(addr.ToBytes(), state); return(state); }
public void SetStorageValue(uint160 addr, byte[] key, byte[] value) { this.GetOrCreateAccountState(addr); ISource <byte[], byte[]> contractStorage = this.storageCache.Get(addr.ToBytes()); contractStorage.Put(key, value); // TODO: Check if 0 }
public void Test_Returns_False_When_Address_Not_Null_Topics_Not_Null() { var address = new uint160(1); var topics = new List <byte[]> { new byte[] { 0xAA, 0xAA, 0xAA }, new byte[] { 0xBB, 0xBB, 0xBB }, new byte[] { 0xCC, 0xCC, 0xCC } }; var bloom = new Bloom(); bloom.Add(address.ToBytes()); foreach (var topic in topics) { bloom.Add(topic); } var address2 = new uint160(2); Assert.False(bloom.Test(address2)); Assert.False(bloom.Test(address2, new[] { topics[0] })); Assert.False(bloom.Test(address2, new[] { topics[1] })); Assert.False(bloom.Test(address2, new[] { topics[2] })); }
public void Test_CatCreation() { using (PoWMockChain chain = new PoWMockChain(2)) { MockChainNode sender = chain.Nodes[0]; MockChainNode receiver = chain.Nodes[1]; sender.MineBlocks(1); ContractCompilationResult compilationResult = ContractCompiler.CompileFile("SmartContracts/ContractCreation.cs"); Assert.True(compilationResult.Success); // Create contract and ensure code exists BuildCreateContractTransactionResponse response = sender.SendCreateContractTransaction(compilationResult.Compilation, 0); receiver.WaitMempoolCount(1); receiver.MineBlocks(2); Assert.NotNull(receiver.GetCode(response.NewContractAddress)); Assert.NotNull(sender.GetCode(response.NewContractAddress)); // Call contract and ensure internal contract was created. BuildCallContractTransactionResponse callResponse = sender.SendCallContractTransaction("CreateCat", response.NewContractAddress, 0); receiver.WaitMempoolCount(1); receiver.MineBlocks(1); Assert.Equal(1, BitConverter.ToInt32(sender.GetStorageValue(response.NewContractAddress, "CatCounter"))); uint160 lastCreatedCatAddress = new uint160(sender.GetStorageValue(response.NewContractAddress, "LastCreatedCat")); uint160 expectedCreatedCatAddress = this.addressGenerator.GenerateAddress(callResponse.TransactionId, 0); Assert.Equal(expectedCreatedCatAddress, lastCreatedCatAddress); // Test that the contract address, event name, and logging values are available in the bloom, from internal create. var scBlockHeader = receiver.GetLastBlock().Header as SmartContractBlockHeader; Assert.True(scBlockHeader.LogsBloom.Test(lastCreatedCatAddress.ToBytes())); Assert.True(scBlockHeader.LogsBloom.Test(Encoding.UTF8.GetBytes("CatCreated"))); Assert.True(scBlockHeader.LogsBloom.Test(BitConverter.GetBytes(0))); // And sanity test that a random value is not available in bloom. Assert.False(scBlockHeader.LogsBloom.Test(Encoding.UTF8.GetBytes("RandomValue"))); // Do a create that should transfer all funds sent now. decimal amount = 20; BuildCallContractTransactionResponse callResponse2 = sender.SendCallContractTransaction("CreateCatWithFunds", response.NewContractAddress, amount); receiver.WaitMempoolCount(1); receiver.MineBlocks(1); // Check created contract has expected balance. lastCreatedCatAddress = new uint160(sender.GetStorageValue(response.NewContractAddress, "LastCreatedCat")); Assert.Equal(amount * Money.COIN, sender.GetContractBalance(lastCreatedCatAddress.ToBase58Address(sender.CoreNode.FullNode.Network))); // Check block has 3 transactions. Coinbase, our tx, and then a condensing tx. var block = receiver.GetLastBlock(); Assert.Equal(3, block.Transactions.Count); // Condensing tx has 1 input and 1 output - FROM: real tx. TO: new contract address. Assert.Single(block.Transactions[2].Inputs); Assert.Single(block.Transactions[2].Outputs); Assert.Equal(block.Transactions[1].GetHash(), block.Transactions[2].Inputs[0].PrevOut.Hash); // References tx above. Assert.Equal(amount * Money.COIN, (ulong)block.Transactions[2].Outputs[0].Value); Assert.True(block.Transactions[2].Inputs[0].ScriptSig.IsSmartContractSpend()); Assert.True(block.Transactions[2].Outputs[0].ScriptPubKey.IsSmartContractInternalCall()); } }
public void ClearUnspent(uint160 address) { AccountState accountState = this.GetOrCreateAccountState(address); accountState.UnspentHash = null; this.accountStateCache.Put(address.ToBytes(), accountState); // TODO: Delete old unspent from cache? }
public void SetCode(uint160 addr, byte[] code) { byte[] codeHash = Hashing.HashHelper.Keccak256(code); this.codeCache.Put(codeHash, code); AccountState accountState = this.GetOrCreateAccountState(addr); accountState.CodeHash = codeHash; this.accountStateCache.Put(addr.ToBytes(), accountState); }
private AccountState GetOrCreateAccountState(uint160 addr) { AccountState ret = this.accountStateCache.Get(addr.ToBytes()); if (ret == null) { ret = this.CreateAccount(addr); } return(ret); }
public void Test_Returns_True_When_Address_Not_Null_Topics_Null() { var address = new uint160(1); var bloom = new Bloom(); bloom.Add(address.ToBytes()); Assert.True(bloom.Test(address, null)); }
private List <Receipt> SearchReceipts(string contractAddress, string eventName) { // Build the bytes we can use to check for this event. uint160 addressUint160 = contractAddress.ToUint160(this.network); byte[] addressBytes = addressUint160.ToBytes(); byte[] eventBytes = Encoding.UTF8.GetBytes(eventName); // Loop through all headers and check bloom. IEnumerable <ChainedHeader> blockHeaders = this.chainIndexer.EnumerateToTip(this.chainIndexer.Genesis); List <ChainedHeader> matches = new List <ChainedHeader>(); foreach (ChainedHeader chainedHeader in blockHeaders) { var scHeader = (ISmartContractBlockHeader)chainedHeader.Header; if (scHeader.LogsBloom.Test(addressBytes) && scHeader.LogsBloom.Test(eventBytes)) // TODO: This is really inefficient, should build bloom for query and then compare. { matches.Add(chainedHeader); } } // For all matching headers, get the block from local db. List <NBitcoin.Block> blocks = new List <NBitcoin.Block>(); foreach (ChainedHeader chainedHeader in matches) { blocks.Add(this.blockStore.GetBlock(chainedHeader.HashBlock)); } // For each block, get all receipts, and if they match, add to list to return. List <Receipt> receiptResponses = new List <Receipt>(); foreach (NBitcoin.Block block in blocks) { foreach (Transaction transaction in block.Transactions) { Receipt storedReceipt = this.receiptRepository.Retrieve(transaction.GetHash()); if (storedReceipt == null) // not a smart contract transaction. Move to next transaction. { continue; } // Check if address and first topic (event name) match. if (storedReceipt.Logs.Any(x => x.Address == addressUint160 && Enumerable.SequenceEqual(x.Topics[0], eventBytes))) { receiptResponses.Add(storedReceipt); } } } return(receiptResponses); }
public void ContractExecutionResult_RefundDue_AdjustFee() { var contractAddress = new uint160(1); var contractTxData = new ContractTxData(1, 1, (Gas)5000, contractAddress, "ThrowException"); var sender = new uint160(2); (Money fee, TxOut refund) = this.refundProcessor.Process(contractTxData, new Money(10500), sender, (Gas)950, false); Assert.Equal(6450, fee); Assert.Equal(sender.ToBytes(), refund.ScriptPubKey.GetDestination(this.network).ToBytes()); Assert.Equal(4050, refund.Value); }
public void GetSigOpCount() { // Test CScript::GetSigOpCount() Script s1 = new Script(); Assert.Equal(s1.GetSigOpCount(false), 0U); Assert.Equal(s1.GetSigOpCount(true), 0U); uint160 dummy = new uint160(0); s1 = s1 + OpcodeType.OP_1 + dummy.ToBytes() + dummy.ToBytes() + OpcodeType.OP_2 + OpcodeType.OP_CHECKMULTISIG; Assert.Equal(s1.GetSigOpCount(true), 2U); s1 = s1 + OpcodeType.OP_IF + OpcodeType.OP_CHECKSIG + OpcodeType.OP_ENDIF; Assert.Equal(s1.GetSigOpCount(true), 3U); Assert.Equal(s1.GetSigOpCount(false), 21U); var payToScript = new PayToScriptHashTemplate(); Script p2sh = payToScript.GenerateScriptPubKey(s1); Script scriptSig = payToScript.GenerateScriptSig(new[] { (Op)OpcodeType.OP_0 }, s1); Assert.Equal(p2sh.GetSigOpCount(scriptSig), 3U); var multiSig = new PayToMultiSigTemplate(); PubKey[] keys = Enumerable.Range(0, 3).Select(_ => new Key(true).PubKey).ToArray(); Script s2 = multiSig.GenerateScriptPubKey(1, keys); Assert.Equal(s2.GetSigOpCount(true), 3U); Assert.Equal(s2.GetSigOpCount(false), 20U); p2sh = payToScript.GenerateScriptPubKey(s2); Assert.Equal(p2sh.GetSigOpCount(true), 0U); Assert.Equal(p2sh.GetSigOpCount(false), 0U); Script scriptSig2 = new Script(); scriptSig2 = scriptSig2 + OpcodeType.OP_1 + dummy.ToBytes() + dummy.ToBytes() + s2.ToRawScript(); Assert.Equal(p2sh.GetSigOpCount(scriptSig2), 3U); }
public void GetSigOpCount() { // Test CScript::GetSigOpCount() var s1 = new Script(); Assert.Equal(0U, s1.GetSigOpCount(false)); Assert.Equal(0U, s1.GetSigOpCount(true)); var dummy = new uint160(0); s1 = s1 + OpcodeType.OP_1 + dummy.ToBytes() + dummy.ToBytes() + OpcodeType.OP_2 + OpcodeType.OP_CHECKMULTISIG; Assert.Equal(2U, s1.GetSigOpCount(true)); s1 = s1 + OpcodeType.OP_IF + OpcodeType.OP_CHECKSIG + OpcodeType.OP_ENDIF; Assert.Equal(3U, s1.GetSigOpCount(true)); Assert.Equal(21U, s1.GetSigOpCount(false)); Script p2sh = PayToScriptHashTemplate.Instance.GenerateScriptPubKey(s1); Script scriptSig = PayToScriptHashTemplate.Instance.GenerateScriptSig(new[] { (Op)OpcodeType.OP_0 }, s1); Assert.Equal(3U, p2sh.GetSigOpCount(KnownNetworks.Main, scriptSig)); PubKey[] keys = Enumerable.Range(0, 3).Select(_ => new Key(true).PubKey).ToArray(); Script s2 = PayToMultiSigTemplate.Instance.GenerateScriptPubKey(1, keys); Assert.Equal(3U, s2.GetSigOpCount(true)); Assert.Equal(20U, s2.GetSigOpCount(false)); p2sh = PayToScriptHashTemplate.Instance.GenerateScriptPubKey(s2); Assert.Equal(0U, p2sh.GetSigOpCount(true)); Assert.Equal(0U, p2sh.GetSigOpCount(false)); var scriptSig2 = new Script(); scriptSig2 = scriptSig2 + OpcodeType.OP_1 + dummy.ToBytes() + dummy.ToBytes() + s2.ToBytes(); Assert.Equal(3U, p2sh.GetSigOpCount(KnownNetworks.Main, scriptSig2)); }
public SmartContractReceipt( uint256 txHash, ulong blockHeight, uint160 newContractAddress, ulong gasConsumed, bool successful, Exception exception, object returned) { this.TxHash = txHash.ToBytes(); // Can't be null as it's used as the key anyhow. this.BlockHeight = blockHeight; this.NewContractAddress = newContractAddress?.ToBytes(); this.GasConsumed = gasConsumed; this.Successful = successful; this.Exception = exception?.ToString(); this.Returned = returned?.ToString(); }
/// <summary> /// Serializes object to a binary data format. /// </summary> /// <param name="obj">Object to be serialized.</param> /// <returns>Binary data representing the serialized object.</returns> internal byte[] Serializer(object obj) { IBitcoinSerializable serializable = obj as IBitcoinSerializable; if (serializable != null) { return(serializable.ToBytes(network: this.Network)); } uint256 u256 = obj as uint256; if (u256 != null) { return(u256.ToBytes()); } uint160 u160 = obj as uint160; if (u160 != null) { return(u160.ToBytes()); } uint?u32 = obj as uint?; if (u32 != null) { return(u32.ToBytes()); } object[] arr = obj as object[]; if (arr != null) { byte[][] serializedItems = new byte[arr.Length][]; int itemIndex = 0; foreach (object arrayObject in arr) { byte[] serializedObject = this.Serializer(arrayObject); serializedItems[itemIndex] = serializedObject; itemIndex++; } return(ConcatArrays(serializedItems)); } throw new NotSupportedException(); }
/// <summary> /// Gets the script used to 'send' an address funds, depending on whether it's a contract or non-contract. /// </summary> /// <param name="address">The address of the receiver.</param> private Script GetTxOutScriptForAddress(uint160 address) { AccountState accountState = this.stateRepository.GetAccountState(address); if (accountState != null) { var s = new List <byte> { (byte)ScOpcodeType.OP_INTERNALCONTRACTTRANSFER }; s.AddRange(address.ToBytes()); return(new Script(s)); } return(this.CreateScript(address)); }
public byte[] Sign(byte[] data, out uint160 nonce) { while (true) { byte[] output = new byte[256]; nonce = new uint160(RandomUtils.GetBytes(20)); Sha512Digest sha512 = new Sha512Digest(); var msg = Utils.Combine(nonce.ToBytes(), data); var generator = new Mgf1BytesGenerator(sha512); generator.Init(new MgfParameters(msg)); generator.GenerateBytes(output, 0, output.Length); var input = new BigInteger(1, output); if (input.CompareTo(_Key.Modulus) >= 0) { continue; } var engine = new RsaCoreEngine(); engine.Init(true, _Key); return(engine.ConvertOutput(engine.ProcessBlock(input))); } }
public void Test_CatCreation() { using (MockChain chain = new MockChain(2)) { MockChainNode sender = chain.Nodes[0]; MockChainNode receiver = chain.Nodes[1]; sender.MineBlocks(10); SmartContractCompilationResult compilationResult = SmartContractCompiler.CompileFile("SmartContracts/ContractCreation.cs"); Assert.True(compilationResult.Success); // Create contract and ensure code exists BuildCreateContractTransactionResponse response = sender.SendCreateContractTransaction(compilationResult.Compilation); receiver.WaitMempoolCount(1); receiver.MineBlocks(2); Assert.NotNull(receiver.GetCode(response.NewContractAddress)); Assert.NotNull(sender.GetCode(response.NewContractAddress)); // Call contract and ensure internal contract was created. BuildCallContractTransactionResponse callResponse = sender.SendCallContractTransaction("CreateCat", response.NewContractAddress, 0); receiver.WaitMempoolCount(1); receiver.MineBlocks(1); Assert.Equal(1, BitConverter.ToInt32(sender.GetStorageValue(response.NewContractAddress, "CatCounter"))); uint160 lastCreatedCatAddress = new uint160(sender.GetStorageValue(response.NewContractAddress, "LastCreatedCat")); uint160 expectedCreatedCatAddress = this.addressGenerator.GenerateAddress(callResponse.TransactionId, 0); Assert.Equal(expectedCreatedCatAddress, lastCreatedCatAddress); // Test that the contract address, event name, and logging values are available in the bloom, from internal create. var scBlockHeader = receiver.GetLastBlock().Header as SmartContractBlockHeader; Assert.True(scBlockHeader.LogsBloom.Test(lastCreatedCatAddress.ToBytes())); Assert.True(scBlockHeader.LogsBloom.Test(Encoding.UTF8.GetBytes("CatCreated"))); Assert.True(scBlockHeader.LogsBloom.Test(BitConverter.GetBytes(0))); // And sanity test that a random value is not available in bloom. Assert.False(scBlockHeader.LogsBloom.Test(Encoding.UTF8.GetBytes("RandomValue"))); } }
/// <summary> /// Serializes object to a binary data format. /// </summary> /// <param name="obj">Object to be serialized.</param> /// <returns>Binary data representing the serialized object.</returns> internal static byte[] NBitcoinSerialize(object obj) { IBitcoinSerializable serializable = obj as IBitcoinSerializable; if (serializable != null) { return(serializable.ToBytes()); } uint256 u256 = obj as uint256; if (u256 != null) { return(u256.ToBytes()); } uint160 u160 = obj as uint160; if (u160 != null) { return(u160.ToBytes()); } uint?u32 = obj as uint?; if (u32 != null) { return(u32.ToBytes()); } object[] a = obj as object[]; if (a != null) { var result = (from x in a select NBitcoinSerialize(x)).ToArray().SelectMany(x => x).ToArray(); return(result); } throw new NotSupportedException(); }
public byte[] ToBytes() { return(_Id.ToBytes()); }
public AssetId(uint160 value) : this(value.ToBytes()) { _value = value; }
public void Delete(uint160 addr) { this.accountStateCache.Delete(addr.ToBytes()); this.storageCache.Delete(addr.ToBytes()); }
public void methods() { Assert.True(R1L.ToString() == R1L.ToString()); Assert.True(R2L.ToString() == R2L.ToString()); Assert.True(OneL.ToString() == OneL.ToString()); Assert.True(MaxL.ToString() == 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.ReadWrite(ss, true, ProtocolVersion.PROTOCOL_VERSION); Assert.True(ArrayToString(ss.ToArray()) == ArrayToString(R1Array)); ss.Position = 0; TmpL.ReadWrite(ss, false, ProtocolVersion.PROTOCOL_VERSION); Assert.True(R1L == TmpL); ss = new MemoryStream(); ZeroL.ReadWrite(ss, true, ProtocolVersion.PROTOCOL_VERSION); Assert.True(ArrayToString(ss.ToArray()) == ArrayToString(ZeroArray)); ss.Position = 0; TmpL.ReadWrite(ss, false, ProtocolVersion.PROTOCOL_VERSION); Assert.True(ZeroL == TmpL); ss = new MemoryStream(); MaxL.ReadWrite(ss, true, ProtocolVersion.PROTOCOL_VERSION); Assert.True(ArrayToString(ss.ToArray()) == ArrayToString(MaxArray)); ss.Position = 0; TmpL.ReadWrite(ss, false, ProtocolVersion.PROTOCOL_VERSION); Assert.True(MaxL == TmpL); ss = new MemoryStream(); 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.ReadWrite(ss, true, ProtocolVersion.PROTOCOL_VERSION); Assert.True(ArrayToString(ss.ToArray()) == ArrayToString(R1Array.Take(20).ToArray())); ss.Position = 0; TmpS.ReadWrite(ss, false, ProtocolVersion.PROTOCOL_VERSION); Assert.True(R1S == TmpS); ss = new MemoryStream(); ZeroS.ReadWrite(ss, true, ProtocolVersion.PROTOCOL_VERSION); Assert.True(ArrayToString(ss.ToArray()) == ArrayToString(ZeroArray.Take(20).ToArray())); ss.Position = 0; TmpS.ReadWrite(ss, false, ProtocolVersion.PROTOCOL_VERSION); Assert.True(ZeroS == TmpS); ss = new MemoryStream(); MaxS.ReadWrite(ss, true, ProtocolVersion.PROTOCOL_VERSION); Assert.True(ArrayToString(ss.ToArray()) == ArrayToString(MaxArray.Take(20).ToArray())); ss.Position = 0; TmpS.ReadWrite(ss, false, 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 AccountState GetAccountState(uint160 addr) { return(this.accountStateCache.Get(addr.ToBytes())); }
public KeyId(uint160 value) { _DestBytes = value.ToBytes(); }
public static Address ToAddress(this uint160 address) { return(Address.Create(address.ToBytes())); }
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 byte[] GetStorageValue(uint160 addr, byte[] key) { AccountState accountState = this.GetAccountState(addr); return(accountState == null ? null : this.storageCache.Get(addr.ToBytes()).Get(key)); }