public async Task Should_Serialize_And_Sign_TransactionAsync()
{
var account2 = Account.CreateFromPrivateKey("D54AC0CB0FF50FB44233782B3A6B5FDE2F1C83B9AE2F1352119F93713F3AB923", NetworkType.TEST_NET);
// var nonce = MosaicNonce.CreateRandom();
var account = Account.CreateFromPrivateKey("feab2970d23c9a6f0170adf9b846575831c63084bcf1f0d7e70644818c546017", NetworkType.TEST_NET);
// var mosaicId = MosaicId.CreateFromNonce(nonce, account.PublicAccount.PublicKey);
var mosaicToTransfer = NetworkCurrencyMosaic.CreateRelative(1000);
var transferTransaction = TransferTransaction.Create(Deadline.Create(),
Recipient.From(Address.CreateFromRawAddress("VDVLDGVUEZ2X2CB5AZLOVHV6UK4DPCQHHWHCV75T")),
new List <Mosaic>()
{
mosaicToTransfer
},
PlainMessage.Create("test-message"),
NetworkType.TEST_NET
);
var generationHash = "B750FC8ADD9FAB8C71F0BB90B6409C66946844F07C5CADB51F27A9FAF219BFC7";
var signedTransaction = account.Sign(transferTransaction, generationHash);
//var payload = signedTransaction.Payload;
signedTransaction.Payload.Should().NotBeNullOrEmpty();
signedTransaction.Hash.Should().NotBeNullOrEmpty();
}
bool OnPlainMessage(byte[] buf, int size, IPEndPoint remoteEP, ref int connectionId, ref ArraySegment <byte> ret)
{
int offset = 1;
connectionId = BinaryUtil.ReadInt(buf, ref offset);
if (!m_PeerManager.TryGetValue(connectionId, out PeerEntry peer))
{
return(false);
}
if (!peer.EndPoint.Equals(remoteEP))
{
return(false);
}
if (!PlainMessage.TryUnpack(buf, size, out var packet))
{
return(false);
}
ret = packet.Payload;
return(true);
}
public async Task <object> TestingTransfer(string from, string privateKey, string to, IAsset asset, decimal amount)
{
var nodeHttp = new NodeHttp(_nemUrl);
var networkType = await nodeHttp.GetNetworkType();
var networkTime = (int)(await nodeHttp.GetExtendedNodeInfo()).NisInfo.CurrentTime;
var toAddressParts = to.Split(AddressSeparator);
var message = toAddressParts.Length > 1
? PlainMessage.Create(toAddressParts[1]) as IMessage
: EmptyMessage.Create();
var mosaic = Mosaic.CreateFromIdentifier(asset.AssetId, (ulong)asset.ToBaseUnit(amount));
var fee = await TransferTransaction.CalculateFee(networkType, message, new[] { mosaic }, new NamespaceMosaicHttp(_nemUrl));
var tx = TransferTransaction.Create(
networkType,
new Deadline(networkTime + _expiresInSeconds),
fee.fee,
Address.CreateFromEncoded(toAddressParts[0]),
new List <Mosaic> {
mosaic
},
message,
networkTime);
var signed = tx.SignWith(KeyPair.CreateFromPrivateKey(privateKey));
var result = await new TransactionHttp(_nemUrl).Announce(signed);
return(result);
}
private static IMessage GetMessage(JObject msg)
{
try
{
var msgType = msg["type"].ToObject <int>();
var payload = msg["payload"].ToObject <string>().FromHex();
switch (MessageTypeExtension.GetRawValue(msgType))
{
case MessageType.PLAIN_MESSAGE:
if (payload.Length <= 0)
{
return(EmptyMessage.Create());
}
return(PlainMessage.Create(Encoding.UTF8.GetString(payload)));
case MessageType.SECURED_MESSAGE:
return(SecureMessage.CreateFromEncodedPayload(payload));
default:
return(EmptyMessage.Create());
}
}
catch (Exception)
{
return(EmptyMessage.Create());
}
}
public static async System.Threading.Tasks.Task CreateTransactionAsync(int xpxAmount, List <Account> recipients)
{
foreach (var recipient in recipients)
{
var client = new SiriusClient("http://bctestnet1.brimstone.xpxsirius.io:3000");
var networkType = client.NetworkHttp.GetNetworkType().Wait();
var mosaicToTransfer = NetworkCurrencyMosaic.CreateRelative((ulong)xpxAmount);
var transferTransaction = TransferTransaction.Create(
Deadline.Create(),
recipient.Address,
new List <Mosaic>()
{
mosaicToTransfer
},
PlainMessage.Create("Transfered " + xpxAmount.ToString() + " successfully."),
NetworkType.TEST_NET
);
var generationHash = await client.BlockHttp.GetGenerationHash();
var signedTransaction = senderAccount.Sign(transferTransaction, generationHash);
await client.TransactionHttp.Announce(signedTransaction);
var newAccountInfo = await client.AccountHttp.GetAccountInfo(senderAccount.Address);
Console.WriteLine("Sent " + Convert.ToInt32(xpxAmount) + " XPX to: \n");
Console.WriteLine($"{nameof(newAccountInfo)} : {newAccountInfo}");
}
}
public static async Task getResponse()
{
try
{
Account account = Account.CreateFromPrivateKey("5cd5a454be8045056bd3c5e67c20dea92a8eb4921351d850f0249983a804a903", NetworkType.Types.TEST_NET);
KeyPair keyPair = account.KeyPair;
var transaction = TransferTransaction.Create(
NetworkType.Types.TEST_NET,
Deadline.CreateHours(2),
Address.CreateFromEncoded("TB2Z7J-R2K3BZ-2TRS6D-H5747F-Y3XKUM-BNWCI4-BPDJ"),
new List <Mosaic> {
Xem.CreateRelative(10)
},
PlainMessage.Create("Well shit. W/ mosaic")
);
SignedTransaction signedTransaction = transaction.SignWith(keyPair);
TransactionResponse response = await new TransactionHttp("http://" + Config.Domain + ":7890").Announce(signedTransaction);
Console.WriteLine(response.Message);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
Console.WriteLine(e.StackTrace);
}
}
public void CanHandleImPingMessages()
{
var ims = new List <DirectMessageChannel>
{
new DirectMessageChannel {
Id = "IMID"
}
};
var mockState = new Mock <IBotState>();
mockState.Setup(m => m.Ims).Returns(ims).Verifiable();
var message = new PlainMessage
{
Type = EventType.Message,
Subtype = MessageSubType.PlainMessage,
Channel = "IMID",
Text = "ping"
};
var handler = new UserPingHandler();
handler.BotState = mockState.Object;
var result = handler.CanHandle(message);
Assert.True(result);
}
private static IMessageBase CheckPorn(string cacheImageName, byte[] image)
{
IMessageBase imageMessage = null;
string path = Path.GetDirectoryName(cacheImageName);
string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(cacheImageName);
string healthFileName = Path.Combine(path, fileNameWithoutExtension + "_IsHealth.png");
string notHealthFileName = Path.Combine(path, fileNameWithoutExtension + "_NotHealth.png");
try
{
bool bHealth = TencentCloudHelper.CheckImageHealth(image);
if (bHealth)
{
if (File.Exists(cacheImageName))
{
File.Move(cacheImageName, healthFileName, true);
}
}
else
{
imageMessage = new PlainMessage(BotInfo.SearchCheckPornIllegalReply);
if (File.Exists(cacheImageName))
{
File.Move(cacheImageName, notHealthFileName, true);
}
}
}
catch (Exception ex)
{
imageMessage = new PlainMessage(BotInfo.SearchCheckPornErrorReply.ReplaceGreenOnionsTags(new KeyValuePair <string, string>("错误信息", ex.Message)));
}
return(imageMessage);
}
public RpcAnswer RpcCall(Combinator combinator, params string[] expectedAnswers)
{
Trace.TraceInformation("#Send plain: {0}", combinator);
var pm = new PlainMessage(0, combinator);
var transport = new TcpTransport(_connection.PacketNumber++, pm.Serialize());
byte[] responseb = _connection.ExchangeWithServer(transport.Serialize());
TcpTransport answer;
using (var ms = new MemoryStream(responseb))
answer = new TcpTransport(ms);
uint constructor = PlainMessage.ExtractConstructor(answer.Payload);
new Crc32();
foreach (string item in expectedAnswers)
{
uint crc32 = Crc32.Compute(Encoding.UTF8.GetBytes(item));
if (crc32 == constructor)
{
var resultCombinator = new PlainMessage(answer.Payload, item.Split(' ').Last().Trim()).Combinator;
Trace.TraceInformation("#Recieve plain: {0}", resultCombinator);
return(new RpcAnswer(resultCombinator));
}
}
throw new ArgumentException("unexpected answer");
}
public async Task AnnounceTransferTransactionWithMosaicWithMessage()
{
var keyPair = KeyPair.CreateFromPrivateKey(Config.PrivateKeyMain);
var account = new Account("E45030D2A22D97FDC4C78923C4BBF7602BBAC3B018FFAD2ED278FB49CD6F218C", NetworkType.Types.MIJIN_TEST);
var transaction = TransferTransaction.Create(
NetworkType.Types.MIJIN_TEST,
Deadline.CreateHours(2),
account.Address,
new List <Mosaic> {
Mosaic.CreateFromIdentifier("nem:xem", 100000000000)
},
PlainMessage.Create("hello")
).SignWith(keyPair);
listener.TransactionStatus(Address.CreateFromPublicKey(transaction.Signer, NetworkType.Types.MIJIN_TEST))
.Subscribe(e =>
{
Console.WriteLine(e.Status);
});
await new TransactionHttp("http://" + Config.Domain + ":3000").Announce(transaction);
var status = await listener.ConfirmedTransactionsGiven(Address.CreateFromPublicKey(transaction.Signer, NetworkType.Types.MIJIN_TEST)).Take(1);
Assert.AreEqual(keyPair.PublicKeyString, status.Signer.PublicKey);
}
public async Task AnnounceMultisigTransaction()
{
var cosignatory = KeyPair.CreateFromPrivateKey("8db858dcc8e2827074498204b3829154ec4c4f24d13738d3f501003b518ef256");
var multisigAccount = PublicAccount.CreateFromPublicKey("29c4a4aa674953749053c8a35399b37b713dedd5d002cb29b3331e56ff1ea65a", NetworkType.Types.TEST_NET);
var recipient = new Account("E45030D2A22D97FDC4C78923C4BBF7602BBAC3B018FFAD2ED278FB49CD6F218C", NetworkType.Types.TEST_NET);
var transaction = TransferTransaction.Create(
NetworkType.Types.TEST_NET,
Deadline.CreateHours(2),
recipient.Address,
new List <Mosaic> {
Mosaic.CreateFromIdentifier("nem:xem", 1000000)
},
PlainMessage.Create("hello")
);
var multisigTransaction = MultisigTransaction.Create(
NetworkType.Types.TEST_NET,
Deadline.CreateHours(1),
transaction
).SignWith(cosignatory, multisigAccount);
var response = await new TransactionHttp("http://" + Config.Domain + ":7890").Announce(multisigTransaction);
Assert.AreEqual("SUCCESS", response.Message);
}
public void ShouldCreateAggregateTransactionAndSignWithMultipleCosignatories()
{
TransferTransaction transferTx = TransferTransaction.Create(
NetworkType.Types.MIJIN_TEST,
FakeDeadline.Create(),
new Address("SBILTA367K2LX2FEXG5TFWAS7GEFYAGY7QLFBYKC", NetworkType.Types.MIJIN_TEST),
new List <Mosaic>(),
PlainMessage.Create("test-message")
);
AggregateTransaction aggregateTx = AggregateTransaction.CreateComplete(
NetworkType.Types.MIJIN_TEST,
FakeDeadline.Create(),
new List <Transaction>()
{
transferTx.ToAggregate(new PublicAccount("B694186EE4AB0558CA4AFCFDD43B42114AE71094F5A1FC4A913FE9971CACD21D", NetworkType.Types.MIJIN_TEST))
});
Account cosignatoryAccount = new Account("2a2b1f5d366a5dd5dc56c3c757cf4fe6c66e2787087692cf329d7a49a594658b", NetworkType.Types.MIJIN_TEST);
Account cosignatoryAccount2 = new Account("b8afae6f4ad13a1b8aad047b488e0738a437c7389d4ff30c359ac068910c1d59", NetworkType.Types.MIJIN_TEST);
SignedTransaction signedTransaction = cosignatoryAccount.SignTransactionWithCosignatories(aggregateTx, new List <Account>()
{
cosignatoryAccount2
});
Assert.AreEqual("2D010000", signedTransaction.Payload.Substring(0, 8));
Assert.AreEqual("5100000051000000", signedTransaction.Payload.Substring(240, 16));
}
public void ShouldCastToType()
{
EventMessageBase message = new PlainMessage();
var result = EventMessageExtensions.CastTo <PlainMessage>(message);
Assert.Same(message, result);
}
public void CanNotHandleInvalidPingMessages()
{
var selfData = new SelfBotData {
Id = "BOTID"
};
var mockState = new Mock <IBotState>();
mockState.Setup(m => m.Ims).Returns(new List <DirectMessageChannel>()).Verifiable();
mockState.Setup(m => m.Self).Returns(selfData).Verifiable();
var message = new PlainMessage
{
Type = EventType.Message,
Subtype = MessageSubType.PlainMessage,
Text = "<@BOTID>: pingdom"
};
var handler = new UserPingHandler();
handler.BotState = mockState.Object;
var result = handler.CanHandle(message);
Assert.False(result);
}
public void ProcessMessage(MsgReply rply, IChatMessage[] chain)
{
StringBuilder str = new StringBuilder();
List <string> pic = new List <string>();
foreach (IChatMessage msg in chain)
{
switch (msg.Type)
{
case PlainMessage.MsgType:
PlainMessage pmsg = (PlainMessage)msg;
str.Append(pmsg.Message);
break;
case ImageMessage.MsgType:
ImageMessage imsg = (ImageMessage)msg;
pic.Add(imsg.Url);
break;
default:
break;
}
}
PrivateMessage(rply, str.ToString(), pic.ToArray());
}
public void IsImShouldNotMatchMissingDirectMessage()
{
var ims = new List <DirectMessageChannel>()
{
new DirectMessageChannel {
Id = "BADID1"
},
new DirectMessageChannel {
Id = "BADID2"
},
new DirectMessageChannel {
Id = "BADID3"
}
};
var mockState = new Mock <IBotState>();
mockState.Setup(m => m.Ims).Returns(ims).Verifiable();
var message = new PlainMessage()
{
Type = EventType.Message,
Subtype = MessageSubType.PlainMessage,
Channel = "TESTID"
};
var result = EventMessageExtensions.IsIm(message, mockState.Object);
mockState.Verify();
Assert.False(result);
}
public MockTempMessageEventArgs(string message, long id, string name)
{
Chain[0] = new PlainMessage(message);
Sender = new MockGroupMemberInfo()
{
Group = MockGroupInfo.TestMockGroupInfo, Name = name, Id = id
};
}
public async Task HandleMessageAsync2(IMiraiHttpSession session, IFriendMessageEventArgs e) // 法2: 使用 params IMessageBase[]
{
IChatMessage plain1 = new PlainMessage($"收到了来自{e.Sender.Name}({e.Sender.Remark})[{e.Sender.Id}]的私聊消息:{string.Join(null, (IEnumerable<IChatMessage>)e.Chain)}");
// / 好友昵称 / / 好友备注 / / 好友QQ号 / / 消息链 /
IChatMessage plain2 = new PlainMessage("嘤嘤嘤"); // 在下边的 SendFriendMessageAsync, 你可以串起n个 IChatMessage
await session.SendFriendMessageAsync(e.Sender.Id, plain1 /*, plain2, /* etc... */); // 向消息来源好友异步发送由以上chain表示的消息
e.BlockRemainingHandlers = false; // 不阻断消息传递。如需阻断请返回true
}
public async Task <Account> GenerateAccountWithCurrency(ulong amount)
{
var account = Account.GenerateNewAccount(NetworkType);
var mosaic = NetworkCurrencyMosaic.CreateRelative(amount);
var message = PlainMessage.Create("Send some money");
var tx = await Transfer(SeedAccount, account.Address, mosaic, message, GenerationHash);
return(account);
}
public async Task <bool> GroupMessage2(MiraiHttpSession session, IGroupMessageEventArgs e) // 法2: 使用 params IMessageBase[]
{
IMessageBase plain1 = new PlainMessage($"收到了来自{e.Sender.Name}[{e.Sender.Id}]{{{e.Sender.Permission}}}的群消息:{string.Join(null, (IEnumerable<IMessageBase>)e.Chain)}");
// / 发送者群名片 / / 发送者QQ号 / / 发送者在群内权限 / / 消息链 /
IMessageBase plain2 = new PlainMessage("QAQ"); // 在下边的 SendGroupMessageAsync, 你可以串起n个 IMessageBase
await session.SendGroupMessageAsync(e.Sender.Group.Id, plain1 /*, plain2, /* etc... */); // 向消息来源群异步发送由以上chain表示的消息
return(false); // 不阻断消息传递。如需阻断请返回true
}
internal static TransferTransaction CreateInnerTransferTransaction(String signer)
{
return(TransferTransaction.Create(
NetworkType.Types.MIJIN_TEST,
Deadline.CreateHours(2),
Address.CreateFromEncoded("SAAA57DREOPYKUFX4OG7IQXKITMBWKD6KXTVBBQP"),
new List <Mosaic> {
Mosaic.CreateFromIdentifier("nem:xem", 10)
},
PlainMessage.Create("hey")));
}
public async Task Should_Announce_Aggregate_Transaction_Signed_Aggregate_Transaction()
{
var account = Account.GenerateNewAccount(Fixture.NetworkType);
var mosaic = NetworkCurrencyMosaic.CreateAbsolute(1);
var message = PlainMessage.Create("c#__ SDK plain message test");
var result = await Fixture.AggregateTransfer(Fixture.SeedAccount, account.Address, mosaic, message, Fixture.GenerationHash);
Log.WriteLine($"Transaction confirmed {result.TransactionInfo.Hash}");
result.TransactionInfo.Hash.Should().NotBeNullOrWhiteSpace();
result.TransactionType.Should().Be(EntityType.AGGREGATE_COMPLETE);
}
public async Task <Account> GenerateAccountAndSendSomeMoney(int amount)
{
var networkType = Client.NetworkHttp.GetNetworkType().Wait();
var account = Account.GenerateNewAccount(networkType);
var money = (ulong)amount;
var mosaicToTransfer = NetworkCurrencyMosaic.CreateRelative(money);
var transferTransaction = TransferTransaction.Create(
Deadline.Create(),
account.Address,
new List <Mosaic>()
{
// mosaicToTransfer
},
PlainMessage.Create("transferTest"),
networkType);
var signedTransaction = SeedAccount.Sign(transferTransaction, Environment.GenerationHash);
WatchForFailure(signedTransaction);
try
{
await WebSocket.Listener.Open();
var tx = WebSocket.Listener.ConfirmedTransactionsGiven(account.Address).Take(1).Timeout(TimeSpan.FromSeconds(100));
await Client.TransactionHttp.Announce(signedTransaction);
var result = await tx;
if (result.IsConfirmed())
{
return(account);
}
else
{
throw new Exception($"Unable to send money to account {account.Address.Plain}");
}
}
finally
{
try
{
// WebSocket.Listener.Close();
}
catch (Exception)
{
//do nothing
}
}
}
public void IsActivePlainMessageShouldNotMatchWrongEventType()
{
var message = new PlainMessage()
{
Type = EventType.Hello,
Subtype = MessageSubType.PlainMessage,
};
var result = EventMessageExtensions.IsActivePlainMessage(message);
Assert.False(result);
}
public async Task Should_Announce_Transfer_Transaction_With_NetworkCurrencyMosaic_PlainMessage()
{
var account = Account.GenerateNewAccount(Fixture.NetworkType);
var mosaic = NetworkCurrencyMosaic.CreateRelative(10);
var message = PlainMessage.Create("Test message");
var result = await Fixture.Transfer(Fixture.SeedAccount, account.Address, mosaic, message, Fixture.GenerationHash);
Log.WriteLine($"Transaction confirmed {result.TransactionInfo.Hash}");
result.TransactionInfo.Hash.Should().NotBeNullOrWhiteSpace();
//result.TransactionType.Should().Be(EntityType.TRANSFER);
((TransferTransaction)result).Message.GetMessageType().Should().Be(MessageType.PLAIN_MESSAGE.GetValueInByte());
}
public void IsActivePlainMessageShouldMatch()
{
var message = new PlainMessage()
{
Type = EventType.Message,
Subtype = MessageSubType.PlainMessage,
};
var result = EventMessageExtensions.IsActivePlainMessage(message);
Assert.True(result);
}
internal static TransferTransaction CreateInnerTransferTransaction(string mosaic, ulong amount = 10)
{
return(TransferTransaction.Create(
NetworkType.Types.MIJIN_TEST,
Deadline.CreateHours(2),
Address.CreateFromEncoded("SAAA57-DREOPY-KUFX4O-G7IQXK-ITMBWK-D6KXTV-BBQP"),
new List <Mosaic> {
Mosaic.CreateFromIdentifier(mosaic, amount)
},
PlainMessage.Create("hey")
));
}
public void ShouldNotMatchInvalidText()
{
var message = new PlainMessage()
{
Type = EventType.Message,
Subtype = MessageSubType.PlainMessage,
Text = "test message"
};
var result = EventMessageExtensions.MatchesText(message, @"testing");
Assert.False(result);
}
public void ShouldMatchValidText()
{
var message = new PlainMessage()
{
Type = EventType.Message,
Subtype = MessageSubType.PlainMessage,
Text = "test message"
};
var result = EventMessageExtensions.MatchesText(message, @"\btest\b");
Assert.True(result);
}
public void IsActivePlainMessageShouldNotMatchHistoric()
{
var message = new PlainMessage()
{
Type = EventType.Message,
Subtype = MessageSubType.PlainMessage,
Historic = true
};
var result = EventMessageExtensions.IsActivePlainMessage(message);
Assert.False(result);
}
