public void ShouldConvertFromWeiAndBackToEth()
{
var unitConversion = new UnitConversion();
var val = BigInteger.Parse("1000000000000000000000000001");
var result = unitConversion.FromWei(val, 18);
var result2 = unitConversion.FromWei(val);
Assert.Equal(result, result2);
result2 = unitConversion.FromWei(val, BigInteger.Parse("1000000000000000000"));
Assert.Equal(result, result2);
Assert.Equal(val, UnitConversion.Convert.ToWei(result));
}
public ChainSimulator(Nexus nexus, KeyPair ownerKey, int seed, Logger logger = null)
{
this.Logger = logger != null ? logger : new DummyLogger();
_owner = ownerKey;
this.Nexus = nexus;
CurrentTime = new DateTime(2018, 8, 26);
if (!Nexus.Ready)
{
if (!Nexus.CreateGenesisBlock("simnet", _owner, CurrentTime))
{
throw new ChainException("Genesis block failure");
}
}
this.bankChain = Nexus.FindChainByName("bank");
_rnd = new Random(seed);
_keys.Add(_owner);
var oneFuel = UnitConversion.ToBigInteger(1, Nexus.FuelTokenDecimals);
var localBalance = Nexus.RootChain.GetTokenBalance(Nexus.FuelTokenSymbol, _owner.Address);
if (localBalance < oneFuel)
{
throw new Exception("Funds missing oops");
}
var neoPlatform = Pay.Chains.NeoWallet.NeoPlatform;
var neoKeys = InteropUtils.GenerateInteropKeys(_owner, neoPlatform);
var neoText = Phantasma.Neo.Core.NeoKey.FromWIF(neoKeys.ToWIF()).address;
var neoAddress = Phantasma.Pay.Chains.NeoWallet.EncodeAddress(neoText);
var ethPlatform = Pay.Chains.EthereumWallet.EthereumPlatform;
var ethKeys = InteropUtils.GenerateInteropKeys(_owner, ethPlatform);
var ethText = Phantasma.Ethereum.EthereumKey.FromWIF(ethKeys.ToWIF()).address;
var ethAddress = Phantasma.Pay.Chains.EthereumWallet.EncodeAddress(ethText);
BeginBlock();
GenerateAppRegistration(_owner, "mystore", "https://my.store", "The future of digital content distribution!");
GenerateCustomTransaction(_owner, 0, () => new ScriptBuilder().AllowGas(_owner.Address, Address.Null, MinimumFee, 9999).
CallContract("nexus", "CreatePlatform", neoAddress, "GAS").
CallContract("nexus", "CreatePlatform", ethAddress, "ETH").
SpendGas(_owner.Address).EndScript());
GenerateToken(_owner, "NEO", "NEO", neoPlatform, Hash.FromUnpaddedHex("c56f33fc6ecfcd0c225c4ab356fee59390af8560be0e930faebe74a6daff7c9b"), UnitConversion.ToBigInteger(100000000, 0), 0, TokenFlags.Fungible | TokenFlags.Transferable | TokenFlags.Finite | TokenFlags.External);
GenerateToken(_owner, "GAS", "GAS", neoPlatform, Hash.FromUnpaddedHex("602c79718b16e442de58778e148d0b1084e3b2dffd5de6b7b16cee7969282de7"), UnitConversion.ToBigInteger(100000000, 8), 8, TokenFlags.Fungible | TokenFlags.Transferable | TokenFlags.Divisible | TokenFlags.Finite | TokenFlags.External);
GenerateToken(_owner, "ETH", "Ethereum", ethPlatform, Hash.FromString("ETH"), UnitConversion.ToBigInteger(0, 18), 18, TokenFlags.Fungible | TokenFlags.Transferable | TokenFlags.Divisible | TokenFlags.External);
GenerateToken(_owner, "DAI", "Dai Stablecoin", ethPlatform, Hash.FromUnpaddedHex("89d24a6b4ccb1b6faa2625fe562bdd9a23260359"), UnitConversion.ToBigInteger(0, 18), 18, TokenFlags.Fungible | TokenFlags.Transferable | TokenFlags.Divisible | TokenFlags.External);
//GenerateToken(_owner, "EOS", "EOS", "EOS", UnitConversion.ToBigInteger(1006245120, 18), 18, TokenFlags.Fungible | TokenFlags.Transferable | TokenFlags.Finite | TokenFlags.Divisible | TokenFlags.External);
EndBlock();
/*
* var market = Nexus.FindChainByName("market");
* var nftSales = new List<KeyValuePair<KeyPair, BigInteger>>();
*
* BeginBlock();
* for (int i = 1; i < 7; i++)
* {
* BigInteger ID = i + 100;
* TokenContent info;
* try
* {
* info = Nexus.GetNFT(nachoSymbol, ID);
* }
* catch
* {
* continue;
* }
*
* var chain = Nexus.FindChainByAddress(info.CurrentChain);
* if (chain == null)
* {
* continue;
* }
*
* var nftOwner = chain.GetTokenOwner(nachoSymbol, ID);
*
* if (nftOwner == Address.Null)
* {
* continue;
* }
*
* foreach (var key in _keys)
* {
* if (key.Address == nftOwner)
* {
* nftSales.Add(new KeyValuePair<KeyPair, BigInteger>(key, ID));
* // send some gas to the sellers
* GenerateTransfer(_owner, key.Address, Nexus.RootChain, Nexus.FuelTokenSymbol, UnitConversion.ToBigInteger(0.01m, Nexus.FuelTokenDecimals));
* }
* }
* }
*
* EndBlock();
*
* BeginBlock();
* foreach (var sale in nftSales)
* {
* // TODO this later should be the market chain instead of root
* GenerateNftSale(sale.Key, Nexus.RootChain, nachoSymbol, sale.Value, UnitConversion.ToBigInteger(100 + 5 * _rnd.Next() % 50, Nexus.FuelTokenDecimals));
* }
* EndBlock();
*/
}
public static BigInteger StakeToFuel(BigInteger stakeAmount, uint _BaseEnergyRatioDivisor)
{
return(UnitConversion.ConvertDecimals(stakeAmount, DomainSettings.StakingTokenDecimals, DomainSettings.FuelTokenDecimals) / _BaseEnergyRatioDivisor);
}
public void MeshLoadProfiling()
{
var k3d = new Toolkit();
int nBeams = 20;
int nFaces = 1500;
double lengthBeams = 10.0;
double xIncBeam = lengthBeams / nBeams;
double xIncMesh = lengthBeams / nFaces;
double limit_dist = xIncBeam / 100.0;
// create beams
var lines = new List <Line3>();
var nodeI = new Point3(0, 0, 0);
for (int beamInd = 0; beamInd < nBeams; ++beamInd)
{
var nodeK = new Point3(nodeI.X + xIncBeam, 0, 0);
lines.Add(new Line3(nodeI, nodeK));
nodeI = nodeK;
}
LineToBeam.solve(new List <Point3>(), lines, true, true, limit_dist, new List <Vector3>(), new List <string>(),
new List <Color>(), new List <CroSec>(), true,
out List <Point3> outPoints, out List <BuilderBeam> builderElements, out string info);
// create a MeshLoad
var meshUnitLoadsBuffer = new Dictionary <MeshUnitLoad, MeshUnitLoad>();
var mesh = new Mesh();
mesh.Vertices.Add(new Point3d(0, -0.5, 0));
mesh.Vertices.Add(new Point3d(0, 0.5, 0));
for (var faceInd = 0; faceInd < nFaces; ++faceInd)
{
mesh.Vertices.Add(new Point3d((faceInd + 1) * xIncMesh, -0.5, 0));
mesh.Vertices.Add(new Point3d((faceInd + 1) * xIncMesh, 0.5, 0));
var nV = mesh.Vertices.Count;
mesh.Faces.AddFace(new MeshFace(nV - 4, nV - 3, nV - 1, nV - 2));
}
UnitsConversionFactory ucf = UnitsConversionFactories.Conv();
UnitConversion m = ucf.m();
var baseMesh = m.toBaseMesh(new RhinoMesh(mesh));
var load = new MeshLoad(new List <Vector3>()
{
new Vector3(0, 0, -1)
});
load.InitUnitLoads(meshUnitLoadsBuffer, baseMesh, LoadOrientation.global, new List <bool>()
{
true, true
},
new List <Point3>(), new List <string>());
// create a Support
var support = k3d.Support.Support(new Point3(0, 0, 0), k3d.Support.SupportFixedConditions);
// assemble the model
var model = k3d.Model.AssembleModel(builderElements, new List <Support>()
{
support
}, new List <Load>()
{
load
},
out info, out var mass, out var cog, out var msg, out var runtimeWarning);
ThIAnalyze.solve(model, out var outMaxDisp, out var outG, out var outComp, out var warning, out model);
Assert.AreEqual(outMaxDisp[0], 2.8232103119331837, 1E-5);
// Assert.AreEqual(1, 1, 1E-8);
}
public OSM_To_Revit(Length_Unit_Types OSM_unit)
{
//revit uses double values to represent feet imperial unit
this.unitConversion = new UnitConversion(OSM_unit, Length_Unit_Types.FEET);
}
public void SingleUploadSuccess()
{
var owner = KeyPair.Generate();
var simulator = new ChainSimulator(owner, 1234);
var nexus = simulator.Nexus;
var testUser = KeyPair.Generate();
var accountBalance = MinimumValidStake * 5;
Transaction tx = null;
simulator.BeginBlock();
simulator.GenerateTransfer(owner, testUser.Address, nexus.RootChain, Nexus.FuelTokenSymbol, 100000000);
simulator.GenerateTransfer(owner, testUser.Address, nexus.RootChain, Nexus.StakingTokenSymbol, accountBalance);
simulator.EndBlock();
//-----------
//Perform a valid Stake call for minimum staking amount
var stakeAmount = accountBalance / 2;
var startingSoulBalance = simulator.Nexus.RootChain.GetTokenBalance(Nexus.StakingTokenSymbol, testUser.Address);
simulator.BeginBlock();
tx = simulator.GenerateCustomTransaction(testUser, () =>
ScriptUtils.BeginScript().AllowGas(testUser.Address, Address.Null, 1, 9999)
.CallContract("energy", "Stake", testUser.Address, stakeAmount).
SpendGas(testUser.Address).EndScript());
simulator.EndBlock();
BigInteger stakedAmount = (BigInteger)simulator.Nexus.RootChain.InvokeContract("energy", "GetStake", testUser.Address);
Assert.IsTrue(stakedAmount == stakeAmount);
var finalSoulBalance = simulator.Nexus.RootChain.GetTokenBalance(Nexus.StakingTokenSymbol, testUser.Address);
Assert.IsTrue(stakeAmount == startingSoulBalance - finalSoulBalance);
//-----------
//Upload a file: should succeed
var filename = "notAVirus.exe";
var headerSize = CalculateRequiredSize(filename, 0);
var contentSize = (long)(((UnitConversion.ToDecimal(stakedAmount, Nexus.StakingTokenDecimals)) * KilobytesPerStake) * 1024) - (long)headerSize;
var content = new byte[contentSize];
var rnd = new Random();
for (int i = 0; i < content.Length; i++)
{
content[i] = (byte)rnd.Next();
}
var contentMerkle = new MerkleTree(content);
simulator.BeginBlock();
tx = simulator.GenerateCustomTransaction(testUser, () =>
ScriptUtils.BeginScript().AllowGas(testUser.Address, Address.Null, 1, 9999)
.CallContract("storage", "UploadFile", testUser.Address, filename, contentSize, contentMerkle, ArchiveFlags.None, new byte[0]).
SpendGas(testUser.Address).EndScript());
//System.IO.File.WriteAllText(@"c:\code\bug_vm.txt", string.Join('\n', new VM.Disassembler(tx.Script).Instructions));
simulator.EndBlock();
var usedSpace = (BigInteger)simulator.Nexus.RootChain.InvokeContract("storage", "GetUsedSpace", testUser.Address);
Assert.IsTrue(usedSpace == 0);
Assert.IsTrue(simulator.Nexus.ArchiveExists(contentMerkle.Root));
var archive = simulator.Nexus.FindArchive(contentMerkle.Root);
for (int i = 0; i < archive.BlockCount; i++)
{
int ofs = (int)(i * Archive.BlockSize);
var blockContent = content.Skip(ofs).Take((int)Archive.BlockSize).ToArray();
simulator.Nexus.WriteArchiveBlock(archive, blockContent, i);
}
}
public static string GetTxDescription(TransactionDto tx, List <ChainDto> phantasmaChains, List <TokenDto> phantasmaTokens, string addressfrom)
{
string description = null;
string senderToken = null;
string senderChain = phantasmaChains.Where(x => x.Address == tx.ChainAddress).Select(x => x.Name).FirstOrDefault();
Address senderAddress = Address.Null;
string receiverToken = null;
string receiverChain = "";
Address receiverAddress = Address.Null;
BigInteger amount = 0;
foreach (var evt in tx.Events)
{
switch (evt.EventKind)
{
case EventKind.TokenClaim:
{
var data = Serialization.Unserialize <TokenEventData>(evt.Data.Decode());
if (data.Symbol == "SOUL")
{
return(description = $"Custom transaction");
}
}
break;
case EventKind.TokenStake:
{
var data = Serialization.Unserialize <TokenEventData>(evt.Data.Decode());
amount = data.Value;
if (amount >= 1000000000)
{
if (data.Symbol != "KCAL" && data.Symbol != "NEO" && data.Symbol != "GAS")
{
//return description = $"Stake transaction";
return(description = $"Custom transaction");
}
}
}
break;
case EventKind.TokenMint:
{
var data = Serialization.Unserialize <TokenEventData>(evt.Data.Decode());
if (data.Symbol == "TTRS")
{
return(description = $"Custom transaction");
}
return(description = $"Claim transaction");
}
break;
case EventKind.AddressRegister:
{
var name = Serialization.Unserialize <string>(evt.Data.Decode());
description = $"Register transaction: name '{name}' registered";
}
break;
case EventKind.TokenSend:
{
var data = Serialization.Unserialize <TokenEventData>(evt.Data.Decode());
amount = data.Value;
senderAddress = Address.FromText(evt.EventAddress);
senderToken = data.Symbol;
}
break;
case EventKind.TokenReceive:
{
var data = Serialization.Unserialize <TokenEventData>(evt.Data.Decode());
amount = data.Value;
receiverAddress = Address.FromText(evt.EventAddress);
receiverChain = data.ChainName;
receiverToken = data.Symbol;
}
break;
}
}
if (description == null)
{
if (amount > 0 && senderAddress != Address.Null && receiverAddress != Address.Null &&
senderToken != null && senderToken == receiverToken)
{
var amountDecimal = UnitConversion.ToDecimal(amount, phantasmaTokens.Single(p => p.Symbol == senderToken).Decimals);
if (addressfrom == senderAddress.ToString())
{
description =
$"Send transaction: to {receiverAddress.ToString()}";
}
else
{
description =
$"Receive transaction: from {senderAddress.ToString()}";
}
}
else if (amount > 0 && receiverAddress != Address.Null && receiverToken != null)
{
var amountDecimal = UnitConversion.ToDecimal(amount, phantasmaTokens.Single(p => p.Symbol == receiverToken).Decimals);
description = $"Send transaction: to {receiverAddress.Text} ";
}
else
{
description = "Custom transaction";
}
}
return(description);
}
private void Start()
{
startScale = transform.localScale;
startPosition = UnitConversion.PointToScreenRatio(transform.position);
Update();
}
/*
* TODO: implement methods that allow cleaning up the order history book.. make sure only the exchange that placed the orders can clear them
*/
/*
* TODO: implement code for trail stops and a method to allow a 3rd party to update the trail stop, without revealing user or order info
*/
public BigInteger CalculateEscrowAmount(BigInteger orderSize, BigInteger orderPrice, TokenInfo baseToken, TokenInfo quoteToken, ExchangeOrderSide side)
{
switch (side)
{
case Sell:
return(orderSize);
case Buy:
return(UnitConversion.ToBigInteger(UnitConversion.ToDecimal(orderSize, baseToken.Decimals) * UnitConversion.ToDecimal(orderPrice, quoteToken.Decimals), quoteToken.Decimals));
default: throw new ContractException("invalid order side");
}
}
public void NoGasTestSideChainTransfer()
{
var owner = KeyPair.Generate();
var simulator = new ChainSimulator(owner, 1234);
var nexus = simulator.Nexus;
var sourceChain = nexus.RootChain;
var targetChain = nexus.FindChainByName("privacy");
var symbol = Nexus.FuelTokenSymbol;
var token = nexus.GetTokenInfo(symbol);
var sender = KeyPair.Generate();
var receiver = KeyPair.Generate();
var originalAmount = UnitConversion.ToBigInteger(10, token.Decimals);
var sideAmount = originalAmount / 2;
Assert.IsTrue(sideAmount > 0);
// Send from Genesis address to "sender" user
simulator.BeginBlock();
simulator.GenerateTransfer(owner, sender.Address, nexus.RootChain, symbol, originalAmount);
simulator.EndBlock();
// verify test user balance
var balance = nexus.RootChain.GetTokenBalance(symbol, sender.Address);
Assert.IsTrue(balance == originalAmount);
Transaction txA = null, txB = null;
try
{
// do a side chain send using test user balance from root to account chain
simulator.BeginBlock();
txA = simulator.GenerateSideChainSend(sender, symbol, sourceChain, receiver.Address, targetChain,
originalAmount, 1);
simulator.EndBlock();
}
catch (Exception e)
{
Assert.IsNotNull(e);
}
try
{
var blockA = nexus.RootChain.LastBlock;
// finish the chain transfer
simulator.BeginBlock();
txB = simulator.GenerateSideChainSettlement(sender, nexus.RootChain, targetChain, blockA.Hash);
Assert.IsTrue(simulator.EndBlock().Any());
}
catch (Exception e)
{
Assert.IsNotNull(e);
}
// verify balances, receiver should have 0 balance
balance = targetChain.GetTokenBalance(symbol, receiver.Address);
Assert.IsTrue(balance == 0);
}
public void SidechainNftTransfer()
{
var owner = KeyPair.Generate();
var simulator = new ChainSimulator(owner, 1234);
var nexus = simulator.Nexus;
var sourceChain = nexus.RootChain;
var targetChain = nexus.FindChainByName("privacy");
var nftSymbol = "COOL";
var sender = KeyPair.Generate();
var receiver = KeyPair.Generate();
var fullAmount = UnitConversion.ToBigInteger(10, Nexus.FuelTokenDecimals);
var smallAmount = fullAmount / 2;
Assert.IsTrue(smallAmount > 0);
// Send some SOUL to the test user (required for gas used in "transfer" transaction)
simulator.BeginBlock();
simulator.GenerateTransfer(owner, sender.Address, sourceChain, Nexus.FuelTokenSymbol, fullAmount);
simulator.EndBlock();
// Create the token CoolToken as an NFT
simulator.BeginBlock();
simulator.GenerateToken(owner, nftSymbol, "CoolToken", 0, 0, Blockchain.Tokens.TokenFlags.None);
simulator.EndBlock();
var token = simulator.Nexus.GetTokenInfo(nftSymbol);
var tokenData = new byte[] { 0x1, 0x3, 0x3, 0x7 };
Assert.IsTrue(nexus.TokenExists(nftSymbol), "Can't find the token symbol");
// verify nft presence on the sender pre-mint
var ownedTokenList = sourceChain.GetTokenOwnerships(nftSymbol).Get(sourceChain.Storage, sender.Address);
Assert.IsTrue(!ownedTokenList.Any(), "How does the sender already have a CoolToken?");
// Mint a new CoolToken directly on the sender
simulator.BeginBlock();
simulator.GenerateNft(owner, sender.Address, sourceChain, nftSymbol, tokenData, new byte[0]);
simulator.EndBlock();
// verify nft presence on the sender post-mint
ownedTokenList = sourceChain.GetTokenOwnerships(nftSymbol).Get(sourceChain.Storage, sender.Address);
Assert.IsTrue(ownedTokenList.Count() == 1, "How does the sender not have one now?");
//verify that the present nft is the same we actually tried to create
var tokenId = ownedTokenList.ElementAt(0);
var nft = nexus.GetNFT(nftSymbol, tokenId);
Assert.IsTrue(nft.ROM.SequenceEqual(tokenData) || nft.RAM.SequenceEqual(tokenData),
"And why is this NFT different than expected? Not the same data");
// verify nft presence on the receiver pre-transfer
ownedTokenList = targetChain.GetTokenOwnerships(nftSymbol).Get(targetChain.Storage, receiver.Address);
Assert.IsTrue(!ownedTokenList.Any(), "How does the receiver already have a CoolToken?");
var extraFee = UnitConversion.ToBigInteger(0.001m, Nexus.FuelTokenDecimals);
// transfer that nft from sender to receiver
simulator.BeginBlock();
simulator.GenerateSideChainSend(sender, Nexus.FuelTokenSymbol, sourceChain, receiver.Address, targetChain, smallAmount, extraFee);
var txA = simulator.GenerateNftSidechainTransfer(sender, receiver.Address, sourceChain, targetChain, nftSymbol, tokenId);
simulator.EndBlock();
var blockA = nexus.RootChain.LastBlock;
// finish the chain transfer
simulator.BeginBlock();
simulator.GenerateSideChainSettlement(receiver, nexus.RootChain, targetChain, blockA.Hash);
Assert.IsTrue(simulator.EndBlock().Any());
// verify the sender no longer has it
ownedTokenList = sourceChain.GetTokenOwnerships(nftSymbol).Get(sourceChain.Storage, sender.Address);
Assert.IsTrue(!ownedTokenList.Any(), "How does the sender still have one?");
// verify nft presence on the receiver post-transfer
ownedTokenList = targetChain.GetTokenOwnerships(nftSymbol).Get(targetChain.Storage, receiver.Address);
Assert.IsTrue(ownedTokenList.Count() == 1, "How does the receiver not have one now?");
//verify that the transfered nft is the same we actually tried to create
tokenId = ownedTokenList.ElementAt(0);
nft = nexus.GetNFT(nftSymbol, tokenId);
Assert.IsTrue(nft.ROM.SequenceEqual(tokenData) || nft.RAM.SequenceEqual(tokenData),
"And why is this NFT different than expected? Not the same data");
}
public void NftTransfer()
{
var owner = KeyPair.Generate();
var simulator = new ChainSimulator(owner, 1234);
var nexus = simulator.Nexus;
var chain = nexus.RootChain;
var nftKey = KeyPair.Generate();
var nftSymbol = "COOL";
var nftName = "CoolToken";
var sender = KeyPair.Generate();
var receiver = KeyPair.Generate();
// Send some SOUL to the test user (required for gas used in "transfer" transaction)
simulator.BeginBlock();
simulator.GenerateTransfer(owner, sender.Address, chain, Nexus.FuelTokenSymbol, UnitConversion.ToBigInteger(1, Nexus.FuelTokenDecimals));
simulator.EndBlock();
// Create the token CoolToken as an NFT
simulator.BeginBlock();
simulator.GenerateToken(owner, nftSymbol, nftName, 0, 0, Blockchain.Tokens.TokenFlags.None);
simulator.EndBlock();
var token = simulator.Nexus.GetTokenInfo(nftSymbol);
var tokenData = new byte[] { 0x1, 0x3, 0x3, 0x7 };
Assert.IsTrue(nexus.TokenExists(nftSymbol), "Can't find the token symbol");
// verify nft presence on the sender pre-mint
var ownedTokenList = chain.GetTokenOwnerships(nftSymbol).Get(chain.Storage, sender.Address);
Assert.IsTrue(!ownedTokenList.Any(), "How does the sender already have a CoolToken?");
// Mint a new CoolToken directly on the sender
simulator.BeginBlock();
simulator.GenerateNft(owner, sender.Address, chain, nftSymbol, tokenData, new byte[0]);
simulator.EndBlock();
// verify nft presence on the sender post-mint
ownedTokenList = chain.GetTokenOwnerships(nftSymbol).Get(chain.Storage, sender.Address);
Assert.IsTrue(ownedTokenList.Count() == 1, "How does the sender not have one now?");
//verify that the present nft is the same we actually tried to create
var tokenId = ownedTokenList.ElementAt(0);
var nft = nexus.GetNFT(nftSymbol, tokenId);
Assert.IsTrue(nft.ROM.SequenceEqual(tokenData) || nft.RAM.SequenceEqual(tokenData),
"And why is this NFT different than expected? Not the same data");
// verify nft presence on the receiver pre-transfer
ownedTokenList = chain.GetTokenOwnerships(nftSymbol).Get(chain.Storage, receiver.Address);
Assert.IsTrue(!ownedTokenList.Any(), "How does the receiver already have a CoolToken?");
// transfer that nft from sender to receiver
simulator.BeginBlock();
var txA = simulator.GenerateNftTransfer(sender, receiver.Address, chain, nftSymbol, tokenId);
simulator.EndBlock();
// verify nft presence on the receiver post-transfer
ownedTokenList = chain.GetTokenOwnerships(nftSymbol).Get(chain.Storage, receiver.Address);
Assert.IsTrue(ownedTokenList.Count() == 1, "How does the receiver not have one now?");
//verify that the transfered nft is the same we actually tried to create
tokenId = ownedTokenList.ElementAt(0);
nft = nexus.GetNFT(nftSymbol, tokenId);
Assert.IsTrue(nft.ROM.SequenceEqual(tokenData) || nft.RAM.SequenceEqual(tokenData),
"And why is this NFT different than expected? Not the same data");
}
public void SideChainTransferMultipleSteps()
{
var owner = KeyPair.Generate();
var simulator = new ChainSimulator(owner, 1234);
var nexus = simulator.Nexus;
var sourceChain = nexus.RootChain;
var appsChain = nexus.FindChainByName("apps");
var symbol = Nexus.FuelTokenSymbol;
var token = nexus.GetTokenInfo(symbol);
var sender = KeyPair.Generate();
var receiver = KeyPair.Generate();
var originalAmount = UnitConversion.ToBigInteger(10, token.Decimals);
var sideAmount = originalAmount / 2;
Assert.IsTrue(sideAmount > 0);
var newChainName = "testing";
// Send from Genesis address to "sender" user
simulator.BeginBlock();
simulator.GenerateTransfer(owner, sender.Address, nexus.RootChain, symbol, originalAmount);
simulator.GenerateChain(owner, appsChain, newChainName);
simulator.EndBlock();
var targetChain = nexus.FindChainByName(newChainName);
// verify test user balance
var balance = nexus.RootChain.GetTokenBalance(symbol, sender.Address);
Assert.IsTrue(balance == originalAmount);
// do a side chain send using test user balance from root to apps chain
simulator.BeginBlock();
var txA = simulator.GenerateSideChainSend(sender, symbol, sourceChain, sender.Address, appsChain, sideAmount, 0);
var blockA = simulator.EndBlock().FirstOrDefault();
// finish the chain transfer
simulator.BeginBlock();
var txB = simulator.GenerateSideChainSettlement(sender, nexus.RootChain, appsChain, blockA.Hash);
Assert.IsTrue(simulator.EndBlock().Any());
// we cant transfer the full side amount due to fees
// TODO calculate the proper fee values instead of this
sideAmount /= 2;
var extraFree = UnitConversion.ToBigInteger(0.01m, token.Decimals);
// do another side chain send using test user balance from apps to target chain
simulator.BeginBlock();
var txC = simulator.GenerateSideChainSend(sender, symbol, appsChain, receiver.Address, targetChain, sideAmount, extraFree);
var blockC = simulator.EndBlock().FirstOrDefault();
// finish the chain transfer
simulator.BeginBlock();
var txD = simulator.GenerateSideChainSettlement(sender, appsChain, targetChain, blockC.Hash);
Assert.IsTrue(simulator.EndBlock().Any());
// TODO verify balances
}
public void TransferToAccountName()
{
var owner = KeyPair.Generate();
var simulator = new ChainSimulator(owner, 1234);
var nexus = simulator.Nexus;
var symbol = Nexus.FuelTokenSymbol;
Func <KeyPair, string, bool> registerName = (keypair, name) =>
{
bool result = true;
try
{
simulator.BeginBlock();
var tx = simulator.GenerateAccountRegistration(keypair, name);
var lastBlock = simulator.EndBlock().FirstOrDefault();
if (lastBlock != null)
{
Assert.IsTrue(tx != null);
var evts = lastBlock.GetEventsForTransaction(tx.Hash);
Assert.IsTrue(evts.Any(x => x.Kind == Blockchain.Contracts.EventKind.AddressRegister));
}
}
catch (Exception)
{
result = false;
}
return(result);
};
var targetName = "hello";
var testUser = KeyPair.Generate();
var token = nexus.GetTokenInfo(symbol);
var amount = UnitConversion.ToBigInteger(10, token.Decimals);
simulator.BeginBlock();
simulator.GenerateTransfer(owner, testUser.Address, nexus.RootChain, symbol, amount);
simulator.EndBlock();
Assert.IsTrue(registerName(testUser, targetName));
// Send from Genesis address to test user
var transferAmount = 1;
var initialFuelBalance = simulator.Nexus.RootChain.GetTokenBalance(symbol, testUser.Address);
simulator.BeginBlock();
simulator.GenerateCustomTransaction(testUser, () =>
ScriptUtils.BeginScript().AllowGas(owner.Address, Address.Null, 1, 9999)
.CallContract("token", "TransferTokens", owner.Address, targetName, token.Symbol, transferAmount)
.SpendGas(owner.Address).EndScript());
simulator.EndBlock();
var finalFuelBalance = simulator.Nexus.RootChain.GetTokenBalance(symbol, testUser.Address);
Assert.IsTrue(finalFuelBalance - initialFuelBalance == transferAmount);
}
public void AccountRegister()
{
var owner = KeyPair.Generate();
var simulator = new ChainSimulator(owner, 1234);
var nexus = simulator.Nexus;
var symbol = Nexus.FuelTokenSymbol;
Func <KeyPair, string, bool> registerName = (keypair, name) =>
{
bool result = true;
try
{
simulator.BeginBlock();
var tx = simulator.GenerateAccountRegistration(keypair, name);
var lastBlock = simulator.EndBlock().FirstOrDefault();
if (lastBlock != null)
{
Assert.IsTrue(tx != null);
var evts = lastBlock.GetEventsForTransaction(tx.Hash);
Assert.IsTrue(evts.Any(x => x.Kind == Blockchain.Contracts.EventKind.AddressRegister));
}
}
catch (Exception)
{
result = false;
}
return(result);
};
var testUser = KeyPair.Generate();
var token = nexus.GetTokenInfo(symbol);
var amount = UnitConversion.ToBigInteger(10, token.Decimals);
// Send from Genesis address to test user
simulator.BeginBlock();
simulator.GenerateTransfer(owner, testUser.Address, nexus.RootChain, symbol, amount);
simulator.EndBlock();
// verify test user balance
var balance = nexus.RootChain.GetTokenBalance(symbol, testUser.Address);
Assert.IsTrue(balance == amount);
var targetName = "hello";
Assert.IsTrue(targetName == targetName.ToLower());
Assert.IsFalse(registerName(testUser, targetName.Substring(3)));
Assert.IsFalse(registerName(testUser, targetName.ToUpper()));
Assert.IsFalse(registerName(testUser, targetName + "!"));
Assert.IsTrue(registerName(testUser, targetName));
var currentName = nexus.LookUpAddress(testUser.Address);
Assert.IsTrue(currentName == targetName);
var someAddress = nexus.LookUpName(targetName);
Assert.IsTrue(someAddress == testUser.Address);
Assert.IsFalse(registerName(testUser, "other"));
}
public ActionResult PostMaterial(MaterialViewModel pvm)
{
Product pt1 = new Product();
ProductGroup group = new ProductGroupService(_unitOfWork).Find(pvm.ProductGroupId);
ProductType Type = new ProductTypeService(_unitOfWork).Find(group.ProductTypeId);
if (pvm.ProductGroupId <= 0)
{
ModelState.AddModelError("ProductGroupId", "Product Group field is required");
}
if (ModelState.IsValid)
{
//Checking for Create or Edit(<=0 =====>CREATE)
if (pvm.ProductId <= 0)
{
var ProductSKu = db.Product.Find(pvm.ProductSKUId);
var PRoductSize = db.ProductSize.Where(m => m.ProductId == ProductSKu.ProductId && m.ProductSizeTypeId == (int)ProductSizeTypeConstants.MapSize).FirstOrDefault();
var Size = db.Size.Find(PRoductSize.SizeId);
pt1.ProductName = pvm.ProductName;
pt1.ProductCode = pvm.ProductCode;
pt1.ProductGroupId = pvm.ProductGroupId;
pt1.StandardCost = pvm.StandardCost;
pt1.UnitId = pvm.UnitId;
pt1.SalesTaxGroupProductId = pvm.SalesTaxGroupProductId;
pt1.UnitId = UnitConstants.Pieces;
pt1.IsActive = pvm.IsActive;
pt1.DivisionId = pvm.DivisionId;
pt1.CreatedDate = DateTime.Now;
pt1.ModifiedDate = DateTime.Now;
pt1.CreatedBy = User.Identity.Name;
pt1.ModifiedBy = User.Identity.Name;
pt1.ReferenceDocId = pvm.ProductSKUId;
pt1.ReferenceDocTypeId = new DocumentTypeService(_unitOfWork).Find(MasterDocTypeConstants.Product).DocumentTypeId;
pt1.IsActive = true;
pt1.ObjectState = Model.ObjectState.Added;
_ProductService.Create(pt1);
//Standard Size Data
ProductSize standardsize = new ProductSize();
standardsize.ProductSizeTypeId = (int)(ProductSizeTypeConstants.StandardSize);
//standardsize.ProductSizeTypeId = 1;
standardsize.SizeId = PRoductSize.SizeId;
standardsize.ProductId = pt1.ProductId;
standardsize.CreatedBy = User.Identity.Name;
standardsize.CreatedDate = DateTime.Now;
standardsize.ModifiedBy = User.Identity.Name;
standardsize.ModifiedDate = DateTime.Now;
standardsize.IsActive = true;
new ProductSizeService(_unitOfWork).Create(standardsize);
UnitConversion UnitConv = new UnitConversion();
UnitConv.CreatedBy = User.Identity.Name;
UnitConv.CreatedDate = DateTime.Now;
UnitConv.ModifiedBy = User.Identity.Name;
UnitConv.ModifiedDate = DateTime.Now;
UnitConv.ProductId = pt1.ProductId;
UnitConv.FromQty = 1;
UnitConv.FromUnitId = UnitConstants.Pieces;
UnitConv.ToUnitId = UnitConstants.SqYard;
UnitConv.UnitConversionForId = (byte)UnitConversionFors.Standard;
using (SqlConnection sqlConnection = new SqlConnection((string)System.Web.HttpContext.Current.Session["DefaultConnectionString"]))
{
sqlConnection.Open();
SqlCommand Totalf = new SqlCommand("SELECT * FROM Web.FuncConvertSqFeetToSqYard( " + Size.Area + ")", sqlConnection);
UnitConv.ToQty = Convert.ToDecimal(Totalf.ExecuteScalar() == DBNull.Value ? 0 : Totalf.ExecuteScalar());
}
new UnitConversionService(_unitOfWork).Create(UnitConv);
try
{
_unitOfWork.Save();
}
catch (Exception ex)
{
string message = _exception.HandleException(ex);
ModelState.AddModelError("", message);
PrepareMaterialViewBag(null);
ViewBag.Name = Type.ProductTypeName;
ViewBag.id = group.ProductTypeId;
ViewBag.ProductGroupList = new ProductGroupService(_unitOfWork).GetProductGroupListForItemType(group.ProductTypeId);
return(View("CreateMaterial", pvm));
}
LogActivity.LogActivityDetail(LogVm.Map(new ActiivtyLogViewModel
{
DocTypeId = new DocumentTypeService(_unitOfWork).FindByName(MasterDocTypeConstants.Product).DocumentTypeId,
DocId = pt1.ProductId,
ActivityType = (int)ActivityTypeContants.Added,
}));
#region
//Saving Images if any uploaded after UnitOfWorkSave
if (Request.Files[0] != null && Request.Files[0].ContentLength > 0)
{
//For checking the first time if the folder exists or not-----------------------------
string uploadfolder;
int MaxLimit;
int.TryParse(ConfigurationManager.AppSettings["MaxFileUploadLimit"], out MaxLimit);
var x = (from iid in db.Counter
select iid).FirstOrDefault();
if (x == null)
{
uploadfolder = System.Guid.NewGuid().ToString();
Counter img = new Counter();
img.ImageFolderName = uploadfolder;
img.ModifiedBy = User.Identity.Name;
img.CreatedBy = User.Identity.Name;
img.ModifiedDate = DateTime.Now;
img.CreatedDate = DateTime.Now;
new CounterService(_unitOfWork).Create(img);
_unitOfWork.Save();
}
else
{
uploadfolder = x.ImageFolderName;
}
//For checking if the image contents length is greater than 100 then create a new folder------------------------------------
if (!Directory.Exists(System.Web.HttpContext.Current.Request.MapPath("~/Uploads/" + uploadfolder)))
{
Directory.CreateDirectory(System.Web.HttpContext.Current.Request.MapPath("~/Uploads/" + uploadfolder));
}
int count = Directory.GetFiles(System.Web.HttpContext.Current.Request.MapPath("~/Uploads/" + uploadfolder)).Length;
if (count >= MaxLimit)
{
uploadfolder = System.Guid.NewGuid().ToString();
var u = new CounterService(_unitOfWork).Find(x.CounterId);
u.ImageFolderName = uploadfolder;
new CounterService(_unitOfWork).Update(u);
_unitOfWork.Save();
}
//Saving Thumbnails images:
Dictionary <string, string> versions = new Dictionary <string, string>();
//Define the versions to generate
versions.Add("_thumb", "maxwidth=100&maxheight=100"); //Crop to square thumbnail
versions.Add("_medium", "maxwidth=200&maxheight=200"); //Fit inside 400x400 area, jpeg
string temp2 = "";
string filename = System.Guid.NewGuid().ToString();
foreach (string filekey in System.Web.HttpContext.Current.Request.Files.Keys)
{
HttpPostedFile pfile = System.Web.HttpContext.Current.Request.Files[filekey];
if (pfile.ContentLength <= 0)
{
continue; //Skip unused file controls.
}
temp2 = Path.GetExtension(pfile.FileName);
string uploadFolder = System.Web.HttpContext.Current.Request.MapPath("~/Uploads/" + uploadfolder);
if (!Directory.Exists(uploadFolder))
{
Directory.CreateDirectory(uploadFolder);
}
string filecontent = Path.Combine(uploadFolder, pvm.ProductName + "_" + filename);
//pfile.SaveAs(filecontent);
ImageBuilder.Current.Build(new ImageJob(pfile, filecontent, new Instructions(), false, true));
//Generate each version
foreach (string suffix in versions.Keys)
{
if (suffix == "_thumb")
{
string tuploadFolder = System.Web.HttpContext.Current.Request.MapPath("~/Uploads/" + uploadfolder + "/Thumbs");
if (!Directory.Exists(tuploadFolder))
{
Directory.CreateDirectory(tuploadFolder);
}
//Generate a filename (GUIDs are best).
string tfileName = Path.Combine(tuploadFolder, pvm.ProductName + "_" + filename);
//Let the image builder add the correct extension based on the output file type
//fileName = ImageBuilder.Current.Build(file, fileName, new ResizeSettings(versions[suffix]), false, true);
ImageBuilder.Current.Build(new ImageJob(pfile, tfileName, new Instructions(versions[suffix]), false, true));
}
else if (suffix == "_medium")
{
string tuploadFolder = System.Web.HttpContext.Current.Request.MapPath("~/Uploads/" + uploadfolder + "/Medium");
if (!Directory.Exists(tuploadFolder))
{
Directory.CreateDirectory(tuploadFolder);
}
//Generate a filename (GUIDs are best).
string tfileName = Path.Combine(tuploadFolder, pvm.ProductName + "_" + filename);
//Let the image builder add the correct extension based on the output file type
//fileName = ImageBuilder.Current.Build(file, fileName, new ResizeSettings(versions[suffix]), false, true);
ImageBuilder.Current.Build(new ImageJob(pfile, tfileName, new Instructions(versions[suffix]), false, true));
}
}
//var tempsave = _FinishedProductService.Find(pt.ProductId);
var tempsave = _ProductService.Find(pt1.ProductId);
tempsave.ImageFileName = pvm.ProductName + "_" + filename + temp2;
tempsave.ImageFolderName = uploadfolder;
_ProductService.Update(tempsave);
_unitOfWork.Save();
}
}
#endregion
return(RedirectToAction("CreateMaterial", new { id = group.ProductTypeId }).Success("Data saved successfully"));
}
else
{
List <LogTypeViewModel> LogList = new List <LogTypeViewModel>();
Product pt = _ProductService.Find(pvm.ProductId);
Product ExRec = Mapper.Map <Product>(pt);
pt.ProductName = pvm.ProductName;
pt.ProductCode = pvm.ProductCode;
pt.StandardCost = pvm.StandardCost;
pt.ProductGroupId = pvm.ProductGroupId;
pt.SalesTaxGroupProductId = pvm.SalesTaxGroupProductId;
pt.IsActive = pvm.IsActive;
pt.ModifiedDate = DateTime.Now;
pt.ModifiedBy = User.Identity.Name;
pt.ObjectState = Model.ObjectState.Modified;
_ProductService.Update(pt);
LogList.Add(new LogTypeViewModel
{
ExObj = ExRec,
Obj = pt,
});
XElement Modifications = new ModificationsCheckService().CheckChanges(LogList);
try
{
_unitOfWork.Save();
}
catch (Exception ex)
{
string message = _exception.HandleException(ex);
ModelState.AddModelError("", message);
PrepareMaterialViewBag(pvm);
ViewBag.Name = Type.ProductTypeName;
ViewBag.id = group.ProductTypeId;
ViewBag.ProductGroupList = new ProductGroupService(_unitOfWork).GetProductGroupListForItemType(group.ProductTypeId);
return(View("CreateMaterial", pvm));
}
LogActivity.LogActivityDetail(LogVm.Map(new ActiivtyLogViewModel
{
DocTypeId = new DocumentTypeService(_unitOfWork).FindByName(MasterDocTypeConstants.Product).DocumentTypeId,
DocId = pt.ProductId,
ActivityType = (int)ActivityTypeContants.Modified,
xEModifications = Modifications,
}));
#region
//Saving Image if file is uploaded
if (Request.Files[0] != null && Request.Files[0].ContentLength > 0)
{
string uploadfolder = pt.ImageFolderName;
string tempfilename = pt.ImageFileName;
if (uploadfolder == null)
{
var x = (from iid in db.Counter
select iid).FirstOrDefault();
if (x == null)
{
uploadfolder = System.Guid.NewGuid().ToString();
Counter img = new Counter();
img.ImageFolderName = uploadfolder;
img.ModifiedBy = User.Identity.Name;
img.CreatedBy = User.Identity.Name;
img.ModifiedDate = DateTime.Now;
img.CreatedDate = DateTime.Now;
new CounterService(_unitOfWork).Create(img);
_unitOfWork.Save();
}
else
{
uploadfolder = x.ImageFolderName;
}
}
//Deleting Existing Images
var xtemp = System.Web.HttpContext.Current.Server.MapPath("~/Uploads/" + uploadfolder + "/" + tempfilename);
if (System.IO.File.Exists(System.Web.HttpContext.Current.Server.MapPath("~/Uploads/" + uploadfolder + "/" + tempfilename)))
{
System.IO.File.Delete(System.Web.HttpContext.Current.Server.MapPath("~/Uploads/" + uploadfolder + "/" + tempfilename));
}
//Deleting Thumbnail Image:
if (System.IO.File.Exists(System.Web.HttpContext.Current.Server.MapPath("~/Uploads/" + uploadfolder + "/Thumbs/" + tempfilename)))
{
System.IO.File.Delete(System.Web.HttpContext.Current.Server.MapPath("~/Uploads/" + uploadfolder + "/Thumbs/" + tempfilename));
}
//Deleting Medium Image:
if (System.IO.File.Exists(System.Web.HttpContext.Current.Server.MapPath("~/Uploads/" + uploadfolder + "/Medium/" + tempfilename)))
{
System.IO.File.Delete(System.Web.HttpContext.Current.Server.MapPath("~/Uploads/" + uploadfolder + "/Medium/" + tempfilename));
}
//Saving Thumbnails images:
Dictionary <string, string> versions = new Dictionary <string, string>();
//Define the versions to generate
versions.Add("_thumb", "maxwidth=100&maxheight=100"); //Crop to square thumbnail
versions.Add("_medium", "maxwidth=200&maxheight=200"); //Fit inside 400x400 area, jpeg
var temo = pt.ProductName.Replace(" ", string.Empty);
string temp2 = "";
string filename = System.Guid.NewGuid().ToString();
foreach (string filekey in System.Web.HttpContext.Current.Request.Files.Keys)
{
HttpPostedFile pfile = System.Web.HttpContext.Current.Request.Files[filekey];
if (pfile.ContentLength <= 0)
{
continue; //Skip unused file controls.
}
temp2 = Path.GetExtension(pfile.FileName);
string uploadFolder = System.Web.HttpContext.Current.Request.MapPath("~/Uploads/" + uploadfolder);
if (!Directory.Exists(uploadFolder))
{
Directory.CreateDirectory(uploadFolder);
}
string filecontent = Path.Combine(uploadFolder, pt.ProductName + "_" + filename);
//pfile.SaveAs(filecontent);
ImageBuilder.Current.Build(new ImageJob(pfile, filecontent, new Instructions(), false, true));
//Generate each version
foreach (string suffix in versions.Keys)
{
if (suffix == "_thumb")
{
string tuploadFolder = System.Web.HttpContext.Current.Request.MapPath("~/Uploads/" + uploadfolder + "/Thumbs");
if (!Directory.Exists(tuploadFolder))
{
Directory.CreateDirectory(tuploadFolder);
}
//Generate a filename (GUIDs are best).
string tfileName = Path.Combine(tuploadFolder, pt.ProductName + "_" + filename);
//Let the image builder add the correct extension based on the output file type
//fileName = ImageBuilder.Current.Build(file, fileName, new ResizeSettings(versions[suffix]), false, true);
ImageBuilder.Current.Build(new ImageJob(pfile, tfileName, new Instructions(versions[suffix]), false, true));
}
else if (suffix == "_medium")
{
string tuploadFolder = System.Web.HttpContext.Current.Request.MapPath("~/Uploads/" + uploadfolder + "/Medium");
if (!Directory.Exists(tuploadFolder))
{
Directory.CreateDirectory(tuploadFolder);
}
//Generate a filename (GUIDs are best).
string tfileName = Path.Combine(tuploadFolder, pt.ProductName + "_" + filename);
//Let the image builder add the correct extension based on the output file type
//fileName = ImageBuilder.Current.Build(file, fileName, new ResizeSettings(versions[suffix]), false, true);
ImageBuilder.Current.Build(new ImageJob(pfile, tfileName, new Instructions(versions[suffix]), false, true));
}
}
}
var temsave = _ProductService.Find(pt.ProductId);
temsave.ImageFileName = pt.ProductName + "_" + filename + temp2;
temsave.ImageFolderName = uploadfolder;
_ProductService.Update(temsave);
_unitOfWork.Save();
}
#endregion
return(RedirectToAction("MaterialIndex", new { id = group.ProductTypeId }).Success("Data saved successfully"));
}
}
PrepareMaterialViewBag(pvm);
return(View("CreateMaterial", pvm));
}
private BigInteger ConvertQuoteToBase(BigInteger quoteAmount, BigInteger orderPrice, TokenInfo baseToken, TokenInfo quoteToken)
{
return(UnitConversion.ToBigInteger(UnitConversion.ToDecimal(quoteAmount, quoteToken.Decimals) / UnitConversion.ToDecimal(orderPrice, quoteToken.Decimals), baseToken.Decimals));
}
void ApplyPosition(Vector2 position)
{
transform.position = UnitConversion.ScreenRatioToPoint(position);
transform.localScale = startScale * (1f - perspective);
}
public void TestTransactions()
{
InitMainNode();
int addressCount = 20;
LinkedList <KeyPair> addressList = new LinkedList <KeyPair>();
for (int i = 0; i < addressCount; i++)
{
var key = KeyPair.Generate();
if (addressList.Contains(key) == false)
{
addressList.AddLast(key);
}
}
var currentKey = addressList.First;
var masterKeys = KeyPair.FromWIF(nexusWif);
//Trace.Message($"Connecting to host: {host} with address {masterKeys.Address.Text}");
var amount = UnitConversion.ToBigInteger(1000000, Nexus.StakingTokenDecimals);
var hash = SendTransfer(host, masterKeys, currentKey.Value.Address, amount);
if (hash == Hash.Null)
{
return;
}
ConfirmTransaction(host, hash);
int totalTxs = 0;
int okTxs = 0;
BigInteger currentKeyBalance = GetBalance(currentKey.Value.Address);
amount = UnitConversion.ToBigInteger(1000000, Nexus.FuelTokenDecimals);
SendTransfer(host, masterKeys, currentKey.Value.Address, amount, "KCAL");
//while (currentKeyBalance > 9999)
while (totalTxs < 10)
{
var destKey = currentKey.Next != null ? currentKey.Next : addressList.First;
var txHash = SendTransfer(host, currentKey.Value, destKey.Value.Address, currentKeyBalance - 9999);
if (txHash == Hash.Null)
{
amount = UnitConversion.ToBigInteger(1000000, Nexus.FuelTokenDecimals);
SendTransfer(host, masterKeys, currentKey.Value.Address, amount);
}
do
{
Thread.Sleep(100);
} while (mempool.Size > 0);
var confirmation = ConfirmTransaction(host, hash);
okTxs += confirmation ? 1 : 0;
totalTxs++;
currentKey = destKey;
currentKeyBalance = GetBalance(currentKey.Value.Address);
Trace.WriteLine(currentKeyBalance);
}
Assert.IsTrue(okTxs == totalTxs);
CloseNode();
}
public static string GetTxAmount(TransactionDto tx, List <ChainDto> phantasmaChains, List <TokenDto> phantasmaTokens)
{
string amountsymbol = null;
string senderToken = null;
Address senderChain = Address.FromText(tx.ChainAddress);
Address senderAddress = Address.Null;
string receiverToken = null;
string receiverChain = "";
Address receiverAddress = Address.Null;
BigInteger amount = 0;
tx.Events.Reverse();
foreach (var evt in tx.Events) //todo move this
{
switch (evt.EventKind)
{
case EventKind.TokenStake:
{
var data = Serialization.Unserialize <TokenEventData>(evt.Data.Decode());
amount = data.Value;
receiverAddress = Address.FromText(evt.EventAddress);
receiverChain = data.ChainName;
if (data.Symbol == "TTRS")
{
amountsymbol = $"{data.Symbol} • NFT";
break;
}
var amountDecimal = UnitConversion.ToDecimal(amount, phantasmaTokens.Single(p => p.Symbol == data.Symbol).Decimals);
if (data.Symbol != "KCAL" && data.Symbol != "NEO" && data.Symbol != "GAS")
{
amountsymbol = $"{amountDecimal.ToString("#,0.##########").ToString(new CultureInfo("en-US"))} {data.Symbol}";
}
}
break;
case EventKind.TokenClaim:
{
var data = Serialization.Unserialize <TokenEventData>(evt.Data.Decode());
amount = data.Value;
receiverAddress = Address.FromText(evt.EventAddress);
receiverChain = data.ChainName;
if (data.Symbol == "TTRS")
{
amountsymbol = $"{data.Symbol} • NFT";
break;
}
var amountDecimal = UnitConversion.ToDecimal(amount, phantasmaTokens.Single(p => p.Symbol == data.Symbol).Decimals);
if (data.Symbol != "KCAL" && data.Symbol != "NEO" && data.Symbol != "GAS")
{
amountsymbol = $"{amountDecimal.ToString("#,0.##########").ToString(new CultureInfo("en-US"))} {data.Symbol}";
}
}
break;
case EventKind.TokenSend:
{
var data = Serialization.Unserialize <TokenEventData>(evt.Data.Decode());
amount = data.Value;
senderAddress = Address.FromText(evt.EventAddress);
senderToken = data.Symbol;
if (data.Symbol == "TTRS")
{
amountsymbol = $"{data.Symbol} • NFT";
break;
}
var amountDecimal = UnitConversion.ToDecimal(amount, phantasmaTokens.Single(p => p.Symbol == senderToken).Decimals);
amountsymbol = $"{amountDecimal.ToString("#,0.##########").ToString(new CultureInfo("en-US"))} {senderToken}";
}
break;
case EventKind.TokenReceive:
{
var data = Serialization.Unserialize <TokenEventData>(evt.Data.Decode());
amount = data.Value;
receiverAddress = Address.FromText(evt.EventAddress);
receiverChain = data.ChainName;
receiverToken = data.Symbol;
var amountDecimal = UnitConversion.ToDecimal(amount, phantasmaTokens.Single(p => p.Symbol == receiverToken).Decimals);
if (data.Symbol == "TTRS")
{
amountsymbol = $"{data.Symbol} • NFT";
break;
}
amountsymbol = $"{amountDecimal.ToString("#,0.##########").ToString(new CultureInfo("en-US"))} {receiverToken}";
}
break;
case EventKind.TokenMint:
{
var data = Serialization.Unserialize <TokenEventData>(evt.Data.Decode());
amount = data.Value;
receiverAddress = Address.FromText(evt.EventAddress);
receiverChain = data.ChainName;
var amountDecimal = UnitConversion.ToDecimal(amount, phantasmaTokens.Single(p => p.Symbol == data.Symbol).Decimals);
amountsymbol = $"{amountDecimal.ToString("#,0.##########").ToString(new CultureInfo("en-US"))} {data.Symbol}";
if (data.Symbol == "TTRS")
{
amountsymbol = $"{data.Symbol} • NFT";
}
}
break;
case EventKind.AddressRegister:
{
return(amountsymbol = $"");
}
break;
}
}
return(amountsymbol);
}
public static BigInteger FuelToStake(BigInteger fuelAmount)
{
return(UnitConversion.ConvertDecimals(fuelAmount * BaseEnergyRatioDivisor, Nexus.FuelTokenDecimals, Nexus.StakingTokenDecimals));
}
static void DumpBalances(string symbol, int decimals)
{
var prefix = BalanceSheet.MakePrefix(symbol);
var storage = new KeyStoreStorage(store);
var stakeMapKey = GetKeyForField <StakeContract>("_stakes");
var stakeMap = new StorageMap(stakeMapKey, storage);
var stakeCount = stakeMap.Count();
var addresses = new HashSet <Address>();
//Console.WriteLine($"************ BALANCE LIST FOR {symbol} ************");
decimal total = 0;
store.Visit((key, value) =>
{
if (HasPrefix(prefix, key))
{
var bytes = new byte[key.Length - prefix.Length];
ByteArrayUtils.CopyBytes(key, prefix.Length, bytes, 0, bytes.Length);
var addr = Address.FromBytes(bytes);
if (addr.IsSystem || addr.Text == "P2KFNXEbt65rQiWqogAzqkVGMqFirPmqPw8mQyxvRKsrXV8")
{
return;
}
BigInteger amount;
if (value.Length > 0)
{
amount = BigInteger.FromSignedArray(value);
}
else
{
amount = 0;
}
/*if (symbol == DomainSettings.StakingTokenSymbol && stakeMap.ContainsKey<Address>(addr))
* {
* var temp = stakeMap.Get<Address, EnergyStake>(addr);
* amount += temp.stakeAmount;
* }*/
addresses.Add(addr);
string s;
if (PrettyPrint)
{
var dec = UnitConversion.ToDecimal(amount, decimals);
total += dec;
s = dec.ToString();
}
else
{
s = amount.ToString();
}
Console.WriteLine($"{addr.Text},{symbol},{s}");
}
});
/*
* if (symbol == DomainSettings.StakingTokenSymbol)
* {
* var masterListKey = GetKeyForField<StakeContract>("_mastersList");
* var masterList = new StorageList(masterListKey, storage);
* var masterCount = masterList.Count();
* for (int i = 0; i < masterCount; i++)
* {
* var master = masterList.Get<EnergyMaster>(i);
* if (addresses.Contains(master.address))
* {
* continue;
* }
*
* var temp = stakeMap.Get<Address, EnergyAction>(master.address);
*
* string s;
*
* if (PrettyPrint)
* {
* var stake = UnitConversion.ToDecimal(temp.totalAmount, decimals);
* s = stake.ToString();
* total += stake;
* }
* else
* {
* s = temp.totalAmount.ToString();
* }
*
* Console.WriteLine($"{master.address.Text},{symbol},{s}");
* }
* }*/
if (PrettyPrint)
{
Console.WriteLine($"Total,{symbol},{total}");
}
}
public static BigInteger StakeToFuel(BigInteger stakeAmount)
{
return(UnitConversion.ConvertDecimals(stakeAmount, Nexus.StakingTokenDecimals, Nexus.FuelTokenDecimals) / BaseEnergyRatioDivisor);
}
public static string GetTxDescription(TransactionDto tx, List <ChainDto> phantasmaChains, List <TokenDto> phantasmaTokens)
{
string description = null;
string senderToken = null;
Address senderChain = Address.FromText(tx.ChainAddress);
Address senderAddress = Address.Null;
string receiverToken = null;
Address receiverChain = Address.Null;
Address receiverAddress = Address.Null;
BigInteger amount = 0;
foreach (var evt in tx.Events) //todo move this
{
switch (evt.EventKind)
{
case EventKind.TokenSend:
{
var data = Serialization.Unserialize <TokenEventData>(evt.Data.Decode());
amount = data.value;
senderAddress = Address.FromText(evt.EventAddress);
senderToken = data.symbol;
}
break;
case EventKind.TokenReceive:
{
var data = Serialization.Unserialize <TokenEventData>(evt.Data.Decode());
amount = data.value;
receiverAddress = Address.FromText(evt.EventAddress);
receiverChain = data.chainAddress;
receiverToken = data.symbol;
}
break;
case EventKind.TokenEscrow:
{
var data = Serialization.Unserialize <TokenEventData>(evt.Data.Decode());
amount = data.value;
var amountDecimal = UnitConversion.ToDecimal(amount, phantasmaTokens.Single(p => p.Symbol == data.symbol).Decimals);
receiverAddress = Address.FromText(evt.EventAddress);
receiverChain = data.chainAddress;
var chain = GetChainName(receiverChain.Text, phantasmaChains);
description =
$"{amountDecimal} {data.symbol} tokens escrowed for address {receiverAddress} in {chain}";
}
break;
case EventKind.AddressRegister:
{
var name = Serialization.Unserialize <string>(evt.Data.Decode());
description = $"{evt.EventAddress} registered the name '{name}'";
}
break;
case EventKind.AddFriend:
{
var address = Serialization.Unserialize <Address>(evt.Data.Decode());
description = $"{evt.EventAddress} added '{address.ToString()} to friends.'";
}
break;
case EventKind.RemoveFriend:
{
var address = Serialization.Unserialize <Address>(evt.Data.Decode());
description = $"{evt.EventAddress} removed '{address.ToString()} from friends.'";
}
break;
}
}
if (description == null)
{
if (amount > 0 && senderAddress != Address.Null && receiverAddress != Address.Null &&
senderToken != null && senderToken == receiverToken)
{
var amountDecimal = UnitConversion.ToDecimal(amount, phantasmaTokens.Single(p => p.Symbol == senderToken).Decimals);
description =
$"{amountDecimal} {senderToken} sent from {senderAddress.ToString()} to {receiverAddress.ToString()}";
}
else if (amount > 0 && receiverAddress != Address.Null && receiverToken != null)
{
var amountDecimal = UnitConversion.ToDecimal(amount, phantasmaTokens.Single(p => p.Symbol == receiverToken).Decimals);
description = $"{amountDecimal} {receiverToken} received on {receiverAddress.Text} ";
}
else
{
description = "Custom transaction";
}
if (receiverChain != Address.Null && receiverChain != senderChain)
{
description +=
$" from {GetChainName(senderChain.Text, phantasmaChains)} chain to {GetChainName(receiverChain.Text, phantasmaChains)} chain";
}
}
return(description);
}
public byte[] Read(string url)
{
if (_entries.ContainsKey(url))
{
return(_entries[url].Content);
}
byte[] content;
if (url.StartsWith(interopTag))
{
url = url.Substring(interopTag.Length);
var args = url.Split('/');
var platformName = args[0];
if (Nexus.PlatformExists(platformName))
{
args = args.Skip(1).ToArray();
return(ReadChainOracle(platformName, args));
}
else
{
throw new OracleException("invalid oracle platform: " + platformName);
}
}
else
if (url.StartsWith(priceTag))
{
url = url.Substring(priceTag.Length);
var symbols = url.Split('/');
if (symbols.Length < 1 || symbols.Length > 2)
{
throw new OracleException("invalid oracle price request");
}
var baseSymbol = symbols[0];
var quoteSymbol = symbols.Length > 1 ? symbols[1] : Nexus.FiatTokenSymbol;
if (!Nexus.TokenExists(baseSymbol))
{
throw new OracleException("unknown token: " + baseSymbol);
}
if (!Nexus.TokenExists(quoteSymbol))
{
throw new OracleException("unknown token: " + quoteSymbol);
}
var tokenInfo = Nexus.GetTokenInfo(quoteSymbol);
var price = PullPrice(baseSymbol, quoteSymbol);
var val = UnitConversion.ToBigInteger(price, tokenInfo.Decimals);
return(val.ToUnsignedByteArray());
}
else
{
content = PullData(url);
}
var entry = new OracleEntry(url, content);
_entries[url] = entry;
return(content);
}
public static BigInteger FuelToStake(BigInteger fuelAmount, uint _BaseEnergyRatioDivisor)
{
return(UnitConversion.ConvertDecimals(fuelAmount * _BaseEnergyRatioDivisor, DomainSettings.FuelTokenDecimals, DomainSettings.StakingTokenDecimals));
}
public BigInteger GetRequiredStake()
{
return(UnitConversion.ToBigInteger(50000, Nexus.StakingTokenDecimals)); // TODO this should be dynamic
}
// Start is called before the first frame update
void Start()
{
result = UnitConversion.ConvertAcelMilesToMeters(mi);
}
public void ApplyInflation(Address from)
{
Runtime.Expect(_inflationReady, "inflation not ready");
Runtime.Expect(Runtime.IsRootChain(), "only on root chain");
var currentSupply = Runtime.GetTokenSupply(DomainSettings.StakingTokenSymbol);
var minExpectedSupply = UnitConversion.ToBigInteger(100000000, DomainSettings.StakingTokenDecimals);
if (currentSupply < minExpectedSupply)
{
currentSupply = minExpectedSupply;
}
// NOTE this gives an approximate inflation of 3% per year (0.75% per season)
var inflationAmount = currentSupply / 133;
BigInteger mintedAmount = 0;
Runtime.Expect(inflationAmount > 0, "invalid inflation amount");
var masterOrg = Runtime.GetOrganization(DomainSettings.MastersOrganizationName);
var masters = masterOrg.GetMembers();
var rewardList = new List <Address>();
foreach (var addr in masters)
{
var masterDate = Runtime.CallNativeContext(NativeContractKind.Stake, nameof(StakeContract.GetMasterDate), addr).AsTimestamp();
if (masterDate <= _lastInflationDate)
{
rewardList.Add(addr);
}
}
if (rewardList.Count > 0)
{
var rewardAmount = inflationAmount / 10;
var rewardStake = rewardAmount / rewardList.Count;
rewardAmount = rewardList.Count * rewardStake; // eliminate leftovers
var rewardFuel = _rewardAccum / rewardList.Count;
BigInteger stakeAmount;
if (Runtime.ProtocolVersion > 5)
{
stakeAmount = UnitConversion.ToBigInteger(2, DomainSettings.StakingTokenDecimals);
}
else
{
stakeAmount = UnitConversion.ToBigInteger(1, DomainSettings.StakingTokenDecimals);
}
Runtime.MintTokens(DomainSettings.StakingTokenSymbol, this.Address, this.Address, rewardAmount);
var crownAddress = TokenUtils.GetContractAddress(DomainSettings.RewardTokenSymbol);
Runtime.MintTokens(DomainSettings.StakingTokenSymbol, this.Address, crownAddress, stakeAmount);
Runtime.CallNativeContext(NativeContractKind.Stake, nameof(StakeContract.Stake), crownAddress, stakeAmount);
foreach (var addr in rewardList)
{
var reward = new StakeReward(addr, Runtime.Time);
/*var temp = VMObject.FromObject(reward);
* temp = VMObject.CastTo(temp, VMType.Struct);
*
* var rom = temp.Serialize();*/
var rom = Serialization.Serialize(reward);
var tokenID = Runtime.MintToken(DomainSettings.RewardTokenSymbol, this.Address, this.Address, rom, new byte[0], 0);
Runtime.InfuseToken(DomainSettings.RewardTokenSymbol, this.Address, tokenID, DomainSettings.FuelTokenSymbol, rewardFuel);
Runtime.InfuseToken(DomainSettings.RewardTokenSymbol, this.Address, tokenID, DomainSettings.StakingTokenSymbol, rewardStake);
Runtime.TransferToken(DomainSettings.RewardTokenSymbol, this.Address, addr, tokenID);
}
_rewardAccum -= rewardList.Count * rewardFuel;
Runtime.Expect(_rewardAccum >= 0, "invalid reward leftover");
inflationAmount -= rewardAmount;
inflationAmount -= stakeAmount;
}
var refillAmount = inflationAmount / 50;
var cosmicAddress = SmartContract.GetAddressForNative(NativeContractKind.Swap);
Runtime.MintTokens(DomainSettings.StakingTokenSymbol, this.Address, cosmicAddress, refillAmount);
inflationAmount -= refillAmount;
var phantomOrg = Runtime.GetOrganization(DomainSettings.PhantomForceOrganizationName);
if (phantomOrg != null)
{
var phantomFunding = inflationAmount / 3;
Runtime.MintTokens(DomainSettings.StakingTokenSymbol, this.Address, phantomOrg.Address, phantomFunding);
inflationAmount -= phantomFunding;
if (phantomOrg.Size == 1)
{
Runtime.CallNativeContext(NativeContractKind.Stake, nameof(StakeContract.Stake), phantomOrg.Address, phantomFunding);
}
}
var bpOrg = Runtime.GetOrganization(DomainSettings.ValidatorsOrganizationName);
if (bpOrg != null)
{
Runtime.MintTokens(DomainSettings.StakingTokenSymbol, this.Address, bpOrg.Address, inflationAmount);
if (bpOrg.Size == 1)
{
Runtime.CallNativeContext(NativeContractKind.Stake, nameof(StakeContract.Stake), bpOrg.Address, inflationAmount);
}
}
Runtime.Notify(EventKind.Inflation, from, new TokenEventData(DomainSettings.StakingTokenSymbol, mintedAmount, Runtime.Chain.Name));
_lastInflationDate = Runtime.Time;
_inflationReady = false;
}
public void GenerateRandomBlock(Mempool mempool = null)
{
//Console.WriteLine("begin block #" + Nexus.RootChain.BlockHeight);
BeginBlock();
int transferCount = 1 + _rnd.Next() % 10;
int tries = 0;
while (tries < 10000)
{
if (transactions.Count >= transferCount)
{
break;
}
tries++;
var source = _keys[_rnd.Next() % _keys.Count];
if (usedAddresses.Contains(source.Address))
{
continue;
}
var prevTxCount = transactions.Count;
var sourceChain = Nexus.RootChain;
var fee = 9999;
string tokenSymbol;
switch (_rnd.Next() % 4)
{
case 1: tokenSymbol = Nexus.FiatTokenSymbol; break;
//case 2: token = Nexus.FuelTokenSymbol; break;
default: tokenSymbol = Nexus.StakingTokenSymbol; break;
}
switch (_rnd.Next() % 7)
{
// side-chain send
case 1:
{
var sourceChainList = Nexus.Chains.ToArray();
sourceChain = Nexus.FindChainByName(sourceChainList[_rnd.Next() % sourceChainList.Length]);
var targetChainList = Nexus.Chains.Select(x => Nexus.FindChainByName(x)).Where(x => Nexus.GetParentChainByName(x.Name) == sourceChain.Name || Nexus.GetParentChainByName(sourceChain.Name) == x.Name).ToArray();
var targetChain = targetChainList[_rnd.Next() % targetChainList.Length];
var total = UnitConversion.ToBigInteger(1 + _rnd.Next() % 100, Nexus.FuelTokenDecimals);
var tokenBalance = sourceChain.GetTokenBalance(tokenSymbol, source.Address);
var fuelBalance = sourceChain.GetTokenBalance(Nexus.FuelTokenSymbol, source.Address);
var expectedTotal = total;
if (tokenSymbol == Nexus.FuelTokenSymbol)
{
expectedTotal += fee;
}
var sideFee = 0;
if (tokenSymbol != Nexus.FuelTokenSymbol)
{
sideFee = fee;
}
if (tokenBalance > expectedTotal && fuelBalance > fee + sideFee)
{
Logger.Debug($"Rnd.SideChainSend: {total} {tokenSymbol} from {source.Address}");
GenerateSideChainSend(source, tokenSymbol, sourceChain, source.Address, targetChain, total, sideFee);
}
break;
}
// side-chain receive
case 2:
{
if (_pendingBlocks.Any())
{
var pendingBlock = _pendingBlocks.First();
if (mempool == null || Nexus.GetConfirmationsOfHash(pendingBlock.hash) > 0)
{
var balance = pendingBlock.destChain.GetTokenBalance(pendingBlock.tokenSymbol, source.Address);
if (balance > 0)
{
Logger.Message($"...Settling {pendingBlock.sourceChain.Name}=>{pendingBlock.destChain.Name}: {pendingBlock.hash}");
GenerateSideChainSettlement(source, pendingBlock.sourceChain, pendingBlock.destChain, pendingBlock.hash);
}
}
}
break;
}
/*
* // stable claim
* case 3:
* {
* sourceChain = bankChain;
* tokenSymbol = Nexus.FuelTokenSymbol;
*
* var balance = sourceChain.GetTokenBalance(tokenSymbol, source.Address);
*
* var total = UnitConversion.ToBigInteger(1 + _rnd.Next() % 100, Nexus.FuelTokenDecimals - 1);
*
* if (balance > total + fee)
* {
* Logger.Debug($"Rnd.StableClaim: {total} {tokenSymbol} from {source.Address}");
* GenerateStableClaim(source, sourceChain, total);
* }
*
* break;
* }
*
* // stable redeem
* case 4:
* {
* sourceChain = bankChain;
* tokenSymbol = Nexus.FiatTokenSymbol;
*
* var tokenBalance = sourceChain.GetTokenBalance(tokenSymbol, source.Address);
* var fuelBalance = sourceChain.GetTokenBalance(Nexus.FuelTokenSymbol, source.Address);
*
* var rate = (BigInteger) bankChain.InvokeContract("bank", "GetRate", Nexus.FuelTokenSymbol);
* var total = tokenBalance / 10;
* if (total >= rate && fuelBalance > fee)
* {
* Logger.Debug($"Rnd.StableRedeem: {total} {tokenSymbol} from {source.Address}");
* GenerateStableRedeem(source, sourceChain, total);
* }
*
* break;
* }*/
// name register
case 5:
{
sourceChain = this.Nexus.RootChain;
tokenSymbol = Nexus.FuelTokenSymbol;
var balance = sourceChain.GetTokenBalance(tokenSymbol, source.Address);
if (balance > fee + AccountContract.RegistrationCost && !pendingNames.Contains(source.Address))
{
var randomName = accountNames[_rnd.Next() % accountNames.Length];
switch (_rnd.Next() % 10)
{
case 1:
case 2:
randomName += (_rnd.Next() % 10).ToString();
break;
case 3:
case 4:
case 5:
randomName += (10 + _rnd.Next() % 90).ToString();
break;
case 6:
randomName += (100 + _rnd.Next() % 900).ToString();
break;
}
var currentName = Nexus.LookUpAddressName(source.Address);
if (currentName == ValidationUtils.ANONYMOUS)
{
var lookup = Nexus.LookUpName(randomName);
if (lookup.IsNull)
{
Logger.Debug($"Rnd.GenerateAccount: {source.Address} => {randomName}");
GenerateAccountRegistration(source, randomName);
}
}
}
break;
}
// normal transfer
default:
{
var temp = _rnd.Next() % 5;
Address targetAddress;
if ((_keys.Count < 2 || temp == 0) && _keys.Count < 2000)
{
var key = KeyPair.Generate();
_keys.Add(key);
targetAddress = key.Address;
}
else
{
targetAddress = _keys[_rnd.Next() % _keys.Count].Address;
}
if (source.Address != targetAddress)
{
var total = UnitConversion.ToBigInteger(1 + _rnd.Next() % 100, Nexus.FuelTokenDecimals - 1);
var tokenBalance = sourceChain.GetTokenBalance(tokenSymbol, source.Address);
var fuelBalance = sourceChain.GetTokenBalance(Nexus.FuelTokenSymbol, source.Address);
var expectedTotal = total;
if (tokenSymbol == Nexus.FuelTokenSymbol)
{
expectedTotal += fee;
}
if (tokenBalance > expectedTotal && fuelBalance > fee)
{
Logger.Debug($"Rnd.Transfer: {total} {tokenSymbol} from {source.Address} to {targetAddress}");
GenerateTransfer(source, targetAddress, sourceChain, tokenSymbol, total);
}
}
break;
}
}
}
if (transactions.Count > 0)
{
EndBlock(mempool);
}
else
{
CancelBlock();
}
}
/// <summary>Samples a new projectile.</summary>
/// <param name="manager">The manager.</param>
/// <param name="emitter">The emitter that the projectile comes from.</param>
/// <param name="offset">The offset.</param>
/// <param name="angle">The angle.</param>
/// <param name="weapon">The weapon.</param>
/// <param name="faction">The faction the projectile belongs to.</param>
/// <param name="random">The randomizer to use.</param>
/// <returns>A new projectile.</returns>
public int SampleProjectile(
IManager manager,
int emitter,
Vector2 offset,
float angle,
Weapon weapon,
Factions faction,
IUniformRandom random)
{
var entity = manager.AddEntity();
// Get position and velocity of the emitter, to set initial position
// and additional velocity.
var emitterTransform = (ITransform)manager.GetComponent(emitter, TransformTypeId);
var emitterVelocity = (IVelocity)manager.GetComponent(emitter, VelocityTypeId);
// Rotate the offset.
var emitterAngle = emitterTransform.Angle;
var cosRadians = (float)Math.Cos(emitterAngle);
var sinRadians = (float)Math.Sin(emitterAngle);
FarPosition rotatedOffset;
rotatedOffset.X = -offset.X * cosRadians - offset.Y * sinRadians;
rotatedOffset.Y = -offset.X * sinRadians + offset.Y * cosRadians;
// Set initial velocity.
var velocity = SampleInitialDirectedVelocity(emitterAngle + angle, random);
var accelerationForce = SampleAccelerationForce(emitterAngle + angle, random);
// Adjust rotation for projectile based on its own acceleration or speed.
var emitAngle = emitterAngle;
if (accelerationForce != Vector2.Zero)
{
emitAngle = (float)Math.Atan2(accelerationForce.Y, accelerationForce.X);
}
else if (velocity != Vector2.Zero)
{
emitAngle = (float)Math.Atan2(velocity.Y, velocity.X);
}
// See what we must not bump into.
var collisionMask = ~faction.ToCollisionGroup();
// Normally projectiles won't test against each other, but some may be
// shot down, such as missiles. If that's the case, don't add us to the
// common projectile group.
if (!_canBeShot)
{
collisionMask &= ~Factions.Projectiles.ToCollisionGroup();
}
// Create physical body.
var body = manager.AddBody(
entity,
emitterTransform.Position + rotatedOffset + velocity / Settings.TicksPerSecond,
emitAngle,
Body.BodyType.Dynamic,
isBullet: true,
allowSleep: false);
manager.AttachCircle(
body,
UnitConversion.ToSimulationUnits(_collisionRadius),
0,
restitution: 0.1f,
collisionCategory: faction.ToCollisionGroup() | Factions.Projectiles.ToCollisionGroup(),
collisionMask: collisionMask);
// Add to render system indexes. The padding these perform should be enough for any projectile.
manager.AddComponent <Indexable>(entity).Initialize(CameraSystem.IndexId);
manager.AddComponent <Indexable>(entity).Initialize(InterpolationSystem.IndexId);
// If our emitter was moving, apply its velocity.
if (emitterVelocity != null)
{
velocity += emitterVelocity.LinearVelocity;
}
// Then set the initial velocity of our bullet.
body.LinearVelocity = velocity;
// Sample an acceleration for this projectile. If there is any, create the
// component for it, otherwise disregard.
if (accelerationForce != Vector2.Zero)
{
// TODO add motor joint? else teach acceleration system to use ApplyForce
// manager.AddComponent<Acceleration>(entity).Initialize(accelerationForce);
}
// Apply friction to this projectile if so desired.
if (_friction > 0)
{
body.LinearDamping = 1f - _friction;
}
// If this projectile should vanish after some time, make it expire.
if (_timeToLive > 0)
{
manager.AddComponent <Expiration>(entity).Initialize((int)(_timeToLive * Settings.TicksPerSecond));
}
// Mark as applying damage on collision.
manager.AddComponent <CollisionDamage>(entity).Initialize(true);
// Apply attributes of the weapon, modified with emitter attribute values,
// and emitter attributes to the projectile to allow damage calculation if
// it hits something.
var emitterAttributes =
(Attributes <AttributeType>)manager.GetComponent(emitter, Attributes <AttributeType> .TypeId);
Attributes <AttributeType> projectileAttributes = null; // Only create if necessary.
foreach (AttributeType attributeType in Enum.GetValues(typeof(AttributeType)))
{
if (attributeType == AttributeType.None)
{
continue;
}
// Try to get weapon local attribute as base values.
var value = 0f;
if (weapon.Attributes.ContainsKey(attributeType))
{
value = weapon.Attributes[attributeType];
}
// Try to modify it with emitter attributes.
if (emitterAttributes != null)
{
value = emitterAttributes.GetValue(attributeType, value);
}
// If we have something, copy it to the projectile.
// ReSharper disable CompareOfFloatsByEqualityOperator
if (value != 0f)
// ReSharper restore CompareOfFloatsByEqualityOperator
{
if (projectileAttributes == null)
{
projectileAttributes = manager.AddComponent <Attributes <AttributeType> >(entity);
}
projectileAttributes.SetBaseValue(attributeType, value);
}
}
// Make us visible!
if (!string.IsNullOrWhiteSpace(_model))
{
manager.AddComponent <SimpleTextureDrawable>(entity).Initialize(_model);
}
// And add some particle effects, if so desired.
if (!string.IsNullOrWhiteSpace(_effect))
{
manager.AddComponent <ParticleEffects>(entity)
.TryAdd(0, _effect, 1f, 0, _effectOffset, ParticleEffects.EffectGroup.None, true);
}
// Assign owner, to track original cause when they do something (e.g. kill something).
manager.AddComponent <Owner>(entity).Initialize(emitter);
return(entity);
}
