public void TestRoots()
{
var snapshot = _snapshot.Clone();
var persistingBlock = new Block()
{
Index = 1000
};
var from = NativeContract.NEO.GetCommitteeAddress(snapshot);
// no match
var result = Check_AddRoot(snapshot, from, "te_st", persistingBlock);
Assert.IsFalse(result);
// unsigned
result = Check_AddRoot(snapshot, UInt160.Zero, "test", persistingBlock);
Assert.IsFalse(result);
// add root
result = Check_AddRoot(snapshot, from, "test", persistingBlock);
Assert.IsTrue(result);
CollectionAssert.AreEqual(new string[] { "test" }, NativeContract.NameService.GetRoots(snapshot).ToArray());
// add root twice
result = Check_AddRoot(snapshot, from, "test", persistingBlock);
Assert.IsFalse(result);
}
public void Check_Default()
{
var snapshot = _snapshot.Clone();
var ret = NativeContract.Policy.Call(snapshot, "getMaxTransactionsPerBlock");
ret.Should().BeOfType <VM.Types.Integer>();
ret.GetInteger().Should().Be(512);
ret = NativeContract.Policy.Call(snapshot, "getMaxBlockSize");
ret.Should().BeOfType <VM.Types.Integer>();
ret.GetInteger().Should().Be(1024 * 256);
ret = NativeContract.Policy.Call(snapshot, "getMaxBlockSystemFee");
ret.Should().BeOfType <VM.Types.Integer>();
ret.GetInteger().Should().Be(9000 * 100000000L);
ret = NativeContract.Policy.Call(snapshot, "getFeePerByte");
ret.Should().BeOfType <VM.Types.Integer>();
ret.GetInteger().Should().Be(1000);
}
internal static bool VerifyWitness(this IVerifiable verifiable, StoreView snapshot, UInt160 hash, Witness witness, long gas, out long fee)
{
fee = 0;
using (ApplicationEngine engine = ApplicationEngine.Create(TriggerType.Verification, verifiable, snapshot?.Clone(), null, gas))
{
CallFlags callFlags = !witness.VerificationScript.IsStandardContract() ? CallFlags.ReadStates : CallFlags.None;
byte[] verification = witness.VerificationScript;
if (verification.Length == 0)
{
ContractState cs = NativeContract.ContractManagement.GetContract(snapshot, hash);
if (cs is null)
{
return(false);
}
if (engine.LoadContract(cs, "verify", callFlags, true, 0) is null)
{
return(false);
}
}
else
{
if (NativeContract.IsNative(hash))
{
return(false);
}
if (hash != witness.ScriptHash)
{
return(false);
}
engine.LoadScript(verification, initialPosition: 0, configureState: p =>
{
p.CallFlags = callFlags;
p.ScriptHash = hash;
});
}
engine.LoadScript(witness.InvocationScript, configureState: p => p.CallFlags = CallFlags.None);
if (NativeContract.IsNative(hash))
{
try
{
engine.StepOut();
engine.Push("verify");
}
catch { }
}
if (engine.Execute() == VMState.FAULT)
{
return(false);
}
if (!engine.ResultStack.Peek().GetBoolean())
{
return(false);
}
fee = engine.GasConsumed;
}
return(true);
}
internal static bool VerifyWitnesses(this IVerifiable verifiable, StoreView snapshot, long gas, WitnessFlag filter = WitnessFlag.All)
{
if (gas < 0)
{
return(false);
}
if (gas > MaxVerificationGas)
{
gas = MaxVerificationGas;
}
UInt160[] hashes;
try
{
hashes = verifiable.GetScriptHashesForVerifying(snapshot);
}
catch (InvalidOperationException)
{
return(false);
}
if (hashes.Length != verifiable.Witnesses.Length)
{
return(false);
}
for (int i = 0; i < hashes.Length; i++)
{
WitnessFlag flag = verifiable.Witnesses[i].StateDependent ? WitnessFlag.StateDependent : WitnessFlag.StateIndependent;
if (!filter.HasFlag(flag))
{
gas -= verifiable.Witnesses[i].GasConsumed;
if (gas < 0)
{
return(false);
}
continue;
}
using (ApplicationEngine engine = ApplicationEngine.Create(TriggerType.Verification, verifiable, snapshot?.Clone(), gas))
{
CallFlags callFlags = verifiable.Witnesses[i].StateDependent ? CallFlags.AllowStates : CallFlags.None;
byte[] verification = verifiable.Witnesses[i].VerificationScript;
if (verification.Length == 0)
{
ContractState cs = snapshot.Contracts.TryGet(hashes[i]);
if (cs is null)
{
return(false);
}
if (engine.LoadContract(cs, "verify", callFlags, true) is null)
{
return(false);
}
}
else
{
if (NativeContract.IsNative(hashes[i]))
{
return(false);
}
if (hashes[i] != verifiable.Witnesses[i].ScriptHash)
{
return(false);
}
engine.LoadScript(verification, callFlags, hashes[i], 0);
}
engine.LoadScript(verifiable.Witnesses[i].InvocationScript, CallFlags.None);
if (engine.Execute() == VMState.FAULT)
{
return(false);
}
if (engine.ResultStack.Count != 1 || !engine.ResultStack.Pop().GetBoolean())
{
return(false);
}
gas -= engine.GasConsumed;
verifiable.Witnesses[i].GasConsumed = engine.GasConsumed;
}
}
return(true);
}
public void TestSetAndGet()
{
var snapshot1 = _snapshot.Clone();
snapshot1.PersistingBlock = new Block
{
Index = 0,
};
UInt160 committeeMultiSigAddr = NativeContract.NEO.GetCommitteeAddress(snapshot1);
ECPoint[] validators = NativeContract.NEO.ComputeNextBlockValidators(snapshot1);
var ret = NativeContract.Designate.Call(
snapshot1,
new Nep17NativeContractExtensions.ManualWitness(committeeMultiSigAddr),
"designateAsRole",
new ContractParameter(ContractParameterType.Integer)
{
Value = new BigInteger((int)Role.StateValidator)
},
new ContractParameter(ContractParameterType.Array)
{
Value = validators.Select(p => new ContractParameter(ContractParameterType.ByteArray)
{
Value = p.ToArray()
}).ToList()
}
);
snapshot1.Commit();
var snapshot2 = _snapshot.Clone();
ret = NativeContract.Designate.Call(
snapshot2,
"getDesignatedByRole",
new ContractParameter(ContractParameterType.Integer)
{
Value = new BigInteger((int)Role.StateValidator)
},
new ContractParameter(ContractParameterType.Integer)
{
Value = new BigInteger(1u)
}
);
ret.Should().BeOfType <VM.Types.Array>();
(ret as VM.Types.Array).Count.Should().Be(7);
(ret as VM.Types.Array)[0].GetSpan().ToHexString().Should().Be(validators[0].ToArray().ToHexString());
(ret as VM.Types.Array)[1].GetSpan().ToHexString().Should().Be(validators[1].ToArray().ToHexString());
(ret as VM.Types.Array)[2].GetSpan().ToHexString().Should().Be(validators[2].ToArray().ToHexString());
(ret as VM.Types.Array)[3].GetSpan().ToHexString().Should().Be(validators[3].ToArray().ToHexString());
(ret as VM.Types.Array)[4].GetSpan().ToHexString().Should().Be(validators[4].ToArray().ToHexString());
(ret as VM.Types.Array)[5].GetSpan().ToHexString().Should().Be(validators[5].ToArray().ToHexString());
(ret as VM.Types.Array)[6].GetSpan().ToHexString().Should().Be(validators[6].ToArray().ToHexString());
ret = NativeContract.Designate.Call(
snapshot2,
"getDesignatedByRole",
new ContractParameter(ContractParameterType.Integer)
{
Value = new BigInteger((int)Role.StateValidator)
},
new ContractParameter(ContractParameterType.Integer)
{
Value = new BigInteger(0)
}
);
ret.Should().BeOfType <VM.Types.Array>();
(ret as VM.Types.Array).Count.Should().Be(0);
}
public void Check_BalanceOfTransferAndBurn()
{
var snapshot = _snapshot.Clone();
var persistingBlock = new Block()
{
Index = 1000
};
byte[] from = Blockchain.GetConsensusAddress(Blockchain.StandbyValidators).ToArray();
byte[] to = new byte[20];
var keyCount = snapshot.Storages.GetChangeSet().Count();
var supply = NativeContract.GAS.TotalSupply(snapshot);
supply.Should().Be(3000000050000000); // 3000000000000000 + 50000000 (neo holder reward)
// Check unclaim
var unclaim = UT_NeoToken.Check_UnclaimedGas(snapshot, from, persistingBlock);
unclaim.Value.Should().Be(new BigInteger(0.5 * 1000 * 100000000L));
unclaim.State.Should().BeTrue();
// Transfer
NativeContract.NEO.Transfer(snapshot, from, to, BigInteger.Zero, true, persistingBlock).Should().BeTrue();
NativeContract.NEO.BalanceOf(snapshot, from).Should().Be(100000000);
NativeContract.NEO.BalanceOf(snapshot, to).Should().Be(0);
NativeContract.GAS.BalanceOf(snapshot, from).Should().Be(30000500_00000000);
NativeContract.GAS.BalanceOf(snapshot, to).Should().Be(0);
// Check unclaim
unclaim = UT_NeoToken.Check_UnclaimedGas(snapshot, from, persistingBlock);
unclaim.Value.Should().Be(new BigInteger(0));
unclaim.State.Should().BeTrue();
supply = NativeContract.GAS.TotalSupply(snapshot);
supply.Should().Be(3000050050000000);
snapshot.Storages.GetChangeSet().Count().Should().Be(keyCount + 3); // Gas
// Transfer
keyCount = snapshot.Storages.GetChangeSet().Count();
NativeContract.GAS.Transfer(snapshot, from, to, 30000500_00000000, false, persistingBlock).Should().BeFalse(); // Not signed
NativeContract.GAS.Transfer(snapshot, from, to, 30000500_00000001, true, persistingBlock).Should().BeFalse(); // More than balance
NativeContract.GAS.Transfer(snapshot, from, to, 30000500_00000000, true, persistingBlock).Should().BeTrue(); // All balance
// Balance of
NativeContract.GAS.BalanceOf(snapshot, to).Should().Be(30000500_00000000);
NativeContract.GAS.BalanceOf(snapshot, from).Should().Be(0);
snapshot.Storages.GetChangeSet().Count().Should().Be(keyCount + 1); // All
// Burn
using var engine = ApplicationEngine.Create(TriggerType.Application, null, snapshot, persistingBlock, 0);
keyCount = snapshot.Storages.GetChangeSet().Count();
Assert.ThrowsException <ArgumentOutOfRangeException>(() =>
NativeContract.GAS.Burn(engine, new UInt160(to), BigInteger.MinusOne));
// Burn more than expected
Assert.ThrowsException <InvalidOperationException>(() =>
NativeContract.GAS.Burn(engine, new UInt160(to), new BigInteger(30000500_00000001)));
// Real burn
NativeContract.GAS.Burn(engine, new UInt160(to), new BigInteger(1));
NativeContract.GAS.BalanceOf(snapshot, to).Should().Be(3000049999999999);
keyCount.Should().Be(snapshot.Storages.GetChangeSet().Count());
// Burn all
NativeContract.GAS.Burn(engine, new UInt160(to), new BigInteger(3000049999999999));
(keyCount - 1).Should().Be(snapshot.Storages.GetChangeSet().Count());
// Bad inputs
NativeContract.GAS.Transfer(snapshot, from, to, BigInteger.MinusOne, true, persistingBlock).Should().BeFalse();
NativeContract.GAS.Transfer(snapshot, new byte[19], to, BigInteger.One, false, persistingBlock).Should().BeFalse();
NativeContract.GAS.Transfer(snapshot, from, new byte[19], BigInteger.One, false, persistingBlock).Should().BeFalse();
}
internal static bool VerifyWitnesses(this IVerifiable verifiable, StoreView snapshot, long gas, WitnessFlag filter = WitnessFlag.All)
{
if (gas < 0)
{
return(false);
}
if (gas > MaxVerificationGas)
{
gas = MaxVerificationGas;
}
UInt160[] hashes;
try
{
hashes = verifiable.GetScriptHashesForVerifying(snapshot);
}
catch (InvalidOperationException)
{
return(false);
}
if (hashes.Length != verifiable.Witnesses.Length)
{
return(false);
}
for (int i = 0; i < hashes.Length; i++)
{
WitnessFlag flag = verifiable.Witnesses[i].StateDependent ? WitnessFlag.StateDependent : WitnessFlag.StateIndependent;
if (!filter.HasFlag(flag))
{
gas -= verifiable.Witnesses[i].GasConsumed;
if (gas < 0)
{
return(false);
}
continue;
}
int offset;
ContractMethodDescriptor init = null;
byte[] verification = verifiable.Witnesses[i].VerificationScript;
if (verification.Length == 0)
{
ContractState cs = snapshot.Contracts.TryGet(hashes[i]);
if (cs is null)
{
return(false);
}
ContractMethodDescriptor md = cs.Manifest.Abi.GetMethod("verify");
if (md is null)
{
return(false);
}
verification = cs.Script;
offset = md.Offset;
init = cs.Manifest.Abi.GetMethod("_initialize");
}
else
{
if (NativeContract.IsNative(hashes[i]))
{
return(false);
}
if (hashes[i] != verifiable.Witnesses[i].ScriptHash)
{
return(false);
}
offset = 0;
}
using (ApplicationEngine engine = ApplicationEngine.Create(TriggerType.Verification, verifiable, snapshot?.Clone(), gas))
{
CallFlags callFlags = verifiable.Witnesses[i].StateDependent ? CallFlags.AllowStates : CallFlags.None;
ExecutionContext context = engine.LoadScript(verification, callFlags, offset);
if (NativeContract.IsNative(hashes[i]))
{
using ScriptBuilder sb = new ScriptBuilder();
sb.Emit(OpCode.DEPTH, OpCode.PACK);
sb.EmitPush("verify");
engine.LoadScript(sb.ToArray(), CallFlags.None);
}
else if (init != null)
{
engine.LoadContext(context.Clone(init.Offset), false);
}
engine.LoadScript(verifiable.Witnesses[i].InvocationScript, CallFlags.None);
if (engine.Execute() == VMState.FAULT)
{
return(false);
}
if (engine.ResultStack.Count != 1 || !engine.ResultStack.Pop().GetBoolean())
{
return(false);
}
gas -= engine.GasConsumed;
verifiable.Witnesses[i].GasConsumed = engine.GasConsumed;
}
}
return(true);
}
internal static bool VerifyWitness(this IVerifiable verifiable, StoreView snapshot, UInt160 hash, Witness witness, long gas, out long fee)
{
fee = 0;
using (ApplicationEngine engine = ApplicationEngine.Create(TriggerType.Verification, verifiable, snapshot?.Clone(), gas))
{
CallFlags callFlags = !witness.VerificationScript.IsStandardContract() ? CallFlags.ReadStates : CallFlags.None;
byte[] verification = witness.VerificationScript;
if (verification.Length == 0)
{
ContractState cs = NativeContract.Management.GetContract(snapshot, hash);
if (cs is null)
{
return(false);
}
if (engine.LoadContract(cs, "verify", callFlags, true) is null)
{
return(false);
}
}
else
{
if (NativeContract.IsNative(hash))
{
return(false);
}
if (hash != witness.ScriptHash)
{
return(false);
}
engine.LoadScript(verification, callFlags, hash, 0);
}
engine.LoadScript(witness.InvocationScript, CallFlags.None);
if (engine.Execute() == VMState.FAULT)
{
return(false);
}
if (engine.ResultStack.Count != 1 || !engine.ResultStack.Peek().GetBoolean())
{
return(false);
}
fee = engine.GasConsumed;
}
return(true);
}
internal static bool VerifyWitnesses(this IVerifiable verifiable, StoreView snapshot, long gas)
{
if (gas < 0)
{
return(false);
}
if (gas > MaxVerificationGas)
{
gas = MaxVerificationGas;
}
UInt160[] hashes;
try
{
hashes = verifiable.GetScriptHashesForVerifying(snapshot);
}
catch (InvalidOperationException)
{
return(false);
}
if (hashes.Length != verifiable.Witnesses.Length)
{
return(false);
}
for (int i = 0; i < hashes.Length; i++)
{
int offset;
ContractMethodDescriptor init = null;
byte[] verification = verifiable.Witnesses[i].VerificationScript;
if (verification.Length == 0)
{
ContractState cs = snapshot.Contracts.TryGet(hashes[i]);
if (cs is null)
{
return(false);
}
ContractMethodDescriptor md = cs.Manifest.Abi.GetMethod("verify");
if (md is null)
{
return(false);
}
verification = cs.Script;
offset = md.Offset;
init = cs.Manifest.Abi.GetMethod("_initialize");
}
else
{
if (hashes[i] != verifiable.Witnesses[i].ScriptHash)
{
return(false);
}
offset = 0;
}
using (ApplicationEngine engine = ApplicationEngine.Create(TriggerType.Verification, verifiable, snapshot.Clone(), gas))
{
engine.LoadScript(verification, CallFlags.None).InstructionPointer = offset;
if (init != null)
{
engine.LoadClonedContext(init.Offset);
}
engine.LoadScript(verifiable.Witnesses[i].InvocationScript, CallFlags.None);
if (engine.Execute() == VMState.FAULT)
{
return(false);
}
if (engine.ResultStack.Count != 1 || !engine.ResultStack.Pop().GetBoolean())
{
return(false);
}
gas -= engine.GasConsumed;
}
}
return(true);
}