public override void BeginRenderObject( Gas.Graphics.Material material )
{
effect.SetValue( "world", renderer.WorldMatrix );
effect.SetValue( "worldViewProj", renderer.WorldViewProjectionMatrix );
effect.SetValue( "diffuseMap", material.Textures[ 0 ] );
Vector4[] lightPos = new Vector4[ 4 ];
Vector4[] lightColor = new Vector4[ 4 ];
float[] range = new float[ 4 ];
for ( int i = 0; i < renderer.Lights.Count && i < 4; ++i )
{
lightPos[ i ] = new Vector4( renderer.Lights[ i ].Position.X,
renderer.Lights[ i ].Position.Y, 1.0f, 1.0f );
lightColor[ i ] = new Vector4( ( float )renderer.Lights[ i ].Color.R / 255.0f,
( float )renderer.Lights[ i ].Color.G / 255.0f,
( float )renderer.Lights[ i ].Color.B / 255.0f,
( float )renderer.Lights[ i ].Color.A / 255.0f );
range[ i ] = renderer.Lights[ i ].Range;
}
effect.SetValue( "lightPos", lightPos );
effect.SetValue( "lightColor", lightColor );
effect.SetValue( "range", range );
effect.SetValue( "numActiveLights", renderer.Lights.Count );
effect.CommitChanges();
}
public void SendAndReceiveSmartContractTransactions()
{
NetworkRegistration.Register(new SmartContractsRegTest());
using (SmartContractNodeBuilder builder = SmartContractNodeBuilder.Create(this))
{
CoreNode scSender = builder.CreateSmartContractPowNode().WithWallet().Start();
CoreNode scReceiver = builder.CreateSmartContractPowNode().WithWallet().Start();
var callDataSerializer = new CallDataSerializer(new ContractPrimitiveSerializer(scSender.FullNode.Network));
var maturity = (int)scSender.FullNode.Network.Consensus.CoinbaseMaturity;
HdAddress senderAddress = TestHelper.MineBlocks(scSender, maturity + 5).AddressUsed;
// The mining should add coins to the wallet.
int spendableBlocks = GetSpendableBlocks(maturity + 5, maturity);
var total = scSender.FullNode.WalletManager().GetSpendableTransactionsInWallet(WalletName).Sum(s => s.Transaction.Amount);
Assert.Equal(Money.COIN * spendableBlocks * 50, total);
// Create a token contract.
ulong gasPrice = SmartContractMempoolValidator.MinGasPrice;
int vmVersion = 1;
Gas gasLimit = (Gas)(SmartContractFormatRule.GasLimitMaximum / 2);
ContractCompilationResult compilationResult = ContractCompiler.CompileFile("SmartContracts/TransferTest.cs");
Assert.True(compilationResult.Success);
var contractTxData = new ContractTxData(vmVersion, gasPrice, gasLimit, compilationResult.Compilation);
var contractCreateScript = new Script(callDataSerializer.Serialize(contractTxData));
var txBuildContext = new TransactionBuildContext(scSender.FullNode.Network)
{
AccountReference = new WalletAccountReference(WalletName, AccountName),
MinConfirmations = maturity,
TransactionFee = new Money(1, MoneyUnit.BTC),
FeeType = FeeType.High,
WalletPassword = Password,
Recipients = new[] { new Recipient {
Amount = 0, ScriptPubKey = contractCreateScript
} }.ToList()
};
Transaction transferContractTransaction = (scSender.FullNode.NodeService <IWalletTransactionHandler>() as SmartContractWalletTransactionHandler).BuildTransaction(txBuildContext);
// Broadcast the token transaction to the network.
scSender.FullNode.NodeService <IBroadcasterManager>().BroadcastTransactionAsync(transferContractTransaction);
// Wait for the token transaction to be picked up by the mempool.
TestHelper.WaitLoop(() => scSender.CreateRPCClient().GetRawMempool().Length > 0);
// Mine the token transaction and wait for it to sync.
TestHelper.MineBlocks(scSender, 1);
// Sync to the receiver node.
TestHelper.ConnectAndSync(scSender, scReceiver);
// Ensure that both nodes have the contract.
IStateRepositoryRoot senderState = scSender.FullNode.NodeService <IStateRepositoryRoot>();
IStateRepositoryRoot receiverState = scReceiver.FullNode.NodeService <IStateRepositoryRoot>();
IAddressGenerator addressGenerator = scSender.FullNode.NodeService <IAddressGenerator>();
uint160 tokenContractAddress = addressGenerator.GenerateAddress(transferContractTransaction.GetHash(), 0);
Assert.NotNull(senderState.GetCode(tokenContractAddress));
Assert.NotNull(receiverState.GetCode(tokenContractAddress));
scSender.FullNode.MempoolManager().Clear();
// Create a transfer token contract.
compilationResult = ContractCompiler.CompileFile("SmartContracts/TransferTest.cs");
Assert.True(compilationResult.Success);
contractTxData = new ContractTxData(vmVersion, gasPrice, gasLimit, compilationResult.Compilation);
contractCreateScript = new Script(callDataSerializer.Serialize(contractTxData));
txBuildContext = new TransactionBuildContext(scSender.FullNode.Network)
{
AccountReference = new WalletAccountReference(WalletName, AccountName),
MinConfirmations = maturity,
TransactionFee = new Money(1, MoneyUnit.BTC),
FeeType = FeeType.High,
WalletPassword = Password,
Recipients = new[] { new Recipient {
Amount = 0, ScriptPubKey = contractCreateScript
} }.ToList()
};
// Broadcast the token transaction to the network.
transferContractTransaction = (scSender.FullNode.NodeService <IWalletTransactionHandler>() as SmartContractWalletTransactionHandler).BuildTransaction(txBuildContext);
scSender.FullNode.NodeService <IBroadcasterManager>().BroadcastTransactionAsync(transferContractTransaction);
// Wait for the token transaction to be picked up by the mempool.
TestHelper.WaitLoop(() => scSender.CreateRPCClient().GetRawMempool().Length > 0);
TestHelper.MineBlocks(scSender, 1);
// Ensure both nodes are synced with each other.
TestHelper.WaitLoop(() => TestHelper.AreNodesSynced(scReceiver, scSender));
// Ensure that both nodes have the contract.
senderState = scSender.FullNode.NodeService <IStateRepositoryRoot>();
receiverState = scReceiver.FullNode.NodeService <IStateRepositoryRoot>();
tokenContractAddress = addressGenerator.GenerateAddress(transferContractTransaction.GetHash(), 0);
Assert.NotNull(senderState.GetCode(tokenContractAddress));
Assert.NotNull(receiverState.GetCode(tokenContractAddress));
scSender.FullNode.MempoolManager().Clear();
// Create a call contract transaction which will transfer funds.
contractTxData = new ContractTxData(1, gasPrice, gasLimit, tokenContractAddress, "Test");
Script contractCallScript = new Script(callDataSerializer.Serialize(contractTxData));
txBuildContext = new TransactionBuildContext(scSender.FullNode.Network)
{
AccountReference = new WalletAccountReference(WalletName, AccountName),
MinConfirmations = maturity,
TransactionFee = new Money(1, MoneyUnit.BTC),
FeeType = FeeType.High,
WalletPassword = Password,
Recipients = new[] { new Recipient {
Amount = 1000, ScriptPubKey = contractCallScript
} }.ToList()
};
// Broadcast the token transaction to the network.
transferContractTransaction = (scSender.FullNode.NodeService <IWalletTransactionHandler>() as SmartContractWalletTransactionHandler).BuildTransaction(txBuildContext);
scSender.FullNode.NodeService <IBroadcasterManager>().BroadcastTransactionAsync(transferContractTransaction);
TestHelper.WaitLoop(() => scSender.CreateRPCClient().GetRawMempool().Length > 0);
// Mine the transaction.
TestHelper.MineBlocks(scSender, 1);
// Ensure the nodes are synced
TestHelper.WaitLoop(() => TestHelper.AreNodesSynced(scReceiver, scSender));
// The balance should now reflect the transfer.
Assert.Equal((ulong)900, senderState.GetCurrentBalance(tokenContractAddress));
}
}
public void SendAndReceiveSmartContractTransactionsUsingController()
{
using (SmartContractNodeBuilder builder = SmartContractNodeBuilder.Create(this))
{
CoreNode scSender = builder.CreateSmartContractPowNode().WithWallet().Start();
CoreNode scReceiver = builder.CreateSmartContractPowNode().WithWallet().Start();
int maturity = (int)scReceiver.FullNode.Network.Consensus.CoinbaseMaturity;
HdAddress addr = TestHelper.MineBlocks(scSender, maturity + 5).AddressUsed;
int spendable = GetSpendableBlocks(maturity + 5, maturity);
var total = scSender.FullNode.WalletManager().GetSpendableTransactionsInWallet(WalletName).Sum(s => s.Transaction.Amount);
Assert.Equal(Money.COIN * spendable * 50, total);
SmartContractsController senderSmartContractsController = scSender.FullNode.NodeService <SmartContractsController>();
SmartContractWalletController senderWalletController = scSender.FullNode.NodeService <SmartContractWalletController>();
ContractCompilationResult compilationResult = ContractCompiler.CompileFile("SmartContracts/StorageDemo.cs");
Assert.True(compilationResult.Success);
Gas gasLimit = (Gas)(SmartContractFormatRule.GasLimitMaximum / 2);
var buildRequest = new BuildCreateContractTransactionRequest
{
AccountName = AccountName,
GasLimit = gasLimit,
GasPrice = SmartContractMempoolValidator.MinGasPrice,
ContractCode = compilationResult.Compilation.ToHexString(),
FeeAmount = "0.001",
Password = Password,
WalletName = WalletName,
Sender = addr.Address
};
JsonResult result = (JsonResult)senderSmartContractsController.BuildCreateSmartContractTransaction(buildRequest);
var response = (BuildCreateContractTransactionResponse)result.Value;
TestHelper.Connect(scSender, scReceiver);
SmartContractSharedSteps.SendTransaction(scSender, scReceiver, senderWalletController, response.Hex);
TestHelper.MineBlocks(scReceiver, 2);
TestHelper.WaitLoop(() => TestHelper.AreNodesSynced(scReceiver, scSender));
// Check receipt was stored and can be retrieved.
var receiptResponse = (ReceiptResponse)((JsonResult)senderSmartContractsController.GetReceipt(response.TransactionId.ToString())).Value;
Assert.True(receiptResponse.Success);
Assert.Equal(response.NewContractAddress, receiptResponse.NewContractAddress);
Assert.Null(receiptResponse.To);
Assert.Equal(addr.Address, receiptResponse.From);
string storageRequestResult = (string)((JsonResult)senderSmartContractsController.GetStorage(new GetStorageRequest
{
ContractAddress = response.NewContractAddress.ToString(),
StorageKey = "TestSave",
DataType = MethodParameterDataType.String
})).Value;
Assert.Equal("Hello, smart contract world!", storageRequestResult);
string ownerRequestResult = (string)((JsonResult)senderSmartContractsController.GetStorage(new GetStorageRequest
{
ContractAddress = response.NewContractAddress.ToString(),
StorageKey = "Owner",
DataType = MethodParameterDataType.Address
})).Value;
Assert.NotEmpty(ownerRequestResult);
string counterRequestResult = (string)((JsonResult)senderSmartContractsController.GetStorage(new GetStorageRequest
{
ContractAddress = response.NewContractAddress.ToString(),
StorageKey = "Counter",
DataType = MethodParameterDataType.Int
})).Value;
Assert.Equal("12345", counterRequestResult);
var callRequest = new BuildCallContractTransactionRequest
{
AccountName = AccountName,
GasLimit = gasLimit,
GasPrice = SmartContractMempoolValidator.MinGasPrice,
Amount = "0",
MethodName = "Increment",
ContractAddress = response.NewContractAddress,
FeeAmount = "0.001",
Password = Password,
WalletName = WalletName,
Sender = addr.Address
};
result = (JsonResult)senderSmartContractsController.BuildCallSmartContractTransaction(callRequest);
var callResponse = (BuildCallContractTransactionResponse)result.Value;
SmartContractSharedSteps.SendTransaction(scSender, scReceiver, senderWalletController, callResponse.Hex);
TestHelper.MineBlocks(scReceiver, 2);
TestHelper.WaitLoop(() => TestHelper.AreNodesSynced(scReceiver, scSender));
counterRequestResult = (string)((JsonResult)senderSmartContractsController.GetStorage(new GetStorageRequest
{
ContractAddress = response.NewContractAddress.ToString(),
StorageKey = "Counter",
DataType = MethodParameterDataType.Int
})).Value;
Assert.Equal("12346", counterRequestResult);
// Check receipt was stored and can be retrieved.
receiptResponse = (ReceiptResponse)((JsonResult)senderSmartContractsController.GetReceipt(callResponse.TransactionId.ToString())).Value;
Assert.True(receiptResponse.Success);
Assert.Null(receiptResponse.NewContractAddress);
Assert.Equal(response.NewContractAddress, receiptResponse.To);
Assert.Equal(addr.Address, receiptResponse.From);
// Test serialization
// TODO: When refactoring integration tests, move this to the one place and test all types, from method param to storage to serialization.
var serializationRequest = new BuildCallContractTransactionRequest
{
AccountName = AccountName,
GasLimit = gasLimit,
GasPrice = SmartContractMempoolValidator.MinGasPrice,
Amount = "0",
MethodName = "TestSerializer",
ContractAddress = response.NewContractAddress,
FeeAmount = "0.001",
Password = Password,
WalletName = WalletName,
Sender = addr.Address
};
result = (JsonResult)senderSmartContractsController.BuildCallSmartContractTransaction(serializationRequest);
var serializationResponse = (BuildCallContractTransactionResponse)result.Value;
SmartContractSharedSteps.SendTransaction(scSender, scReceiver, senderWalletController, serializationResponse.Hex);
TestHelper.MineBlocks(scReceiver, 2);
TestHelper.WaitLoop(() => TestHelper.AreNodesSynced(scReceiver, scSender));
// Would have only saved if execution completed successfully
counterRequestResult = (string)((JsonResult)senderSmartContractsController.GetStorage(new GetStorageRequest
{
ContractAddress = response.NewContractAddress.ToString(),
StorageKey = "Int32",
DataType = MethodParameterDataType.Int
})).Value;
Assert.Equal("12345", counterRequestResult);
}
}
/// <summary>
/// Instantiates a <see cref="ScOpcodeType.OP_CALLCONTRACT"/> smart contract carrier.
/// </summary>
public static ContractCarrier CallContract(int vmVersion, uint160 contractAddress, string methodName, ulong gasPrice, Gas gasLimit, string[] methodParameters = null)
{
if (string.IsNullOrWhiteSpace(methodName))
{
throw new SmartContractCarrierException(nameof(methodName) + " is null or empty");
}
var serializer = new MethodParameterSerializer();
string methodParams = GetMethodParams(serializer, methodParameters);
var carrier = new ContractCarrier(new MethodParameterSerializer());
carrier.ContractTxData = new ContractTxData(vmVersion, gasPrice, gasLimit, contractAddress, methodName, methodParams);
if (!string.IsNullOrWhiteSpace(methodParams))
{
carrier.MethodParameters = serializer.ToObjects(methodParams);
}
return(carrier);
}
public void SetGasMeterLimitBelow(Gas maximum)
{
this.GasMeter.SetupGet(g => g.GasAvailable).Returns((Gas)(maximum - 1));
}
public static GasPrototype GetGas(Gas gasId) => GasPrototypes[(int)gasId];
public ContractTransferMessage(uint160 to, uint160 from, ulong amount, Gas gasLimit)
: base(to, from, amount, gasLimit, MethodCall.Receive())
{
}
public void SmartContract_Gas_TestValue()
{
var gas = new Gas(Amount);
Assert.Equal(gas.Value, Amount);
}
private void Generate()
{
Random r = new Random(DateTime.Now.Millisecond);
this.Tiles = new Tile[SIZE, SIZE, SIZE];
this.Mass = 0;
for (int x = 0; x < SIZE; x++)
{
for (int y = 0; y < SIZE; y++)
{
for (int z = 0; z < SIZE; z++)
{
double xDistance = Math.Pow((this.Offset.X * SIZE) + x, 2);
double yDistance = Math.Pow((this.Offset.Y * SIZE) + y, 2);
double zDistance = Math.Pow((this.Offset.Z * SIZE) + z, 2);
double totalDistance = Math.Pow(xDistance + yDistance + zDistance, 0.5);
double seaLevel = World.SEA_LEVEL * SIZE;
Material fill = new Gas();
if (totalDistance < seaLevel)
{
fill = new Solid();
Mass++;
}
this.Tiles[x, y, z] = new Tile(fill);
}
}
}
}
public static IAttackTarget BestAttackTarget(IAttackTargetSearcher searcher, TargetScanFlags flags, Predicate <Thing> validator = null, float minDist = 0f, float maxDist = 9999f, IntVec3 locus = default(IntVec3), float maxTravelRadiusFromLocus = 3.40282347E+38f, bool canBash = false)
{
Thing searcherThing = searcher.Thing;
Pawn searcherPawn = searcher as Pawn;
Verb verb = searcher.CurrentEffectiveVerb;
if (verb == null)
{
//Log.Error("BestAttackTarget with " + searcher + " who has no attack verb.");
return(null);
}
bool onlyTargetMachines = verb != null && verb.IsEMP();
float minDistanceSquared = minDist * minDist;
float num = maxTravelRadiusFromLocus + verb.verbProps.range;
float maxLocusDistSquared = num * num;
Func <IntVec3, bool> losValidator = null;
if ((byte)(flags & TargetScanFlags.LOSBlockableByGas) != 0)
{
losValidator = delegate(IntVec3 vec3)
{
Gas gas = vec3.GetGas(searcherThing.Map);
return(gas == null || !gas.def.gas.blockTurretTracking);
};
}
Predicate <IAttackTarget> innerValidator = delegate(IAttackTarget t)
{
Thing thing = t.Thing;
if (t == searcher)
{
return(false);
}
if (minDistanceSquared > 0f && (float)(searcherThing.Position - thing.Position).LengthHorizontalSquared < minDistanceSquared)
{
return(false);
}
if (maxTravelRadiusFromLocus < 9999f && (float)(thing.Position - locus).LengthHorizontalSquared > maxLocusDistSquared)
{
return(false);
}
if (!searcherThing.HostileTo(thing))
{
return(false);
}
if (validator != null && !validator(thing))
{
return(false);
}
if ((byte)(flags & TargetScanFlags.NeedLOSToAll) != 0 && !searcherThing.CanSee(thing, losValidator))
{
if (t is Pawn)
{
if ((byte)(flags & TargetScanFlags.NeedLOSToPawns) != 0)
{
return(false);
}
}
else if ((byte)(flags & TargetScanFlags.NeedLOSToNonPawns) != 0)
{
return(false);
}
}
if ((byte)(flags & TargetScanFlags.NeedThreat) != 0 && t.ThreatDisabled(searcher))
{
return(false);
}
Pawn pawn = t as Pawn;
if (onlyTargetMachines && pawn != null && pawn.RaceProps.IsFlesh)
{
return(false);
}
if ((byte)(flags & TargetScanFlags.NeedNonBurning) != 0 && thing.IsBurning())
{
return(false);
}
if (searcherThing.def.race != null && searcherThing.def.race.intelligence >= Intelligence.Humanlike)
{
CompExplosive compExplosive = thing.TryGetComp <CompExplosive>();
if (compExplosive != null && compExplosive.wickStarted)
{
return(false);
}
}
if (thing.def.size.x == 1 && thing.def.size.z == 1)
{
if (thing.Position.Fogged(thing.Map))
{
return(false);
}
}
else
{
bool flag2 = false;
CellRect.CellRectIterator iterator = thing.OccupiedRect().GetIterator();
while (!iterator.Done())
{
if (!iterator.Current.Fogged(thing.Map))
{
flag2 = true;
break;
}
iterator.MoveNext();
}
if (!flag2)
{
return(false);
}
}
return(true);
};
if (ARA_AttackTargetFinder.HasRangedAttack(searcher))
{
//Log.Warning("Finder: Range detected. Verb is " + verb);
//Log.Warning("Finder: Pawn " + searcherPawn.Faction);
ARA_AttackTargetFinder.tmpTargets.Clear();
//This needs to be fixed. Can't use searcherThing. Doing this the hard way.
//Set request for all attackable.
ThingRequest thingReq = ThingRequest.ForGroup(ThingRequestGroup.AttackTarget);
IEnumerable <Thing> searchSet = searcherThing.Map.listerThings.ThingsMatching(thingReq);
foreach (IAttackTarget iTarget in searchSet)
{
ARA_AttackTargetFinder.tmpTargets.Add(iTarget);
}
if ((byte)(flags & TargetScanFlags.NeedReachable) != 0)
{
Predicate <IAttackTarget> oldValidator = innerValidator;
innerValidator = ((IAttackTarget t) => oldValidator(t) && ARA_AttackTargetFinder.CanReach(searcherThing, t.Thing, canBash));
}
bool flag = false;
if (searcherThing.Faction != Faction.OfPlayer)
{
//Log.Warning("Finder: Target available : " + ARA_AttackTargetFinder.tmpTargets.Count);
for (int i = 0; i < ARA_AttackTargetFinder.tmpTargets.Count; i++)
{
IAttackTarget attackTarget = ARA_AttackTargetFinder.tmpTargets[i];
if (attackTarget.Thing.Position.InHorDistOf(searcherThing.Position, maxDist) && innerValidator(attackTarget) && ARA_AttackTargetFinder.CanShootAtFromCurrentPosition(attackTarget, searcher, verb))
{
//Log.Warning("Finder: flag is true");
flag = true;
break;
}
}
}
IAttackTarget result;
if (flag)
{
//Log.Warning("Finder: FlagTrue result");
ARA_AttackTargetFinder.tmpTargets.RemoveAll((IAttackTarget x) => !x.Thing.Position.InHorDistOf(searcherThing.Position, maxDist) || !innerValidator(x));
//Log.Warning("Finder: Target Avaliable : " + ARA_AttackTargetFinder.tmpTargets.Count);
result = ARA_AttackTargetFinder.GetRandomShootingTargetByScore(ARA_AttackTargetFinder.tmpTargets, searcher, verb);
}
else
{
Predicate <Thing> validator2;
if ((byte)(flags & TargetScanFlags.NeedReachableIfCantHitFromMyPos) != 0 && (byte)(flags & TargetScanFlags.NeedReachable) == 0)
{
//Log.Warning("Finder: Needs reachable");
validator2 = ((Thing t) => innerValidator((IAttackTarget)t) && (ARA_AttackTargetFinder.CanReach(searcherThing, t, canBash) || ARA_AttackTargetFinder.CanShootAtFromCurrentPosition((IAttackTarget)t, searcher, verb)));
}
else
{
//Log.Warning("Finder: Running normal validator");
validator2 = ((Thing t) => innerValidator((IAttackTarget)t));
}
result = (IAttackTarget)GenClosest.ClosestThing_Global(searcherThing.Position, ARA_AttackTargetFinder.tmpTargets, maxDist, validator2, null);
}
ARA_AttackTargetFinder.tmpTargets.Clear();
//Log.Warning("Trying to return result " + result);
return(result);
}
//Log.Warning("Returning Null");
return(null);
}
public void GetHistoryWithValidModelWithoutTransactionSpendingDetailsReturnsWalletHistoryModel()
{
ulong gasPrice = SmartContractMempoolValidator.MinGasPrice;
int vmVersion = 1;
Gas gasLimit = (Gas)(SmartContractFormatRule.GasLimitMaximum / 2);
var contractTxData = new ContractTxData(vmVersion, gasPrice, gasLimit, new byte[] { 0, 1, 2, 3 });
var callDataSerializer = new CallDataSerializer(new ContractPrimitiveSerializer(new SmartContractsRegTest()));
var contractCreateScript = new Script(callDataSerializer.Serialize(contractTxData));
string walletName = "myWallet";
HdAddress address = WalletTestsHelpers.CreateAddress();
TransactionData normalTransaction = WalletTestsHelpers.CreateTransaction(new uint256(1), new Money(500000), 1);
TransactionData createTransaction = WalletTestsHelpers.CreateTransaction(new uint256(1), new Money(500000), 1);
createTransaction.SpendingDetails = new SpendingDetails
{
BlockHeight = 100,
CreationTime = DateTimeOffset.Now,
TransactionId = uint256.One,
Payments = new List <PaymentDetails>
{
new PaymentDetails
{
Amount = new Money(100000),
DestinationScriptPubKey = contractCreateScript
}
}
};
address.Transactions.Add(normalTransaction);
address.Transactions.Add(createTransaction);
var addresses = new List <HdAddress> {
address
};
Features.Wallet.Wallet wallet = WalletTestsHelpers.CreateWallet(walletName);
var account = new HdAccount {
ExternalAddresses = addresses
};
wallet.AccountsRoot.Add(new AccountRoot()
{
Accounts = new List <HdAccount> {
account
}
});
List <FlatHistory> flat = addresses.SelectMany(s => s.Transactions.Select(t => new FlatHistory {
Address = s, Transaction = t
})).ToList();
var accountsHistory = new List <AccountHistory> {
new AccountHistory {
History = flat, Account = account
}
};
this.walletManager.Setup(w => w.GetHistory(walletName, It.IsAny <string>())).Returns(accountsHistory);
this.walletManager.Setup(w => w.GetWalletByName(walletName)).Returns(wallet);
this.walletManager.Setup(w => w.GetAccounts(walletName)).Returns(new List <HdAccount> {
account
});
this.receiptRepository.Setup(x => x.Retrieve(It.IsAny <uint256>()))
.Returns(new Receipt(null, 0, new Log[0], null, null, null, uint160.Zero, true, null, null));
this.callDataSerializer.Setup(x => x.Deserialize(It.IsAny <byte[]>()))
.Returns(Result.Ok(new ContractTxData(0, 0, (Gas)0, new uint160(0), null, null)));
var controller = new SmartContractWalletController(
this.broadcasterManager.Object,
this.callDataSerializer.Object,
this.connectionManager.Object,
this.loggerFactory.Object,
this.network,
this.receiptRepository.Object,
this.walletManager.Object,
this.smartContractTransactionService.Object);
IActionResult result = controller.GetHistory(walletName, address.Address);
var viewResult = Assert.IsType <JsonResult>(result);
var model = viewResult.Value as IEnumerable <ContractTransactionItem>;
Assert.NotNull(model);
Assert.Equal(3, model.Count());
ContractTransactionItem resultingTransaction = model.ElementAt(2);
ContractTransactionItem resultingCreate = model.ElementAt(0);
Assert.Equal(ContractTransactionItemType.ContractCreate, resultingCreate.Type);
Assert.Equal(createTransaction.SpendingDetails.TransactionId, resultingCreate.Hash);
Assert.Equal(createTransaction.SpendingDetails.Payments.First().Amount.ToUnit(MoneyUnit.Satoshi), resultingCreate.Amount);
Assert.Equal(uint160.Zero.ToBase58Address(this.network), resultingCreate.To);
Assert.Equal(createTransaction.SpendingDetails.BlockHeight, resultingCreate.BlockHeight);
Assert.Equal(ContractTransactionItemType.Received, resultingTransaction.Type);
Assert.Equal(address.Address, resultingTransaction.To);
Assert.Equal(normalTransaction.Id, resultingTransaction.Hash);
Assert.Equal(normalTransaction.Amount.ToUnit(MoneyUnit.Satoshi), resultingTransaction.Amount);
Assert.Equal(1, resultingTransaction.BlockHeight);
}
// Token: 0x06003F17 RID: 16151 RVA: 0x001D8758 File Offset: 0x001D6B58
public static IAttackTarget BestAttackTarget(IAttackTargetSearcher searcher, TargetScanFlags flags, Predicate <Thing> validator = null, float minDist = 0f, float maxDist = 9999f, IntVec3 locus = default(IntVec3), float maxTravelRadiusFromLocus = 3.40282347E+38f, bool canBash = false, bool canTakeTargetsCloserThanEffectiveMinRange = true)
{
Thing searcherThing = searcher.Thing;
Pawn searcherPawn = searcher as Pawn;
Verb verb = searcher.CurrentEffectiveVerb;
if (verb == null)
{
Log.Error("BestAttackTarget with " + searcher.ToStringSafe <IAttackTargetSearcher>() + " who has no attack verb.", false);
return(null);
}
bool onlyTargetMachines = verb.IsEMP();
float minDistSquared = minDist * minDist;
float num = maxTravelRadiusFromLocus + verb.verbProps.range;
float maxLocusDistSquared = num * num;
Func <IntVec3, bool> losValidator = null;
if ((byte)(flags & TargetScanFlags.LOSBlockableByGas) != 0)
{
losValidator = delegate(IntVec3 vec3)
{
Gas gas = vec3.GetGas(searcherThing.Map);
return(gas == null || !gas.def.gas.blockTurretTracking);
};
}
Predicate <IAttackTarget> innerValidator = delegate(IAttackTarget t)
{
Thing thing = t.Thing;
if (t == searcher)
{
return(false);
}
if (minDistSquared > 0f && (float)(searcherThing.Position - thing.Position).LengthHorizontalSquared < minDistSquared)
{
return(false);
}
if (!canTakeTargetsCloserThanEffectiveMinRange)
{
float num2 = verb.verbProps.EffectiveMinRange(thing, searcherThing);
if (num2 > 0f && (float)(searcherThing.Position - thing.Position).LengthHorizontalSquared < num2 * num2)
{
return(false);
}
}
if (maxTravelRadiusFromLocus < 9999f && (float)(thing.Position - locus).LengthHorizontalSquared > maxLocusDistSquared)
{
return(false);
}
/*
* if (!searcherThing.HostileTo(thing))
* {
* return false;
* }
*/
if (validator != null && !validator(thing))
{
return(false);
}
if (searcherPawn != null)
{
Lord lord = searcherPawn.GetLord();
if (lord != null && !lord.LordJob.ValidateAttackTarget(searcherPawn, thing))
{
return(false);
}
}
if ((byte)(flags & TargetScanFlags.NeedLOSToAll) != 0 && !searcherThing.CanSee(thing, losValidator))
{
if (t is Pawn)
{
if ((byte)(flags & TargetScanFlags.NeedLOSToPawns) != 0)
{
return(false);
}
}
else if ((byte)(flags & TargetScanFlags.NeedLOSToNonPawns) != 0)
{
return(false);
}
}
if ((byte)(flags & TargetScanFlags.NeedThreat) != 0 && t.ThreatDisabled(searcher))
{
return(false);
}
Pawn pawn = t as Pawn;
if (onlyTargetMachines && pawn != null && pawn.RaceProps.IsFlesh)
{
return(false);
}
if ((byte)(flags & TargetScanFlags.NeedNonBurning) != 0 && thing.IsBurning())
{
return(false);
}
if (searcherThing.def.race != null && searcherThing.def.race.intelligence >= Intelligence.Humanlike)
{
CompExplosive compExplosive = thing.TryGetComp <CompExplosive>();
if (compExplosive != null && compExplosive.wickStarted)
{
return(false);
}
}
if (thing.def.size.x == 1 && thing.def.size.z == 1)
{
if (thing.Position.Fogged(thing.Map))
{
return(false);
}
}
else
{
bool flag2 = false;
using (CellRect.Enumerator enumerator = thing.OccupiedRect().GetEnumerator())
{
while (enumerator.MoveNext())
{
if (!enumerator.Current.Fogged(thing.Map))
{
flag2 = true;
break;
}
}
}
if (!flag2)
{
return(false);
}
}
return(true);
};
if (XenomorphTargetFinder.HasRangedAttack(searcher))
{
XenomorphTargetFinder.tmpTargets.Clear();
XenomorphTargetFinder.tmpTargets.AddRange(searcherThing.Map.attackTargetsCache.GetPotentialTargetsFor(searcher));
if ((byte)(flags & TargetScanFlags.NeedReachable) != 0)
{
Predicate <IAttackTarget> oldValidator = innerValidator;
innerValidator = ((IAttackTarget t) => oldValidator(t) && XenomorphTargetFinder.CanReach(searcherThing, t.Thing, canBash));
}
bool flag = false;
for (int i = 0; i < XenomorphTargetFinder.tmpTargets.Count; i++)
{
IAttackTarget attackTarget = XenomorphTargetFinder.tmpTargets[i];
if (attackTarget.Thing.Position.InHorDistOf(searcherThing.Position, maxDist) && innerValidator(attackTarget) && XenomorphTargetFinder.CanShootAtFromCurrentPosition(attackTarget, searcher, verb))
{
flag = true;
break;
}
}
IAttackTarget result;
if (flag)
{
XenomorphTargetFinder.tmpTargets.RemoveAll((IAttackTarget x) => !x.Thing.Position.InHorDistOf(searcherThing.Position, maxDist) || !innerValidator(x));
result = XenomorphTargetFinder.GetRandomShootingTargetByScore(XenomorphTargetFinder.tmpTargets, searcher, verb);
}
else
{
Predicate <Thing> validator2;
if ((byte)(flags & TargetScanFlags.NeedReachableIfCantHitFromMyPos) != 0 && (byte)(flags & TargetScanFlags.NeedReachable) == 0)
{
validator2 = ((Thing t) => innerValidator((IAttackTarget)t) && (XenomorphTargetFinder.CanReach(searcherThing, t, canBash) || XenomorphTargetFinder.CanShootAtFromCurrentPosition((IAttackTarget)t, searcher, verb)));
}
else
{
validator2 = ((Thing t) => innerValidator((IAttackTarget)t));
}
result = (IAttackTarget)GenClosest.ClosestThing_Global(searcherThing.Position, XenomorphTargetFinder.tmpTargets, maxDist, validator2, null);
}
XenomorphTargetFinder.tmpTargets.Clear();
return(result);
}
if (searcherPawn != null && searcherPawn.mindState.duty != null && searcherPawn.mindState.duty.radius > 0f && !searcherPawn.InMentalState)
{
Predicate <IAttackTarget> oldValidator = innerValidator;
innerValidator = ((IAttackTarget t) => oldValidator(t) && t.Thing.Position.InHorDistOf(searcherPawn.mindState.duty.focus.Cell, searcherPawn.mindState.duty.radius));
}
IntVec3 position = searcherThing.Position;
Map map = searcherThing.Map;
ThingRequest thingReq = ThingRequest.ForGroup(ThingRequestGroup.AttackTarget);
PathEndMode peMode = PathEndMode.Touch;
Pawn searcherPawn2 = searcherPawn;
Danger maxDanger = Danger.Deadly;
bool canBash2 = canBash;
TraverseParms traverseParams = TraverseParms.For(searcherPawn2, maxDanger, TraverseMode.ByPawn, canBash2);
float maxDist2 = maxDist;
Predicate <Thing> validator3 = (Thing x) => innerValidator((IAttackTarget)x);
int searchRegionsMax = (maxDist <= 800f) ? 40 : -1;
IAttackTarget attackTarget2 = (IAttackTarget)GenClosest.ClosestThingReachable(position, map, thingReq, peMode, traverseParams, maxDist2, validator3, null, 0, searchRegionsMax, false, RegionType.Set_Passable, false);
if (attackTarget2 != null && PawnUtility.ShouldCollideWithPawns(searcherPawn))
{
IAttackTarget attackTarget3 = XenomorphTargetFinder.FindBestReachableMeleeTarget(innerValidator, searcherPawn, maxDist, canBash);
if (attackTarget3 != null)
{
float lengthHorizontal = (searcherPawn.Position - attackTarget2.Thing.Position).LengthHorizontal;
float lengthHorizontal2 = (searcherPawn.Position - attackTarget3.Thing.Position).LengthHorizontal;
if (Mathf.Abs(lengthHorizontal - lengthHorizontal2) < 50f)
{
attackTarget2 = attackTarget3;
}
}
}
return(attackTarget2);
}
public ExternalCreateMessage(uint160 from, ulong amount, Gas gasLimit, byte[] code, object[] parameters)
: base(from, amount, gasLimit)
{
this.Code = code;
this.Parameters = parameters;
}
public abstract Task UpdateValue(Gas gas, ProcessType type, double value);
public void Arrange()
{
_repo = new Gas_Repo();
_gas = new Gas("GMC", "Sierra", "17 miles per gallon");
_repo.AddGasToList(_gas);
}
public JsonResult GetOverViewData()
{
using (DBModel db = new DBModel())
{
var gas = db.gas.FirstOrDefault();
if (gas != null)
{
gas.luu_luong_hien_tai = ((float)Math.Round(float.Parse(gas.luu_luong_hien_tai) * 10f) / 10f).ToString();
gas.luu_luong_tong = ((float)Math.Round(float.Parse(gas.luu_luong_tong) * 10f) / 10f).ToString();
}
else
{
gas = new Gas();
}
//Get Water table
var water = db.water.FirstOrDefault();
if (water != null)
{
water.luu_luong_hien_tai = ((float)Math.Round(float.Parse(water.luu_luong_hien_tai) * 10f) / 10f).ToString();
water.luu_luong_tong = ((float)Math.Round(float.Parse(water.luu_luong_tong) * 10f) / 10f).ToString();
}
else
{
water = new Water();
}
var hienthi = db.hienthi.Select(i => new HienthiOverView {
Kenh = i.Kenh, Ptotal = i.Ptotal, Kwh = i.Kwh
}).ToList();
float count_Ptotal = 0;
float count_Kwh = 0;
if (hienthi != null)
{
for (var i = 0; i < hienthi.Count; i++)
{
switch (hienthi[i].Kenh)
{
case "1":
hienthi[i].Kwh = ((float)Math.Round((float.Parse(hienthi[i].Kwh) - kenh1_2009) * 10f) / 10f).ToString();
break;
case "2":
hienthi[i].Kwh = ((float)Math.Round((float.Parse(hienthi[i].Kwh) - kenh2_2009) * 10f) / 10f).ToString();
break;
case "3":
hienthi[i].Kwh = ((float)Math.Round((float.Parse(hienthi[i].Kwh) - kenh3_2009) * 10f) / 10f).ToString();
break;
case "4":
hienthi[i].Kwh = ((float)Math.Round((float.Parse(hienthi[i].Kwh) - kenh4_2009) * 10f) / 10f).ToString();
break;
case "5":
hienthi[i].Kwh = ((float)Math.Round((float.Parse(hienthi[i].Kwh) - kenh5_2009) * 10f) / 10f).ToString();
break;
case "6":
hienthi[i].Kwh = ((float)Math.Round((float.Parse(hienthi[i].Kwh) - kenh6_2009) * 10f) / 10f).ToString();
break;
default:
break;
}
hienthi[i].Ptotal = ((float)Math.Round(float.Parse(hienthi[i].Ptotal) * 10f) / 10f).ToString();
count_Ptotal += float.Parse(hienthi[i].Ptotal);
count_Kwh += float.Parse(hienthi[i].Kwh);
}
}
var data = new List <object>();
data.Add(gas);
data.Add(water);
data.Add(hienthi);
data.Add(((float)Math.Round(count_Ptotal * 10f) / 10f));
data.Add(((float)Math.Round(count_Kwh * 10f) / 10f));
var result = data;
return(Json(result, JsonRequestBehavior.AllowGet));
}
}
protected BaseMessage(uint160 from, ulong amount, Gas gasLimit)
{
this.From = from;
this.Amount = amount;
this.GasLimit = gasLimit;
}
public ExternalCallMessage(uint160 to, uint160 from, ulong amount, Gas gasLimit, MethodCall methodCall)
: base(to, from, amount, gasLimit, methodCall)
{
}
private void RewriteMethod(MethodDefinition methodDefinition, ObserverReferences observer)
{
if (methodDefinition.DeclaringType == observer.InstanceField.DeclaringType)
{
return; // don't inject on our injected type.
}
if (!methodDefinition.HasBody || methodDefinition.Body.Instructions.Count == 0)
{
return; // don't inject on method without a Body
}
List <Instruction> branches = methodDefinition.Body.Instructions.Where(x => BranchingOps.Contains(x.OpCode)).ToList();
List <Instruction> branchTos = branches.Select(x => (Instruction)x.Operand).ToList();
Instruction currentSegmentStart = methodDefinition.Body.Instructions.FirstOrDefault();
Gas gasTally = Gas.None;
Dictionary <Instruction, Gas> gasToSpendForSegment = new Dictionary <Instruction, Gas>();
// Inject observer instance to method.
ILProcessor il = methodDefinition.Body.GetILProcessor();
var observerVariable = new VariableDefinition(observer.InstanceField.FieldType);
il.Body.Variables.Add(observerVariable);
Instruction start = methodDefinition.Body.Instructions[0];
il.InsertBefore(start, il.Create(OpCodes.Ldsfld, observer.InstanceField));
il.InsertBefore(start, il.CreateStlocBest(observerVariable));
// Start at 2 because of the instructions we just added.
int position = 2;
while (position < methodDefinition.Body.Instructions.Count)
{
Instruction instruction = methodDefinition.Body.Instructions[position];
Gas instructionCost = GasPriceList.InstructionOperationCost(instruction);
// is the end of a segment. Include the current instruction in the count.
if (branches.Contains(instruction))
{
gasTally = (Gas)(gasTally + instructionCost);
gasToSpendForSegment.Add(currentSegmentStart, gasTally);
gasTally = Gas.None;
position++;
if (position == methodDefinition.Body.Instructions.Count)
{
break;
}
currentSegmentStart = methodDefinition.Body.Instructions[position];
}
// is the start of a new segment. Don't include the current instruction in count.
else if (branchTos.Contains(instruction) && instruction != currentSegmentStart)
{
gasToSpendForSegment.Add(currentSegmentStart, gasTally);
gasTally = Gas.None;
currentSegmentStart = instruction;
position++;
}
// is a call to another method
else if (CallingOps.Contains(instruction.OpCode))
{
var methodToCall = (MethodReference)instruction.Operand;
// If it's a method inside this contract then the gas will be injected no worries.
if (methodToCall.DeclaringType == methodDefinition.DeclaringType)
{
position++;
gasTally = (Gas)(gasTally + instructionCost);
}
// If it's a method outside this contract then we will need to get some average in future.
else
{
Gas methodCallCost = GasPriceList.MethodCallCost(methodToCall);
position++;
gasTally = (Gas)(gasTally + instructionCost + methodCallCost);
}
}
// any other instruction. just increase counter.
else
{
position++;
gasTally = (Gas)(gasTally + instructionCost);
}
}
if (!gasToSpendForSegment.ContainsKey(currentSegmentStart))
{
gasToSpendForSegment.Add(currentSegmentStart, gasTally);
}
foreach (Instruction instruction in gasToSpendForSegment.Keys)
{
Instruction injectAfterInstruction = instruction;
// If it's a constructor we need to skip the first 3 instructions.
// These will always be invoking the base constructor
// ldarg.0
// ldarg.0
// call SmartContract::ctor
if (methodDefinition.IsConstructor)
{
injectAfterInstruction = instruction.Next.Next.Next;
}
AddSpendGasMethodBeforeInstruction(methodDefinition, observer, observerVariable, injectAfterInstruction, gasToSpendForSegment[instruction]);
}
foreach (Instruction instruction in branches)
{
var oldReference = (Instruction)instruction.Operand;
Instruction newReference = oldReference.Previous.Previous.Previous; // 3 were inserted
Instruction newInstruction = il.Create(instruction.OpCode, newReference);
il.Replace(instruction, newInstruction);
}
}
public static IAttackTarget BestAttackTarget(IAttackTargetSearcher searcher, TargetScanFlags flags, Predicate <Thing> validator = null, float minDist = 0f, float maxDist = 9999f, IntVec3 locus = default(IntVec3), float maxTravelRadiusFromLocus = float.MaxValue, bool canBash = false, bool canTakeTargetsCloserThanEffectiveMinRange = true)
{
Thing searcherThing = searcher.Thing;
Pawn searcherPawn = searcher as Pawn;
Verb verb = searcher.CurrentEffectiveVerb;
if (verb == null)
{
Log.Error("BestAttackTarget with " + searcher.ToStringSafe() + " who has no attack verb.");
return(null);
}
bool onlyTargetMachines = verb.IsEMP();
float minDistSquared = minDist * minDist;
float num = maxTravelRadiusFromLocus + verb.verbProps.range;
float maxLocusDistSquared = num * num;
Func <IntVec3, bool> losValidator = null;
if ((flags & TargetScanFlags.LOSBlockableByGas) != 0)
{
losValidator = delegate(IntVec3 vec3)
{
Gas gas = vec3.GetGas(searcherThing.Map);
return(gas == null || !gas.def.gas.blockTurretTracking);
};
}
Predicate <IAttackTarget> innerValidator = delegate(IAttackTarget t)
{
Thing thing = t.Thing;
if (t == searcher)
{
return(false);
}
if (minDistSquared > 0f && (float)(searcherThing.Position - thing.Position).LengthHorizontalSquared < minDistSquared)
{
return(false);
}
if (!canTakeTargetsCloserThanEffectiveMinRange)
{
float num2 = verb.verbProps.EffectiveMinRange(thing, searcherThing);
if (num2 > 0f && (float)(searcherThing.Position - thing.Position).LengthHorizontalSquared < num2 * num2)
{
return(false);
}
}
if (maxTravelRadiusFromLocus < 9999f && (float)(thing.Position - locus).LengthHorizontalSquared > maxLocusDistSquared)
{
return(false);
}
if (!searcherThing.HostileTo(thing))
{
return(false);
}
if (validator != null && !validator(thing))
{
return(false);
}
if (searcherPawn != null)
{
Lord lord = searcherPawn.GetLord();
if (lord != null && !lord.LordJob.ValidateAttackTarget(searcherPawn, thing))
{
return(false);
}
}
if ((flags & TargetScanFlags.NeedNotUnderThickRoof) != 0)
{
RoofDef roof = thing.Position.GetRoof(thing.Map);
if (roof != null && roof.isThickRoof)
{
return(false);
}
}
if ((flags & TargetScanFlags.NeedLOSToAll) != 0)
{
if (losValidator != null && (!losValidator(searcherThing.Position) || !losValidator(thing.Position)))
{
return(false);
}
if (!searcherThing.CanSee(thing, losValidator))
{
if (t is Pawn)
{
if ((flags & TargetScanFlags.NeedLOSToPawns) != 0)
{
return(false);
}
}
else if ((flags & TargetScanFlags.NeedLOSToNonPawns) != 0)
{
return(false);
}
}
}
if (((flags & TargetScanFlags.NeedThreat) != 0 || (flags & TargetScanFlags.NeedAutoTargetable) != 0) && t.ThreatDisabled(searcher))
{
return(false);
}
if ((flags & TargetScanFlags.NeedAutoTargetable) != 0 && !IsAutoTargetable(t))
{
return(false);
}
if ((flags & TargetScanFlags.NeedActiveThreat) != 0 && !GenHostility.IsActiveThreatTo(t, searcher.Thing.Faction))
{
return(false);
}
Pawn pawn = t as Pawn;
if (onlyTargetMachines && pawn != null && pawn.RaceProps.IsFlesh)
{
return(false);
}
if ((flags & TargetScanFlags.NeedNonBurning) != 0 && thing.IsBurning())
{
return(false);
}
if (searcherThing.def.race != null && (int)searcherThing.def.race.intelligence >= 2)
{
CompExplosive compExplosive = thing.TryGetComp <CompExplosive>();
if (compExplosive != null && compExplosive.wickStarted)
{
return(false);
}
}
if (thing.def.size.x == 1 && thing.def.size.z == 1)
{
if (thing.Position.Fogged(thing.Map))
{
return(false);
}
}
else
{
bool flag2 = false;
foreach (IntVec3 item in thing.OccupiedRect())
{
if (!item.Fogged(thing.Map))
{
flag2 = true;
break;
}
}
if (!flag2)
{
return(false);
}
}
return(true);
};
if (HasRangedAttack(searcher) && (searcherPawn == null || !searcherPawn.InAggroMentalState))
{
tmpTargets.Clear();
tmpTargets.AddRange(searcherThing.Map.attackTargetsCache.GetPotentialTargetsFor(searcher));
if ((flags & TargetScanFlags.NeedReachable) != 0)
{
Predicate <IAttackTarget> oldValidator2 = innerValidator;
innerValidator = (IAttackTarget t) => oldValidator2(t) && CanReach(searcherThing, t.Thing, canBash);
}
bool flag = false;
for (int i = 0; i < tmpTargets.Count; i++)
{
IAttackTarget attackTarget = tmpTargets[i];
if (attackTarget.Thing.Position.InHorDistOf(searcherThing.Position, maxDist) && innerValidator(attackTarget) && CanShootAtFromCurrentPosition(attackTarget, searcher, verb))
{
flag = true;
break;
}
}
IAttackTarget result;
if (flag)
{
tmpTargets.RemoveAll((IAttackTarget x) => !x.Thing.Position.InHorDistOf(searcherThing.Position, maxDist) || !innerValidator(x));
result = GetRandomShootingTargetByScore(tmpTargets, searcher, verb);
}
else
{
result = (IAttackTarget)GenClosest.ClosestThing_Global(validator: ((flags & TargetScanFlags.NeedReachableIfCantHitFromMyPos) == 0 || (flags & TargetScanFlags.NeedReachable) != 0) ? ((Predicate <Thing>)((Thing t) => innerValidator((IAttackTarget)t))) : ((Predicate <Thing>)((Thing t) => innerValidator((IAttackTarget)t) && (CanReach(searcherThing, t, canBash) || CanShootAtFromCurrentPosition((IAttackTarget)t, searcher, verb)))), center: searcherThing.Position, searchSet: tmpTargets, maxDistance: maxDist);
}
tmpTargets.Clear();
return(result);
}
if (searcherPawn != null && searcherPawn.mindState.duty != null && searcherPawn.mindState.duty.radius > 0f && !searcherPawn.InMentalState)
{
Predicate <IAttackTarget> oldValidator = innerValidator;
innerValidator = delegate(IAttackTarget t)
{
if (!oldValidator(t))
{
return(false);
}
return(t.Thing.Position.InHorDistOf(searcherPawn.mindState.duty.focus.Cell, searcherPawn.mindState.duty.radius) ? true : false);
};
}
IAttackTarget attackTarget2 = (IAttackTarget)GenClosest.ClosestThingReachable(searcherThing.Position, searcherThing.Map, ThingRequest.ForGroup(ThingRequestGroup.AttackTarget), PathEndMode.Touch, TraverseParms.For(searcherPawn, Danger.Deadly, TraverseMode.ByPawn, canBash), maxDist, (Thing x) => innerValidator((IAttackTarget)x), null, 0, (maxDist > 800f) ? (-1) : 40);
if (attackTarget2 != null && PawnUtility.ShouldCollideWithPawns(searcherPawn))
{
IAttackTarget attackTarget3 = FindBestReachableMeleeTarget(innerValidator, searcherPawn, maxDist, canBash);
if (attackTarget3 != null)
{
float lengthHorizontal = (searcherPawn.Position - attackTarget2.Thing.Position).LengthHorizontal;
float lengthHorizontal2 = (searcherPawn.Position - attackTarget3.Thing.Position).LengthHorizontal;
if (Mathf.Abs(lengthHorizontal - lengthHorizontal2) < 50f)
{
attackTarget2 = attackTarget3;
}
}
}
return(attackTarget2);
}
private static void AddSpendGasMethodBeforeInstruction(MethodDefinition methodDefinition, ObserverReferences observer, VariableDefinition variable, Instruction instruction, Gas opcodeCount)
{
ILProcessor il = methodDefinition.Body.GetILProcessor();
il.InsertBefore(instruction, il.CreateLdlocBest(variable)); // load observer
il.InsertBefore(instruction, il.Create(OpCodes.Ldc_I8, (long)opcodeCount.Value)); // load gas amount
il.InsertBefore(instruction, il.Create(OpCodes.Call, observer.SpendGasMethod)); // trigger method
}
public void SetGasMeterLimitAbove(Gas minimum)
{
this.GasMeter.SetupGet(g => g.GasAvailable).Returns((Gas)(minimum + 1));
}
private void Calculate()
{
Gas.GetAmount(PreviousTextBox, CurrentTextBox, MonthsTextBox, ref ConsumptionTextBlock, ref AmountTextBlock);
}
/// <summary>
/// Creates a new instance of a Duval Pentagon.
/// Specify gases in counter clock-wise order starting at 12 o'oclock position.
/// </summary>
public AbstractDuvalPentagonRule(string name, Gas hydrogen, Gas ethane, Gas methane, Gas ethylene, Gas acetylene)
{
PentagonName = name;
Pentagon = new EquilateralPentagon(
new PolygonalAxis(hydrogen.ToString(), new Measurement()
{
Value = 90.0, Unit = new AngleUnits.Degrees()
}),
new PolygonalAxis(ethane.ToString(), new Measurement()
{
Value = 162.0, Unit = new AngleUnits.Degrees()
}),
new PolygonalAxis(methane.ToString(), new Measurement()
{
Value = 234.0, Unit = new AngleUnits.Degrees()
}),
new PolygonalAxis(ethylene.ToString(), new Measurement()
{
Value = 306.0, Unit = new AngleUnits.Degrees()
}),
new PolygonalAxis(acetylene.ToString(), new Measurement()
{
Value = 18.0, Unit = new AngleUnits.Degrees()
}));
GasMeasurements.Add(hydrogen, null);
GasMeasurements.Add(ethane, null);
GasMeasurements.Add(methane, null);
GasMeasurements.Add(ethylene, null);
GasMeasurements.Add(acetylene, null);
GasPercentages.Add(hydrogen, 0.0);
GasPercentages.Add(ethane, 0.0);
GasPercentages.Add(methane, 0.0);
GasPercentages.Add(ethylene, 0.0);
GasPercentages.Add(acetylene, 0.0);
}
/// <summary>
/// Creates a new result for a failed state transition due to a VM exception.
/// </summary>
public static StateTransitionResult Fail(Gas gasConsumed, ContractErrorMessage vmError)
{
return(new StateTransitionResult(new StateTransitionError(gasConsumed, StateTransitionErrorKind.VmError, vmError)));
}
public void SendAndReceiveSmartContractTransactionsOnPosNetwork()
{
using (SmartContractNodeBuilder builder = SmartContractNodeBuilder.Create(this))
{
CoreNode scSender = builder.CreateSmartContractPosNode().WithWallet().Start();
CoreNode scReceiver = builder.CreateSmartContractPosNode().WithWallet().Start();
var callDataSerializer = new CallDataSerializer(new ContractPrimitiveSerializer(scSender.FullNode.Network));
var maturity = (int)scSender.FullNode.Network.Consensus.CoinbaseMaturity;
HdAddress senderAddress = TestHelper.MineBlocks(scSender, maturity + 5).AddressUsed;
// The mining should add coins to the wallet.
var total = scSender.FullNode.WalletManager().GetSpendableTransactionsInWallet(WalletName).Sum(s => s.Transaction.Amount);
Assert.Equal(Money.COIN * 6 * 50, total);
// Create a token contract
ulong gasPrice = 1;
int vmVersion = 1;
Gas gasLimit = (Gas)5000;
ContractCompilationResult compilationResult = ContractCompiler.CompileFile("SmartContracts/TransferTestPos.cs");
Assert.True(compilationResult.Success);
var contractTxData = new ContractTxData(vmVersion, gasPrice, gasLimit, compilationResult.Compilation);
var contractCreateScript = new Script(callDataSerializer.Serialize(contractTxData));
var txBuildContext = new TransactionBuildContext(scSender.FullNode.Network)
{
AccountReference = new WalletAccountReference(WalletName, AccountName),
ChangeAddress = senderAddress,
MinConfirmations = maturity,
FeeType = FeeType.High,
WalletPassword = Password,
Recipients = new[] { new Recipient {
Amount = 0, ScriptPubKey = contractCreateScript
} }.ToList()
};
// Build the transfer contract transaction
var transferContractTransaction = BuildTransferContractTransaction(scSender, txBuildContext);
// Add the smart contract transaction to the mempool to be mined.
scSender.AddToStratisMempool(transferContractTransaction);
// Ensure the smart contract transaction is in the mempool.
TestHelper.WaitLoop(() => scSender.CreateRPCClient().GetRawMempool().Length > 0);
// Mine the token transaction and wait for it sync
TestHelper.MineBlocks(scSender, 1);
// Sync to the receiver node
TestHelper.ConnectAndSync(scSender, scReceiver);
// Ensure that boths nodes has the contract
IStateRepositoryRoot senderState = scSender.FullNode.NodeService <IStateRepositoryRoot>();
IStateRepositoryRoot receiverState = scReceiver.FullNode.NodeService <IStateRepositoryRoot>();
IAddressGenerator addressGenerator = scSender.FullNode.NodeService <IAddressGenerator>();
uint160 tokenContractAddress = addressGenerator.GenerateAddress(transferContractTransaction.GetHash(), 0);
Assert.NotNull(senderState.GetCode(tokenContractAddress));
Assert.NotNull(receiverState.GetCode(tokenContractAddress));
scSender.FullNode.MempoolManager().Clear();
// Create a transfer token contract
compilationResult = ContractCompiler.CompileFile("SmartContracts/TransferTestPos.cs");
Assert.True(compilationResult.Success);
contractTxData = new ContractTxData(vmVersion, gasPrice, gasLimit, compilationResult.Compilation);
contractCreateScript = new Script(callDataSerializer.Serialize(contractTxData));
txBuildContext = new TransactionBuildContext(scSender.FullNode.Network)
{
AccountReference = new WalletAccountReference(WalletName, AccountName),
ChangeAddress = senderAddress,
MinConfirmations = maturity,
FeeType = FeeType.High,
WalletPassword = Password,
Recipients = new[] { new Recipient {
Amount = 0, ScriptPubKey = contractCreateScript
} }.ToList()
};
// Build the transfer contract transaction
transferContractTransaction = BuildTransferContractTransaction(scSender, txBuildContext);
// Add the smart contract transaction to the mempool to be mined.
scSender.AddToStratisMempool(transferContractTransaction);
// Wait for the token transaction to be picked up by the mempool
TestHelper.WaitLoop(() => scSender.CreateRPCClient().GetRawMempool().Length > 0);
TestHelper.MineBlocks(scSender, 1);
// Ensure both nodes are synced with each other
TestHelper.WaitLoop(() => TestHelper.AreNodesSynced(scReceiver, scSender));
tokenContractAddress = addressGenerator.GenerateAddress(transferContractTransaction.GetHash(), 0); // nonce is 0 for user contract creation.
Assert.NotNull(senderState.GetCode(tokenContractAddress));
Assert.NotNull(receiverState.GetCode(tokenContractAddress));
scSender.FullNode.MempoolManager().Clear();
// Create a call contract transaction which will transfer funds
contractTxData = new ContractTxData(1, gasPrice, gasLimit, tokenContractAddress, "Test");
Script contractCallScript = new Script(callDataSerializer.Serialize(contractTxData));
txBuildContext = new TransactionBuildContext(scSender.FullNode.Network)
{
AccountReference = new WalletAccountReference(WalletName, AccountName),
ChangeAddress = senderAddress,
MinConfirmations = maturity,
FeeType = FeeType.High,
WalletPassword = Password,
Recipients = new[] { new Recipient {
Amount = 1000, ScriptPubKey = contractCallScript
} }.ToList()
};
// Build the transfer contract transaction
var callContractTransaction = BuildTransferContractTransaction(scSender, txBuildContext);
// Add the smart contract transaction to the mempool to be mined.
scSender.AddToStratisMempool(callContractTransaction);
// Wait for the token transaction to be picked up by the mempool
TestHelper.WaitLoop(() => scSender.CreateRPCClient().GetRawMempool().Length > 0);
TestHelper.MineBlocks(scSender, 1);
// Ensure the nodes are synced
TestHelper.WaitLoop(() => TestHelper.AreNodesSynced(scReceiver, scSender));
// The balance should now reflect the transfer
Assert.Equal((ulong)900, senderState.GetCurrentBalance(tokenContractAddress));
}
}
/// <summary>
/// Creates a new result for a failed state transition.
/// </summary>
public static StateTransitionResult Fail(Gas gasConsumed, StateTransitionErrorKind kind)
{
return(new StateTransitionResult(new StateTransitionError(gasConsumed, kind, null)));
}
public void SendAndReceiveLocalSmartContractPropertyCallTransactionsUsingController()
{
using (SmartContractNodeBuilder builder = SmartContractNodeBuilder.Create(this))
{
CoreNode scSender = builder.CreateSmartContractPowNode().WithWallet().Start();
CoreNode scReceiver = builder.CreateSmartContractPowNode().WithWallet().Start();
int maturity = (int)scReceiver.FullNode.Network.Consensus.CoinbaseMaturity;
HdAddress addr = TestHelper.MineBlocks(scSender, maturity + 5).AddressUsed;
int spendable = GetSpendableBlocks(maturity + 5, maturity);
var total = scSender.FullNode.WalletManager().GetSpendableTransactionsInWallet(WalletName).Sum(s => s.Transaction.Amount);
Assert.Equal(Money.COIN * spendable * 50, total);
SmartContractsController senderSmartContractsController = scSender.FullNode.NodeService <SmartContractsController>();
SmartContractWalletController senderWalletController = scSender.FullNode.NodeService <SmartContractWalletController>();
ContractCompilationResult compilationResult = ContractCompiler.CompileFile("SmartContracts/StorageDemo.cs");
Assert.True(compilationResult.Success);
Gas gasLimit = (Gas)(SmartContractFormatRule.GasLimitMaximum / 2);
var buildRequest = new BuildCreateContractTransactionRequest
{
AccountName = AccountName,
GasLimit = gasLimit,
GasPrice = SmartContractMempoolValidator.MinGasPrice,
ContractCode = compilationResult.Compilation.ToHexString(),
FeeAmount = "0.001",
Password = Password,
WalletName = WalletName,
Sender = addr.Address
};
JsonResult result = (JsonResult)senderSmartContractsController.BuildCreateSmartContractTransaction(buildRequest);
var response = (BuildCreateContractTransactionResponse)result.Value;
TestHelper.Connect(scSender, scReceiver);
SmartContractSharedSteps.SendTransaction(scSender, scReceiver, senderWalletController, response.Hex);
TestHelper.MineBlocks(scReceiver, 2);
TestHelper.WaitLoop(() => TestHelper.AreNodesSynced(scReceiver, scSender));
// Make a call request where the MethodName is the name of a property
var callRequest = new BuildCallContractTransactionRequest
{
AccountName = AccountName,
GasLimit = gasLimit,
GasPrice = SmartContractMempoolValidator.MinGasPrice,
Amount = "0",
MethodName = "Counter",
ContractAddress = response.NewContractAddress,
FeeAmount = "0.001",
Password = Password,
WalletName = WalletName,
Sender = addr.Address
};
result = (JsonResult)senderSmartContractsController.LocalCallSmartContractTransaction(callRequest);
var callResponse = (ILocalExecutionResult)result.Value;
// Check that the locally executed transaction returns the correct results
Assert.Equal(12345, callResponse.Return);
Assert.False(callResponse.Revert);
Assert.True(callResponse.GasConsumed > 0);
Assert.Null(callResponse.ErrorMessage);
Assert.NotNull(callResponse.InternalTransfers);
TestHelper.MineBlocks(scReceiver, 2);
TestHelper.WaitLoop(() => TestHelper.AreNodesSynced(scReceiver, scSender));
}
}
public StateTransitionError(Gas gasConsumed, StateTransitionErrorKind kind, ContractErrorMessage vmError)
{
this.Kind = kind;
this.GasConsumed = gasConsumed;
this.VmError = vmError;
}
public void SendAndReceiveSmartContractTransactions()
{
using (NodeBuilder builder = NodeBuilder.Create(this))
{
CoreNode scSender = builder.CreateSmartContractPowNode();
CoreNode scReceiver = builder.CreateSmartContractPowNode();
builder.StartAll();
scSender.NotInIBD();
scReceiver.NotInIBD();
scSender.FullNode.WalletManager().CreateWallet(Password, WalletName, Passphrase);
scReceiver.FullNode.WalletManager().CreateWallet(Password, WalletName, Passphrase);
HdAddress addr = scSender.FullNode.WalletManager().GetUnusedAddress(new WalletAccountReference(WalletName, AccountName));
Features.Wallet.Wallet wallet = scSender.FullNode.WalletManager().GetWalletByName(WalletName);
Key key = wallet.GetExtendedPrivateKeyForAddress(Password, addr).PrivateKey;
scSender.SetDummyMinerSecret(new BitcoinSecret(key, scSender.FullNode.Network));
var maturity = (int)scSender.FullNode.Network.Consensus.CoinbaseMaturity;
scSender.GenerateStratisWithMiner(maturity + 5);
// Wait for block repo for block sync to work.
TestHelper.WaitLoop(() => TestHelper.IsNodeSynced(scSender));
// The mining should add coins to the wallet.
int spendableBlocks = GetSpendableBlocks(maturity + 5, maturity);
var total = scSender.FullNode.WalletManager().GetSpendableTransactionsInWallet(WalletName).Sum(s => s.Transaction.Amount);
Assert.Equal(Money.COIN * spendableBlocks * 50, total);
// Create a token contract.
ulong gasPrice = 1;
int vmVersion = 1;
Gas gasLimit = (Gas)2000;
SmartContractCompilationResult compilationResult = SmartContractCompiler.CompileFile("SmartContracts/TransferTest.cs");
Assert.True(compilationResult.Success);
var contractCarrier = SmartContractCarrier.CreateContract(vmVersion, compilationResult.Compilation, gasPrice, gasLimit);
var contractCreateScript = new Script(contractCarrier.Serialize());
var txBuildContext = new TransactionBuildContext(scSender.FullNode.Network)
{
AccountReference = new WalletAccountReference(WalletName, AccountName),
MinConfirmations = maturity,
FeeType = FeeType.High,
WalletPassword = Password,
Recipients = new[] { new Recipient {
Amount = 0, ScriptPubKey = contractCreateScript
} }.ToList()
};
Transaction transferContractTransaction = (scSender.FullNode.NodeService <IWalletTransactionHandler>() as SmartContractWalletTransactionHandler).BuildTransaction(txBuildContext);
// Broadcast the token transaction to the network.
scSender.FullNode.NodeService <IBroadcasterManager>().BroadcastTransactionAsync(transferContractTransaction);
// Wait for the token transaction to be picked up by the mempool.
TestHelper.WaitLoop(() => scSender.CreateRPCClient().GetRawMempool().Length > 0);
// Mine the token transaction and wait for it to sync.
scSender.GenerateStratisWithMiner(1);
TestHelper.WaitLoop(() => TestHelper.IsNodeSynced(scSender));
// Sync to the receiver node.
scSender.CreateRPCClient().AddNode(scReceiver.Endpoint, true);
TestHelper.WaitLoop(() => TestHelper.AreNodesSynced(scReceiver, scSender));
// Ensure that both nodes have the contract.
IContractStateRoot senderState = scSender.FullNode.NodeService <IContractStateRoot>();
IContractStateRoot receiverState = scReceiver.FullNode.NodeService <IContractStateRoot>();
IAddressGenerator addressGenerator = scSender.FullNode.NodeService <IAddressGenerator>();
uint160 tokenContractAddress = addressGenerator.GenerateAddress(transferContractTransaction.GetHash(), 0);
Assert.NotNull(senderState.GetCode(tokenContractAddress));
Assert.NotNull(receiverState.GetCode(tokenContractAddress));
scSender.FullNode.MempoolManager().Clear();
// Create a transfer token contract.
compilationResult = SmartContractCompiler.CompileFile("SmartContracts/TransferTest.cs");
Assert.True(compilationResult.Success);
contractCarrier = SmartContractCarrier.CreateContract(vmVersion, compilationResult.Compilation, gasPrice, gasLimit);
contractCreateScript = new Script(contractCarrier.Serialize());
txBuildContext = new TransactionBuildContext(scSender.FullNode.Network)
{
AccountReference = new WalletAccountReference(WalletName, AccountName),
MinConfirmations = maturity,
FeeType = FeeType.High,
WalletPassword = Password,
Recipients = new[] { new Recipient {
Amount = 0, ScriptPubKey = contractCreateScript
} }.ToList()
};
// Broadcast the token transaction to the network.
transferContractTransaction = (scSender.FullNode.NodeService <IWalletTransactionHandler>() as SmartContractWalletTransactionHandler).BuildTransaction(txBuildContext);
scSender.FullNode.NodeService <IBroadcasterManager>().BroadcastTransactionAsync(transferContractTransaction);
// Wait for the token transaction to be picked up by the mempool.
TestHelper.WaitLoop(() => scSender.CreateRPCClient().GetRawMempool().Length > 0);
scSender.GenerateStratisWithMiner(1);
// Ensure the node is synced.
TestHelper.WaitLoop(() => TestHelper.IsNodeSynced(scSender));
// Ensure both nodes are synced with each other.
TestHelper.WaitLoop(() => TestHelper.AreNodesSynced(scReceiver, scSender));
// Ensure that both nodes have the contract.
senderState = scSender.FullNode.NodeService <IContractStateRoot>();
receiverState = scReceiver.FullNode.NodeService <IContractStateRoot>();
tokenContractAddress = addressGenerator.GenerateAddress(transferContractTransaction.GetHash(), 0);
Assert.NotNull(senderState.GetCode(tokenContractAddress));
Assert.NotNull(receiverState.GetCode(tokenContractAddress));
scSender.FullNode.MempoolManager().Clear();
// Create a call contract transaction which will transfer funds.
contractCarrier = SmartContractCarrier.CallContract(1, tokenContractAddress, "Test", gasPrice, gasLimit);
Script contractCallScript = new Script(contractCarrier.Serialize());
txBuildContext = new TransactionBuildContext(scSender.FullNode.Network)
{
AccountReference = new WalletAccountReference(WalletName, AccountName),
MinConfirmations = maturity,
FeeType = FeeType.High,
WalletPassword = Password,
Recipients = new[] { new Recipient {
Amount = 1000, ScriptPubKey = contractCallScript
} }.ToList()
};
// Broadcast the token transaction to the network.
transferContractTransaction = (scSender.FullNode.NodeService <IWalletTransactionHandler>() as SmartContractWalletTransactionHandler).BuildTransaction(txBuildContext);
scSender.FullNode.NodeService <IBroadcasterManager>().BroadcastTransactionAsync(transferContractTransaction);
TestHelper.WaitLoop(() => scSender.CreateRPCClient().GetRawMempool().Length > 0);
// Mine the transaction.
scSender.GenerateStratisWithMiner(1);
// Ensure the nodes are synced
TestHelper.WaitLoop(() => TestHelper.IsNodeSynced(scSender));
TestHelper.WaitLoop(() => TestHelper.AreNodesSynced(scReceiver, scSender));
// The balance should now reflect the transfer.
Assert.Equal((ulong)900, senderState.GetCurrentBalance(tokenContractAddress));
}
}
private Result <ContractTxData> SerializeCallContract(byte[] smartContractBytes, int vmVersion, ulong gasPrice, Gas gasLimit)
{
var contractAddressBytes = smartContractBytes.Slice(PrefixSize, AddressSize);
var contractAddress = new uint160(contractAddressBytes);
var remaining = smartContractBytes.Slice(CallContractPrefixSize,
(uint)(smartContractBytes.Length - CallContractPrefixSize));
IList <byte[]> decodedParams = RLPDecode(remaining);
var methodName = this.primitiveSerializer.Deserialize <string>(decodedParams[0]);
var methodParameters = this.DeserializeMethodParameters(decodedParams[1]);
var callData = new ContractTxData(vmVersion, gasPrice, gasLimit, contractAddress, methodName, methodParameters);
return(Result.Ok(callData));
}
protected virtual Result <ContractTxData> SerializeCreateContract(byte[] smartContractBytes, int vmVersion, ulong gasPrice, Gas gasLimit)
{
byte[] remaining = smartContractBytes.Slice(PrefixSize, (uint)(smartContractBytes.Length - PrefixSize));
IList <byte[]> decodedParams = RLPDecode(remaining);
var contractExecutionCode = this.primitiveSerializer.Deserialize <byte[]>(decodedParams[0]);
object[] methodParameters = this.DeserializeMethodParameters(decodedParams[1]);
var callData = new ContractTxData(vmVersion, gasPrice, gasLimit, contractExecutionCode, methodParameters);
return(Result.Ok(callData));
}
public Button( Renderer renderer, Cursor cursor, Gas.Graphics.Font font, Surface unpressedSurf,
Surface pressedSurf, string text, Vector2 position)
{
this.renderer = renderer;
this.cursor = cursor;
this.font = font;
this.unpressedSurf = unpressedSurf;
this.pressedSurf = pressedSurf;
this.text = text;
this.position = position;
this.cursor.Clicked += new EventHandler( OnCursorClicked );
this.cursor.Unclicked += new EventHandler( OnCursorUnclicked );
CreateTextSurface( text );
}
