private void ButtonStart_Click(object sender, EventArgs e)
{
try
{
var quikFactory = new QuikFactory();
var options = QuikClientOptions.GetDefault();
textBoxLogsWindow.AppendText("Подключаемся к терминалу Quik..." + Environment.NewLine);
if (checkBoxRemoteHost.Checked)
{
options.Host = IPAddress.Parse(textBoxHost.Text);
}
_quik = quikFactory.Create(options);
//// Отладочный вариант подключения
//if (checkBoxRemoteHost.Checked) _quik = new Quik(34136, new InMemoryStorage(), textBoxHost.Text); // инициализируем объект Quik с использованием удаленного IP-адреса терминала
//else _quik = new Quik(34136, new InMemoryStorage()); // инициализируем объект Quik с использованием локального расположения терминала (по умолчанию)
var transactionManagerFactory = new TransactionManagerFactory();
_transactionManager = transactionManagerFactory.Create(_quik, TransactionManagerOptions.GetDefault());
}
catch
{
textBoxLogsWindow.AppendText("Ошибка инициализации объекта Quik..." + Environment.NewLine);
}
if (_quik != null)
{
textBoxLogsWindow.AppendText("Экземпляр Quik создан." + Environment.NewLine);
try
{
textBoxLogsWindow.AppendText("Получаем статус соединения с сервером...." + Environment.NewLine);
isServerConnected = _quik.Functions.Service.IsConnectedAsync().Result;
if (isServerConnected)
{
textBoxLogsWindow.AppendText("Соединение с сервером установлено." + Environment.NewLine);
buttonRun.Enabled = true;
buttonStart.Enabled = false;
}
else
{
textBoxLogsWindow.AppendText("Соединение с сервером НЕ установлено." + Environment.NewLine);
buttonRun.Enabled = false;
buttonStart.Enabled = true;
}
// для отладки
//Trace.Listeners.Add(new TextWriterTraceListener(Console.Out));
//Trace.Listeners.Add(new TextWriterTraceListener("TraceLogging.log"));
// для отладки
}
catch
{
textBoxLogsWindow.AppendText("Неудачная попытка получить статус соединения с сервером." + Environment.NewLine);
}
}
}
public DapperConnection(string connStr)
{
var dapperTransactionManager = TransactionManagerFactory.GetOrSetTransactionManager(() =>
{
return(new DapperTransactionManager(new SqlConnection(connStr)));
}) as DapperTransactionManager;
this.connection = dapperTransactionManager.connectionHolder.Connection;
this.transaction = dapperTransactionManager.connectionHolder.Transaction;
}
public async Task <UInt256> ExecuteAsync(ExpressWalletAccount account, Script script, decimal additionalGas = 0)
{
var signers = new[] { new Signer {
Scopes = WitnessScope.CalledByEntry, Account = account.AsUInt160()
} };
var factory = new TransactionManagerFactory(rpcClient);
var tm = await factory.MakeTransactionAsync(script, signers).ConfigureAwait(false);
var tx = await tm
.AddGas(additionalGas)
.AddSignatures(chain, account)
.SignAsync()
.ConfigureAwait(false);
return(await SubmitTransactionAsync(tx).ConfigureAwait(false));
}
public async Task <UInt256> ExecuteAsync(Wallet wallet, UInt160 accountHash, WitnessScope witnessScope, Script script, decimal additionalGas = 0)
{
var signers = new[] { new Signer {
Account = accountHash, Scopes = witnessScope
} };
var factory = new TransactionManagerFactory(rpcClient);
var tm = await factory.MakeTransactionAsync(script, signers).ConfigureAwait(false);
if (additionalGas > 0.0m)
{
tm.Tx.SystemFee += (long)additionalGas.ToBigInteger(NativeContract.GAS.Decimals);
}
var account = wallet.GetAccount(accountHash) ?? throw new Exception();
if (account.Contract.Script.IsMultiSigContract())
{
var signatureCount = account.Contract.ParameterList.Length;
var multiSigWallets = chain.GetMultiSigWallets(ProtocolSettings, accountHash);
if (multiSigWallets.Count < signatureCount)
{
throw new InvalidOperationException();
}
var publicKeys = multiSigWallets
.Select(w => (w.GetAccount(accountHash)?.GetKey() ?? throw new Exception()).PublicKey)
.ToArray();
for (var i = 0; i < signatureCount; i++)
{
var key = multiSigWallets[i].GetAccount(accountHash)?.GetKey() ?? throw new Exception();
tm.AddMultiSig(key, signatureCount, publicKeys);
}
}
else
{
tm.AddSignature(account.GetKey() ?? throw new Exception());
}
var tx = await tm.SignAsync().ConfigureAwait(false);
return(await rpcClient.SendRawTransactionAsync(tx).ConfigureAwait(false));
}
protected void SetUpQuik()
{
QuikFactory = new QuikFactory();
var quikClientOptions = QuikClientOptions.GetDefault();
Quik = QuikFactory.Create(quikClientOptions);
Quik.Client.Start();
var pendingResultContainer = new PendingResultContainer();
var eventTypeProvider = new EventTypeProvider();
Serializer = new QuikJsonSerializer(pendingResultContainer, eventTypeProvider);
var transactionManagerFactory = new TransactionManagerFactory();
TransactionManager = transactionManagerFactory.Create(Quik, TransactionManagerOptions.GetDefault());
}
private void buttonConnect_Click(object sender, EventArgs e)
{
try
{
textBoxLogs.AppendText("Подключаемся к терминалу Quik..." + Environment.NewLine);
var quikFactory = new QuikFactory();
var options = QuikClientOptions.GetDefault();
_quik = quikFactory.Create(options); // инициализируем объект Quik
//_quik = new Quik(34136, new InMemoryStorage()); // отладочный вариант
var transactionManagerFactory = new TransactionManagerFactory();
_transactionManager = transactionManagerFactory.Create(_quik, TransactionManagerOptions.GetDefault());
}
catch
{
textBoxLogs.AppendText("Ошибка инициализации объекта Quik." + Environment.NewLine);
}
if (_quik != null)
{
textBoxLogs.AppendText("Экземпляр Quik создан." + Environment.NewLine);
try
{
textBoxLogs.AppendText("Получаем статус соединения с сервером..." + Environment.NewLine);
isServerConnected = _quik.Functions.Service.IsConnectedAsync().Result;
if (isServerConnected)
{
textBoxLogs.AppendText("Соединение с сервером установлено." + Environment.NewLine);
buttonStartStop.Enabled = true;
}
else
{
textBoxLogs.AppendText("Соединение с сервером НЕ установлено." + Environment.NewLine);
buttonStartStop.Enabled = false;
}
}
catch
{
textBoxLogs.AppendText("Неудачная попытка получить статус соединения с сервером." + Environment.NewLine);
}
}
}
static async Task Main(string[] args)
{
var rpcClient = new RpcClient(new Uri($"http://localhost:{RpcPort}"));
var version = await rpcClient.GetVersionAsync().ConfigureAwait(false);
var settings = ProtocolSettings.Default with
{
Network = version.Protocol.Network,
AddressVersion = version.Protocol.AddressVersion
};
var contracts = await rpcClient.ListContractsAsync().ConfigureAwait(false);
var contract = contracts.Single(t => t.manifest.Name == "DevHawk.Registrar");
var program = new Program(settings, contract.hash);
var domainArg = new Argument <string>("domain");
var queryCmd = new Command("query")
{
domainArg
};
queryCmd.SetHandler((string domain) => program.QueryAsync(domain), domainArg);
var ownerArg = new Argument <string>("owner");
var privateKeyArg = new Argument <string>("private-key");
var registerCmd = new Command("register")
{
domainArg, ownerArg, privateKeyArg
};
registerCmd.SetHandler(
(string domain, string owner, string privateKey) =>
program.RegisterAsync(domain, owner, privateKey),
domainArg, ownerArg, privateKeyArg);
var rootCmd = new RootCommand()
{
queryCmd, registerCmd,
};
await rootCmd.InvokeAsync(args).ConfigureAwait(false);
}
Task <int> QueryAsync(string domain)
{
return(HandleErrors(async() =>
{
var domainParam = new ContractParameter(ContractParameterType.String)
{
Value = domain
};
using var builder = new ScriptBuilder();
builder.EmitDynamicCall(contractHash, "query", domainParam);
var rpcClient = new RpcClient(new Uri($"http://localhost:{RpcPort}"), protocolSettings: settings);
var result = await rpcClient.InvokeScriptAsync(builder.ToArray()).ConfigureAwait(false);
if (!string.IsNullOrEmpty(result.Exception))
{
throw new Exception(result.Exception);
}
if (result.Stack.Length != 1)
{
throw new Exception($"Unexpected result stack length {result.Stack.Length}");
}
var ownerScriptHash = ToUInt160(result.Stack[0]);
var text = ownerScriptHash.Equals(UInt160.Zero)
? $"query: {domain} unowned"
: $"query: {domain} owned by {ownerScriptHash.ToAddress(settings.AddressVersion)}";
await Console.Out.WriteLineAsync(text).ConfigureAwait(false);
}));
}
Task <int> RegisterAsync(string domain, string owner, string privateKey)
{
return(HandleErrors(async() =>
{
var keyPair = new KeyPair(Convert.FromHexString(privateKey));
var ownerAccount = owner.ToScriptHash(settings.AddressVersion);
var domainParam = new ContractParameter(ContractParameterType.String)
{
Value = domain
};
var ownerParam = new ContractParameter(ContractParameterType.Hash160)
{
Value = ownerAccount
};
using var builder = new ScriptBuilder();
builder.EmitDynamicCall(contractHash, "register", domainParam, ownerParam);
var rpcClient = new RpcClient(new Uri($"http://localhost:{RpcPort}"), protocolSettings: settings);
var factory = new TransactionManagerFactory(rpcClient);
var signers = new[] { new Signer {
Account = ownerAccount, Scopes = WitnessScope.CalledByEntry
} };
var tm = await factory.MakeTransactionAsync(builder.ToArray(), signers).ConfigureAwait(false);
tm.AddSignature(keyPair);
var tx = await tm.SignAsync().ConfigureAwait(false);
var txHash = await rpcClient.SendRawTransactionAsync(tx).ConfigureAwait(false);
await Console.Out.WriteLineAsync($"register: {domain} to {owner} (tx hash: {txHash})").ConfigureAwait(false);
}));
}
