public async Task ExchangeTokensViaSender()
{
EthereumAddress exchangeAddress = (EthereumAddress)ExchangeAddress;
ExchangeContract exchange = new ExchangeContract(RpcURL, exchangeAddress, new Account(SenderPrivateKey));
Order order = new Order
{
MakerAddress = (EthereumAddress)MakerAddress,
TakerAddress = (EthereumAddress)TakerAddress,
SenderAddress = exchange.CallerAccount.Address,
FeeRecipientAddress = exchange.CallerAccount.Address,
MakerFee = 10,
TakerFee = 10,
MakerAssetAmount = 100,
TakerAssetAmount = 100,
MakerAsset = ERC20Asset.Create((EthereumAddress)MakerTokenAddress),
TakerAsset = ERC20Asset.Create((EthereumAddress)TakerTokenAddress),
ExpirationTime = DateTime.UtcNow + new TimeSpan(1, 0, 0),
Salt = Random.GenerateSalt()
};
byte[] makerSignature = order.Sign(exchangeAddress, MakerPrivateKey);
Transaction tx = ExchangeContract.FillOrderGet0xTx(order, order.TakerAssetAmount, makerSignature);
byte[] takerSignature = tx.Sign(exchangeAddress, TakerPrivateKey);
string hash = await exchange.FillOrderAsync(
order,
order.TakerAssetAmount,
makerSignature,
takerSignature,
tx.Salt,
new TxParameters(1000000));
}
public SmartContract FindContract(string contractName)
{
Throw.IfNullOrEmpty(contractName, nameof(contractName));
if (_contractCache.ContainsKey(contractName))
{
return(_contractCache[contractName]);
}
SmartContract contract;
switch (contractName)
{
case "nexus": contract = new NexusContract(); break;
case "consensus": contract = new ConsensusContract(); break;
case "governance": contract = new GovernanceContract(); break;
case "account": contract = new AccountContract(); break;
case "friends": contract = new FriendContract(); break;
case "exchange": contract = new ExchangeContract(); break;
case "market": contract = new MarketContract(); break;
case "energy": contract = new EnergyContract(); break;
case "token": contract = new TokenContract(); break;
case "swap": contract = new SwapContract(); break;
case "gas": contract = new GasContract(); break;
case "relay": contract = new RelayContract(); break;
case "storage": contract = new StorageContract(); break;
case "vault": contract = new VaultContract(); break;
case "bank": contract = new BankContract(); break;
case "apps": contract = new AppsContract(); break;
case "dex": contract = new ExchangeContract(); break;
case "nacho": contract = new NachoContract(); break;
case "casino": contract = new CasinoContract(); break;
default:
throw new Exception("Unknown contract: " + contractName);
}
_contractCache[contractName] = contract;
return(contract);
}
public void ExportToExchangeContract(ExchangeContract exchange, bool magic = false)
{
try
{
List <Interval> intervals = new List <Interval>();
intervals.AddRange(Experiment1.Intervals);
intervals.AddRange(Experiment2.Intervals);
exchange.Frequencys.Clear();
exchange.Signal.Clear();
exchange.Noise.Clear();
exchange.OriginalSignal.Clear();
exchange.OriginalNoise.Clear();
foreach (Interval current in intervals)
{
try
{
if (magic)
{
current.BeforeMagic();
current.MagicOn();
}
if (current.Markers.Count > 0)
{
foreach (int position in current.Markers)
{
if (position < current.Frequencys.Count)
{
if (current.Frequencys[position] < current.IntervalSettings.FrequencyStop)
{
exchange.Frequencys.Add(current.Frequencys[position]);
exchange.Signal.Add(position < current.Signal.Count ? current.Signal[position] : 0);
exchange.Noise.Add(position < current.Noise.Count ? current.Noise[position] : 0);
exchange.OriginalSignal.Add(position < current.OriginalSignal.Count ? current.OriginalSignal[position] : 0);
exchange.OriginalNoise.Add(position < current.OriginalNoise.Count ? current.OriginalNoise[position] : 0);
}
}
}
}
if (magic)
{
current.AfterMagic();
}
}
catch (Exception ex)
{
MessageBox.Show("ОШИБКА ПРИ ЭКСПОРТЕ" + ex.ToString());
}
}
}
catch (Exception ex)
{
MessageBox.Show("ОШИБКА ПРИ ЭКСПОРТЕ " + ex.ToString());
}
}
/// <inheritdoc/>
public async Task Init()
{
ExchangeContract = await BCComm.GetHoardExchangeContract();
if (ExchangeContract == null)
{
throw new HoardException("Cannot get proper GameExchange contract!");
}
}
public async Task CancelOrder()
{
EthereumAddress exchangeAddress = (EthereumAddress)ExchangeAddress;
ExchangeContract exchangeContract = new ExchangeContract(RpcURL, exchangeAddress, new Account(MakerPrivateKey));
Order order = new Order
{
MakerAddress = (EthereumAddress)MakerAddress,
TakerAddress = (EthereumAddress)TakerAddress,
SenderAddress = EthereumAddress.ZeroAddress,
FeeRecipientAddress = (EthereumAddress)(Web3.GetAddressFromPrivateKey(SenderPrivateKey)),
MakerFee = 10,
TakerFee = 10,
MakerAssetAmount = 100,
TakerAssetAmount = 100,
MakerAsset = ERC20Asset.Create((EthereumAddress)MakerTokenAddress),
TakerAsset = ERC20Asset.Create((EthereumAddress)TakerTokenAddress),
ExpirationTime = DateTime.UtcNow + new TimeSpan(1, 0, 0),
Salt = Random.GenerateSalt()
};
await exchangeContract.CancelOrderAsync(order, new TxParameters(1000000));
}
public async Task ExchangeTokens()
{
EthereumAddress exchangeAddress = (EthereumAddress)ExchangeAddress;
ExchangeContract exchange = new ExchangeContract(RpcURL, exchangeAddress, new Account(TakerPrivateKey));
Order order = new Order
{
MakerAddress = (EthereumAddress)MakerAddress,
TakerAddress = (EthereumAddress)TakerAddress,
SenderAddress = (EthereumAddress)TakerAddress,
FeeRecipientAddress = (EthereumAddress)(Web3.GetAddressFromPrivateKey(SenderPrivateKey)),
MakerFee = 10,
TakerFee = 10,
MakerAssetAmount = 100,
TakerAssetAmount = 100,
MakerAsset = ERC20Asset.Create((EthereumAddress)MakerTokenAddress),
TakerAsset = ERC20Asset.Create((EthereumAddress)TakerTokenAddress),
ExpirationTime = DateTime.UtcNow + new TimeSpan(1, 0, 0),
Salt = Random.GenerateSalt()
};
byte[] signature = order.Sign(exchangeAddress, MakerPrivateKey);
await exchange.FillOrderAsync(order, order.TakerAssetAmount, signature, new TxParameters(1000000));
}
public void FillOrderExecTxCallData()
{
// We use invalid data just because we want to test encoding of tx data
// for executeTransaction
Order order = new Order
{
SenderAddress = EthereumAddress.ZeroAddress,
MakerAddress = EthereumAddress.ZeroAddress,
TakerAddress = EthereumAddress.ZeroAddress,
FeeRecipientAddress = EthereumAddress.ZeroAddress,
MakerAssetAmount = 0,
TakerAssetAmount = 0,
MakerFee = 0,
TakerFee = 0,
ExpirationTime = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc),
Salt = 0,
MakerAsset = ERC20Asset.Create(EthereumAddress.ZeroAddress),
TakerAsset = ERC20Asset.Create(EthereumAddress.ZeroAddress)
};
BigInteger takerAssetFillAmount = 0;
byte[] signature = new byte[1];
CallData callData = ExchangeContract.FillOrderCallData(order, takerAssetFillAmount, signature,
signature, 0, EthereumAddress.ZeroAddress, new Web3());
byte[] expectedTxData = ("0xbfc8bfce00000000000000000000000000000000" +
"00000000000000000000000000000000000000000000000000000000000000" +
"00000000000000000000000000000000000000000000000000000000000000" +
"00000000000000000000000000000000008000000000000000000000000000" +
"000000000000000000000000000000000003a0000000000000000000000000" +
"00000000000000000000000000000000000002e4b4be83d500000000000000" +
"00000000000000000000000000000000000000000000000060000000000000" +
"00000000000000000000000000000000000000000000000000000000000000" +
"0000000000000000000000000000000000000000000000000002a000000000" +
"00000000000000000000000000000000000000000000000000000000000000" +
"00000000000000000000000000000000000000000000000000000000000000" +
"00000000000000000000000000000000000000000000000000000000000000" +
"00000000000000000000000000000000000000000000000000000000000000" +
"00000000000000000000000000000000000000000000000000000000000000" +
"00000000000000000000000000000000000000000000000000000000000000" +
"00000000000000000000000000000000000000000000000000000000000000" +
"00000000000000000000000000000000000000000000000000000000000000" +
"00000000000000000000000000000000000000000000000000000000000000" +
"00000000000000000000000000000000000000000000000000000000000000" +
"00000000000000000000000000000000000000000000000000000000000000" +
"00000000000180000000000000000000000000000000000000000000000000" +
"00000000000001e00000000000000000000000000000000000000000000000" +
"000000000000000024f47261b0000000000000000000000000000000000000" +
"00000000000000000000000000000000000000000000000000000000000000" +
"00000000000000000000000000000000000000000000000000000000000000" +
"000000000000000000000024f47261b0000000000000000000000000000000" +
"00000000000000000000000000000000000000000000000000000000000000" +
"00000000000000000000000000000000000000000000000000000000000000" +
"00000000000000000000000000000100000000000000000000000000000000" +
"00000000000000000000000000000000000000000000000000000000000000" +
"00000000000000000000000000000000000000000000000000000000000000" +
"00000000000000000000000000010000000000000000000000000000000000" +
"000000000000000000000000000000").HexToByteArray();
CollectionAssert.AreEqual(expectedTxData, callData.TxData);
}
internal Chain CreateChain(Address owner, string name, Chain parentChain, Block parentBlock)
{
if (name != RootChainName)
{
if (parentChain == null || parentBlock == null)
{
return(null);
}
}
if (!Chain.ValidateName(name))
{
return(null);
}
// check if already exists something with that name
var temp = FindChainByName(name);
if (temp != null)
{
return(null);
}
SmartContract contract;
switch (name)
{
case "privacy": contract = new PrivacyContract(); break;
case "storage": contract = new StorageContract(); break;
case "vault": contract = new VaultContract(); break;
case "bank": contract = new BankContract(); break;
case "apps": contract = new AppsContract(); break;
case "dex": contract = new ExchangeContract(); break;
case "market": contract = new MarketContract(); break;
case "energy": contract = new EnergyContract(); break;
case "nacho": contract = new NachoContract(); break;
case "casino": contract = new CasinoContract(); break;
default:
{
var sb = new ScriptBuilder();
contract = new CustomContract(sb.ToScript(), null); // TODO
break;
}
}
var tokenContract = new TokenContract();
var gasContract = new GasContract();
var chain = new Chain(this, name, _logger);
chain.Initialize(new[] { tokenContract, gasContract, contract });
// add to persisent list of chains
var chainList = this.Chains.ToList();
chainList.Add(name);
this.Chains = chainList;
// add address and name mapping
this._vars.Set(ChainAddressMapKey + chain.Address.Text, Encoding.UTF8.GetBytes(chain.Name));
this._vars.Set(ChainNameMapKey + chain.Name, chain.Address.PublicKey);
if (parentChain != null)
{
this._vars.Set(ChainParentNameKey + chain.Name, Encoding.UTF8.GetBytes(parentChain.Name));
this._vars.Set(ChainParentBlockKey + chain.Name, parentBlock.Hash.ToByteArray());
}
_chainCache[chain.Name] = chain;
return(chain);
}
internal Chain CreateChain(Address owner, string name, Chain parentChain, Block parentBlock)
{
if (parentChain == null || parentBlock == null)
{
return(null);
}
if (owner != GenesisAddress)
{
if (parentChain.Level < 2)
{
return(null);
}
}
if (!Chain.ValidateName(name))
{
return(null);
}
// check if already exists something with that name
var temp = FindChainByName(name);
if (temp != null)
{
return(null);
}
SmartContract contract;
switch (name)
{
case "privacy": contract = new PrivacyContract(); break;
case "storage": contract = new StorageContract(); break;
case "vault": contract = new VaultContract(); break;
case "bank": contract = new BankContract(); break;
case "apps": contract = new AppsContract(); break;
case "dex": contract = new ExchangeContract(); break;
case "market": contract = new MarketContract(); break;
case "energy": contract = new EnergyContract(); break;
default:
{
var sb = new ScriptBuilder();
contract = new CustomContract(sb.ToScript(), null); // TODO
break;
}
}
var tokenContract = new TokenContract();
var gasContract = new GasContract();
var chain = new Chain(this, name, new[] { tokenContract, gasContract, contract }, _logger, parentChain, parentBlock);
lock (_chains)
{
_chains[name] = chain;
}
return(chain);
}
/// <summary>
/// Destroys this instance
/// </summary>
public void Shutdown()
{
ExchangeContract = null;
}
