public string SponsoredFeeForAsset(PrivateKeyAccount account, Asset asset, decimal minimalFeeInAssets)
{
var tx = new SponsoredFeeTransaction(account.PublicKey, asset, minimalFeeInAssets);
tx.Sign(account);
return(Broadcast(tx));
}
public string BurnAsset(PrivateKeyAccount account, Asset asset, decimal amount)
{
var tx = new BurnTransaction(account.PublicKey, asset, amount).Sign(account);
tx.Sign(account);
return(Broadcast(tx));
}
public string CreateAlias(PrivateKeyAccount account, string alias, char scheme, long fee)
{
var tx = new AliasTransaction(account.PublicKey, alias, scheme);
tx.Sign(account);
return(Broadcast(tx));
}
public string Lease(PrivateKeyAccount sender, string recipient, decimal amount)
{
var tx = new LeaseTransaction(sender.PublicKey, recipient, amount);
tx.Sign(sender);
return(Broadcast(tx));
}
public string ReissueAsset(PrivateKeyAccount account, Asset asset, decimal quantity, bool reissuable)
{
var tx = new ReissueTransaction(account.PublicKey, asset, quantity, reissuable);
tx.Sign(account);
return(Broadcast(tx));
}
public string PlaceOrder(PrivateKeyAccount sender, OrderSide side,
Asset amountAsset, Asset priceAsset, decimal price, decimal amount, DateTime expiration)
{
var order = MakeOrder(sender, MatcherKey, side, amountAsset, priceAsset, price, amount, expiration, 0.02m);
return(Http.Post($"{_host}/matcher/orderbook", order));
}
public string PutData(PrivateKeyAccount account, DictionaryObject entries)
{
var tx = new DataTransaction(account.PublicKey, entries);
tx.Sign(account);
return(Broadcast(tx));
}
public string CancelLease(PrivateKeyAccount account, string transactionId)
{
var tx = new CancelLeasingTransaction(account.PublicKey, transactionId);
tx.Sign(account);
return(Broadcast(tx));
}
public string Transfer(PrivateKeyAccount sender, string recipient, Asset asset, decimal amount,
string message = "")
{
var tx = new TransferTransaction(sender.PublicKey, recipient, asset, amount, message);
tx.Sign(sender);
return(Broadcast(tx));
}
public string MassTransfer(PrivateKeyAccount sender, Asset asset, IEnumerable <MassTransferItem> transfers,
string message = "")
{
var tx = new MassTransferTransaction(sender.PublicKey, asset, transfers, message);
tx.Sign(sender);
return(Broadcast(tx));
}
public string DeleteOrder(PrivateKeyAccount account,
Asset amountAsset, Asset priceAsset, string orderId)
{
var request = MakeOrderCancelRequest(account, orderId);
var url = $"{_host}/matcher/orderbook/{amountAsset.Id}/{priceAsset.Id}/delete";
return(Http.Post(url, request));
}
public Order[] GetOrders(PrivateKeyAccount account, Asset amountAsset, Asset priceAsset)
{
string path = $"{_host}/matcher/orderbook/{amountAsset.Id}/{priceAsset.Id}/publicKey/{account.PublicKey.ToBase58()}";
var headers = GetProtectionHeaders(account);
var response = Http.GetObjectsWithHeaders(path, headers);
return(response.Select(j => Order.CreateFromJson(j, amountAsset, priceAsset)).ToArray());
}
public Asset IssueAsset(PrivateKeyAccount account,
string name, string description, decimal quantity, byte decimals, bool reissuable)
{
var tx = new IssueTransaction(account.PublicKey, name, description, quantity, decimals, reissuable);
tx.Sign(account);
var response = Broadcast(tx);
var assetId = response.ParseJsonObject().GetString("id");
return(new Asset(assetId, name, decimals));
}
private static NameValueCollection GetProtectionHeaders(PrivateKeyAccount account)
{
long timestamp = Utils.CurrentTimestamp();
var stream = new MemoryStream(40);
var writer = new BinaryWriter(stream);
writer.Write(account.PublicKey);
writer.WriteLong(timestamp);
var signature = account.Sign(stream);
return(new NameValueCollection
{
{ "Timestamp", Convert.ToString(timestamp) },
{ "Signature", signature.ToBase58() }
});
}
public static DictionaryObject MakeOrderCancelRequest(PrivateKeyAccount sender, string orderId)
{
var stream = new MemoryStream();
var writer = new BinaryWriter(stream);
writer.Write(sender.PublicKey);
writer.Write(Base58.Decode(orderId));
var signature = sender.Sign(stream);
return(new DictionaryObject
{
{ "sender", sender.PublicKey.ToBase58() },
{ "orderId", orderId },
{ "signature", signature.ToBase58() }
});
}
public static DictionaryObject MakeOrder(PrivateKeyAccount sender, string matcherKey, OrderSide side,
Asset amountAsset, Asset priceAsset, decimal price, decimal amount, DateTime expiration, decimal matcherFee)
{
long timestamp = Utils.CurrentTimestamp();
var stream = new MemoryStream();
var writer = new BinaryWriter(stream);
writer.Write(sender.PublicKey);
writer.Write(Base58.Decode(matcherKey));
writer.WriteAsset(amountAsset.Id);
writer.WriteAsset(priceAsset.Id);
writer.Write((byte)(side == OrderSide.Buy ? 0x0 : 0x1));
writer.WriteLong(Asset.PriceToLong(amountAsset, priceAsset, price));
writer.WriteLong(amountAsset.AmountToLong(amount));
writer.WriteLong(timestamp);
writer.WriteLong(expiration.ToLong());
writer.WriteLong(Assets.TN.AmountToLong(matcherFee));
var signature = sender.Sign(stream);
return(new DictionaryObject {
{ "senderPublicKey", Base58.Encode(sender.PublicKey) },
{ "matcherPublicKey", matcherKey },
{ "assetPair", new DictionaryObject {
{ "amountAsset", amountAsset.IdOrNull },
{ "priceAsset", priceAsset.IdOrNull }
} },
{ "orderType", side.ToString().ToLower() },
{ "price", Asset.PriceToLong(amountAsset, priceAsset, price) },
{ "amount", amountAsset.AmountToLong(amount) },
{ "timestamp", timestamp },
{ "expiration", expiration.ToLong() },
{ "matcherFee", Assets.TN.AmountToLong(matcherFee) },
{ "signature", signature.ToBase58() }
});
}
public static T Sign <T>(this T transaction, PrivateKeyAccount account, int proofIndex = 0) where T : Transaction
{
transaction.Proofs[proofIndex] = account.Sign(transaction.GetBody());
return(transaction);
}
