protected SignedTransaction Transfer(Address sender, List <PrivateKeyNotWallet> signers, Address receiver, Currency currency, Amount amount, List <TxDeclaration> declarations = null, PrivateKeyNotWallet feePayer = null, long?fees = null, TransactionMessage message = null)
{
if (message == null)
{
message = TransactionMessage.Empty;
}
var inputs = new List <TxInput>()
{
new TxInput(sender, currency, amount),
};
var outputs = new List <TxOutput>()
{
new TxOutput(receiver, currency, amount),
};
var feeTxInput = fees == null ? null : new TxInput(feePayer, Currency.BTC, fees);
var transaction = new Transaction(declarations ?? new List <TxDeclaration>(), inputs, outputs, message, DateTime.UtcNow.AddMinutes(1).ToUnixTimestamp(), feeTxInput);
var signed = new SignedTransaction(transaction);
foreach (var signer in signers)
{
Assert.IsTrue(signer.SignTransaction(signed, Network));
}
if (feePayer != null && feePayer.Address != sender)
{
Assert.IsTrue(feePayer.SignTransaction(signed, Network));
}
return(signed);
}
public void OnSubmitted(SignedTransaction transaction)
{
using (locker.CreateLock())
{
transactions.Add(transaction.Hash, new TransactionSubmission(transaction));
}
}
public async Task broadcast_transaction_synchronous()
{
var args = new SignedTransaction();
var resp = await Api.BroadcastTransactionSynchronousAsync(args, CancellationToken.None).ConfigureAwait(false);
TestPropetries(resp);
}
public async Task SerializeAndSignMultiActionTx()
{
var keyStore = new InMemoryKeyStore();
var keyPair = KeyPair.FromString("ed25519:2wyRcSwSuHtRVmkMCGjPwnzZmQLeXLzLLyED1NDMt4BjnKgQL6tF85yBx6Jr26D2dUNeC716RBoTxntVHsegogYw");
await keyStore.SetKeyAsync("test", "test.near", keyPair);
var publicKey = keyPair.GetPublicKey();
var actions = new[]
{
Action.CreateAccount(),
Action.DeployContract(new byte[] { 1, 2, 3 }),
Action.FunctionCall("qqq", new byte[] { 1, 2, 3 }, 1000, 1000000),
Action.Transfer(123),
Action.Stake(1000000, publicKey),
Action.AddKey(publicKey, AccessKey.FunctionCallAccessKey("zzz", new [] { "www" }, null)),
Action.DeleteKey(publicKey),
Action.DeleteAccount("123")
};
var blockHash = new ByteArray32()
{
Buffer = Base58.Decode("244ZQ9cgj3CQ6bWBdytfrJMuMQ1jdXLFGnr4HhvtCTnM")
};
var signedTransaction = await SignedTransaction.SignTransactionAsync("123", 1, actions, blockHash, new InMemorySigner(keyStore), "test.near", "test");
const string expected = "Fo3MJ9XzKjnKuDuQKhDAC6fra5H2UWawRejFSEpPNk3Y";
var actual = Base58.Encode(signedTransaction.Item1);
Assert.AreEqual(expected, actual);
}
public string SignTransaction(string privateKey, string serializedTransactionBase64)
{
try
{
var serializedTransaction = System.Text.Encoding.UTF8.DecodeBase64(serializedTransactionBase64);
var pkBytes = new Bytes(privateKey);
var wallet = Lykke.Icon.Sdk.KeyWallet.Load(pkBytes);
var transaction = TransactionDeserializer.Deserialize(serializedTransaction);
var signedTr = new SignedTransaction(transaction, wallet);
var props = signedTr.GetProperties();
var serializedSignedTransaction = SignedTransaction.Serialize(props);
var base64 = System.Text.Encoding.UTF8.EncodeBase64(serializedSignedTransaction);
return(base64);
}
catch (Exception e)
{
if (e is FormatException || e is ArgumentOutOfRangeException)
{
throw new ArgumentException(e.Message);
}
throw;
}
}
public async Task <SignedTransaction> CallContract(KeyPair key, byte[] scriptHash, byte[] bytes,
string attachSymbol = null, IEnumerable <TransactionOutput> attachTargets = null)
{
if (string.IsNullOrEmpty(attachSymbol))
{
attachSymbol = "GAS";
}
if (attachTargets == null)
{
attachTargets = new List <TransactionOutput>();
}
var(inputs, outputs) = await GenerateInputsOutputs(key, attachSymbol, attachTargets);
if (inputs.Count == 0)
{
throw new WalletException($"Not enough inputs for transaction");
}
var tx = new SignedTransaction
{
Type = TransactionType.InvocationTransaction,
Version = 0,
Script = bytes,
Gas = 0,
Inputs = inputs.ToArray(),
Outputs = outputs.ToArray()
};
var result = await SignAndSendTransaction(tx);
return(result ? tx : null);
}
/// <summary>
/// Sign transaction given an array of transaction, require public keys, and chain id
///
/// curl http://localhost:8889/v1/wallet/sign_transaction -X POST -d '[{"ref_block_num":21453,"ref_block_prefix":3165644999,"expiration":"2017-12-08T10:28:49","scope":["initb","initc"],"read_scope":[],"messages":[{"code":"currency","type":"transfer","authorization":[{"account":"initb","permission":"active"}],"data":"000000008093dd74000000000094dd74e803000000000000"}],"signatures":[]}, ["EOS6MRyAjQq8ud7hVNYcfnVPJqcVpscN5So8BhtHuGYqET5GDW5CV"], ""]'
/// </summary>
/// <param name="publicKeys"></param>
/// <param name="trx"></param>
/// <param name="chainId"></param>
/// <param name="token">Throws a <see cref="T:System.OperationCanceledException" /> if this token has had cancellation requested.</param>
/// <returns></returns>
public async Task <OperationResult <SignedTransaction> > WalletSignTrx(SignedTransaction trx, PublicKey[] publicKeys, string chainId, CancellationToken token)
{
var endpoint = $"{WalletUrl}/v1/wallet/sign_transaction";
var args = new object[] { trx, publicKeys, chainId };
return(await CustomPostRequest <SignedTransaction>(endpoint, args, token));
}
/// <summary>
/// a convenience method for directly appending our signature to a raw tx file
/// </summary>
/// <param name="from">the public identity we are signing as</param>
/// <param name="txBytes">the multisig transaction to append signature to</param>
/// <returns>merged multisignature transaction inclukding our signature</returns>
public byte[] AppendMultisigTransactionBytes(MultisigAddress from, byte[] txBytes)
{
SignedTransaction inTx = Encoder.DecodeFromMsgPack <SignedTransaction>(txBytes);
SignedTransaction appended = this.AppendMultisigTransaction(from, inTx);
return(Encoder.EncodeToMsgPack(appended));
}
public bool Validate(SignedTransaction signed)
{
var timestamp = LedgerService.LedgerManager.GetLedgerBeginTime();
// validate format
if (!ValidateFormat(signed))
{
return(false);
}
// validate expiration
// TODO use end time and not begin time
if (!ValidateExpiration(signed.Transaction, timestamp))
{
return(false);
}
// validate signature
if (!signed.CheckSignatures(LiveService.SignatureManager.TransactionRequiredValidationFactory, LedgerService.LedgerManager.Network, timestamp, LedgerService.LedgerManager.LedgerState))
{
return(false);
}
return(Validate(signed.Transaction));
}
private void createAssetTest(int numDecimal, string goldenString)
{
Address addr = new Address("BH55E5RMBD4GYWXGX5W5PJ5JAHPGM5OXKDQH5DC4O2MGI7NW4H6VOE4CP4");
byte[] gh = Convert.FromBase64String("SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=");
Address sender = addr;
Address manager = addr;
Address reserve = addr;
Address freeze = addr;
Address clawback = addr;
string metadataHash = "fACPO4nRgO55j1ndAK3W6Sgc4APkcyFh";
var tx = Transaction.CreateAssetCreateTransaction(sender, 10, 322575, 323575, null, null,
new Digest(gh), 100, numDecimal, false, "tst", "testcoin", "website",
Encoding.UTF8.GetBytes(metadataHash), manager, reserve, freeze, clawback);
Transaction.AssetParams expectedParams = new Transaction.AssetParams(100, numDecimal, false, "tst", "testcoin",
"website", Encoding.UTF8.GetBytes(metadataHash), manager, reserve, freeze, clawback);
Assert.AreEqual(expectedParams, tx.assetParams);
SignedTransaction stx = DEFAULT_ACCOUNT.SignTransaction(tx);
byte[] encodedOut = Encoder.EncodeToMsgPack(stx);
SignedTransaction decodedOut = Encoder.DecodeFromMsgPack <SignedTransaction>(encodedOut);
Assert.AreEqual(decodedOut, stx);
Assert.AreEqual(Convert.ToBase64String(encodedOut), goldenString);
//Assert.AreEqual(decodedOut, stx);
TestUtil.SerializeDeserializeCheck(stx);
}
public async Task TestSendIcxTransaction()
{
var provider = GetMockProvider <Bytes>();
var fromAddress = new Address("hxbe258ceb872e08851f1f59694dac2558708ece11");
var toAddress = new Address("hx5bfdb090f43a808005ffc27c25b213145e80b7cd");
var transaction = TransactionBuilder.CreateBuilder()
.Nid(NetworkId.Main)
.From(fromAddress)
.To(toAddress)
.Value(BigInteger.Parse("0de0b6b3a7640000", NumberStyles.AllowHexSpecifier))
.StepLimit(BigInteger.Parse("012345", NumberStyles.AllowHexSpecifier))
.Timestamp(BigInteger.Parse("0563a6cf330136", NumberStyles.AllowHexSpecifier))
.Nonce(BigInteger.Parse("1"))
.Build();
IWallet wallet = KeyWallet.Load(new Bytes(SampleKeys.PrivateKeyString));
var signedTransaction = new SignedTransaction(transaction, wallet);
var iconService = new IconService(provider.Object);
await iconService.SendTransaction(signedTransaction);
var expected = "xR6wKs+IA+7E91bT8966jFKlK5mayutXCvayuSMCrx9KB7670CsWa0B7LQzgsxU0GLXaovlAT2MLs1XuDiSaZQE=";
provider.Verify(x =>
x.SendRequestAsync(It.Is <Request>(request => RequestCheckTestSendIcxTransaction(request, expected)),
It.IsAny <IRpcConverter <Bytes> >()), Times.Once);
}
public void testMakeAssetRevocationTransaction()
{
Address addr = new Address("BH55E5RMBD4GYWXGX5W5PJ5JAHPGM5OXKDQH5DC4O2MGI7NW4H6VOE4CP4");
byte[] gh = Convert.FromBase64String("SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=");
Address revoker = addr;
Address revokeFrom = addr;
Address receiver = addr;
ulong assetIndex = 1;
ulong firstValidRound = 322575;
ulong lastValidRound = 323575;
ulong amountToSend = 1;
Transaction tx = Transaction.CreateAssetRevokeTransaction(revoker, revokeFrom, receiver, amountToSend,
10, firstValidRound, lastValidRound, null, null, new Digest(gh), assetIndex);
byte[] outBytes = Encoder.EncodeToMsgPack(tx);
Transaction o = Encoder.DecodeFromMsgPack <Transaction>(outBytes);
Assert.AreEqual(o, tx);
SignedTransaction stx = DEFAULT_ACCOUNT.SignTransaction(tx);
string encodedOutBytes = Convert.ToBase64String(Encoder.EncodeToMsgPack(stx));
string goldenstring = "gqNzaWfEQHsgfEAmEHUxLLLR9s+Y/yq5WeoGo/jAArCbany+7ZYwExMySzAhmV7M7S8+LBtJalB4EhzEUMKmt3kNKk6+vAWjdHhuiqRhYW10AaRhcmN2xCAJ+9J2LAj4bFrmv23Xp6kB3mZ111Dgfoxcdphkfbbh/aRhc25kxCAJ+9J2LAj4bFrmv23Xp6kB3mZ111Dgfoxcdphkfbbh/aNmZWXNCqqiZnbOAATsD6JnaMQgSGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiKibHbOAATv96NzbmTEIAn70nYsCPhsWua/bdenqQHeZnXXUOB+jFx2mGR9tuH9pHR5cGWlYXhmZXKkeGFpZAE=";
SignedTransaction stxDecoded = Encoder.DecodeFromMsgPack <SignedTransaction>(Convert.FromBase64String(encodedOutBytes));
Assert.AreEqual(stxDecoded, stx);
Assert.AreEqual(encodedOutBytes, goldenstring);
TestUtil.SerializeDeserializeCheck(stx);
}
public void testSerializationAssetFreeze()
{
Address addr = new Address("BH55E5RMBD4GYWXGX5W5PJ5JAHPGM5OXKDQH5DC4O2MGI7NW4H6VOE4CP4");
byte[] gh = Convert.FromBase64String("SGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiI=");
Address sender = addr;
Address target = addr;
ulong assetFreezeID = 1;
bool freezeState = true;
var tx = Transaction.CreateAssetFreezeTransaction(sender, target, freezeState, 10,
322575, 323576, null, new Digest(gh), assetFreezeID);
//Transaction tx = Transaction.AssetFreezeTransactionBuilder()
// .sender(sender)
// .freezeTarget(target)
// .freezeState(freezeState)
// .fee(10)
// .firstValid()
// .lastValid()
// .genesisHash(gh)
// .assetIndex(assetFreezeID)
// .build();
SignedTransaction stx = DEFAULT_ACCOUNT.SignTransaction(tx);
string encodedOutBytes = Convert.ToBase64String(Encoder.EncodeToMsgPack(stx));
SignedTransaction o = Encoder.DecodeFromMsgPack <SignedTransaction>(Convert.FromBase64String(encodedOutBytes));
string goldenstring = "gqNzaWfEQAhru5V2Xvr19s4pGnI0aslqwY4lA2skzpYtDTAN9DKSH5+qsfQQhm4oq+9VHVj7e1rQC49S28vQZmzDTVnYDQGjdHhuiaRhZnJ6w6RmYWRkxCAJ+9J2LAj4bFrmv23Xp6kB3mZ111Dgfoxcdphkfbbh/aRmYWlkAaNmZWXNCRqiZnbOAATsD6JnaMQgSGO1GKSzyE7IEPItTxCByw9x8FmnrCDexi9/cOUJOiKibHbOAATv+KNzbmTEIAn70nYsCPhsWua/bdenqQHeZnXXUOB+jFx2mGR9tuH9pHR5cGWkYWZyeg==";
Assert.AreEqual(encodedOutBytes, goldenstring);
Assert.AreEqual(o, stx);
TestUtil.SerializeDeserializeCheck(stx);
}
public static async Task getResponse()
{
try
{
Account sender = Account.CreateFromPrivateKey("5cd5a454be8045056bd3c5e67c20dea92a8eb4921351d850f0249983a804a903", NetworkType.Types.TEST_NET);
KeyPair keyPair1 = sender.KeyPair;
Account reciever = Account.CreateFromPrivateKey("5cd5a454be8045056bd3c5e67c20dea92a8eb4921351d850f0249983a804a903", NetworkType.Types.TEST_NET);
KeyPair keyPair2 = reciever.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(1)
},
SecureMessage.Create("Well shit. W/ mosaic", sender.PrivateKey, reciever.PublicKey)
);
SignedTransaction signedTransaction = transaction.SignWith(keyPair1);
TransactionResponse response = await new TransactionHttp(host).Announce(signedTransaction);
Console.WriteLine(response.Message);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
Console.WriteLine(e.StackTrace);
}
}
private bool ValidateTransaction(TestContext context, SignedTransaction signed)
{
// TODO
var state = context.LedgerService.LedgerManager.LedgerState;
return(context.LiveService.TransactionManager.TransactionValidator.ValidateBalance(state, signed.Transaction.GetInputs()));
}
public static async Task <bool> SendFromNewAccount(String message, Account newAcc)
{
KeyPair keyPair = KeyPair.CreateFromPrivateKey(newAcc.PrivateKey);
var transaction = TransferTransaction.Create(
NetworkType.Types.TEST_NET,
Deadline.CreateHours(2),
Address.CreateFromEncoded(Config.Address),
new List <Mosaic> {
Mosaic.CreateFromIdentifier("nem:xem", 10)
},
SecureMessage.Create(message, newAcc.PrivateKey, Config.PublicKey)
);
TransactionHttp transactionHttp = new TransactionHttp("http://" + Config.Domain + ":7890");
SignedTransaction signedTransaction = transaction.SignWith(keyPair);
Thread.Sleep(2000);
await transactionHttp.Announce(signedTransaction);
Thread.Sleep(2000);
Console.WriteLine(signedTransaction.Hash);
Console.WriteLine(Config.Address + " recve something from : " + newAcc.Address.Plain);
return(true);
}
public async Task broadcast_transaction()
{
var args = new SignedTransaction();
var resp = await Api.BroadcastTransaction(args, CancellationToken.None);
TestPropetries(resp);
}
public static NotificationMessage CreateTransactionReceivedNotification(SignedTransaction transaction)
{
return(CreateNotification(new API.Notifications.TransactionReceived
{
Transaction = ByteStreamConverter.ToBase64 <ByteStream>(stream => { stream.Write(transaction); })
}));
}
public static RequestMessage CreateSendSignedTransactionRequest(SignedTransaction transaction)
{
return(CreateRequest(new SendTransactionRequest
{
Transaction = ByteStreamConverter.ToBase64 <ByteStream>(stream => { stream.Write(transaction); })
}));
}
/// <summary>
///
/// </summary>
/// <param name="propertyApiObj"></param>
/// <param name="userPrivateKeys"></param>
/// <param name="token">Throws a <see cref="T:System.OperationCanceledException" /> if this token has had cancellation requested.</param>
/// <param name="operations"></param>
/// <returns></returns>
/// <exception cref="T:System.OperationCanceledException">The token has had cancellation requested.</exception>
public Task <SignedTransaction> CreateTransactionAsync(DynamicGlobalPropertyObject propertyApiObj, IList <byte[]> userPrivateKeys, BaseOperation[] operations, CancellationToken token)
{
return(Task.Run(() =>
{
var transaction = new SignedTransaction
{
ChainId = ChainId,
RefBlockNum = (ushort)(propertyApiObj.HeadBlockNumber & 0xffff),
RefBlockPrefix = (uint)BitConverter.ToInt32(Hex.HexToBytes(propertyApiObj.HeadBlockId), 4),
Expiration = propertyApiObj.Time.Value.AddSeconds(30),
Operations = operations.Select(o => new Operation(o)).ToArray()
};
var msg = MessageSerializer.Serialize <SignedTransaction>(transaction);
var data = Sha256Manager.GetHash(msg);
transaction.Signatures = new string[userPrivateKeys.Count];
for (var i = 0; i < userPrivateKeys.Count; i++)
{
token.ThrowIfCancellationRequested();
var userPrivateKey = userPrivateKeys[i];
var sig = Secp256K1Manager.SignCompressedCompact(data, userPrivateKey);
transaction.Signatures[i] = Hex.ToString(sig);
}
return transaction;
}, token));
}
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 TxDeclarationTest()
{
var account1 = CreateAccount();
var account2 = CreateAccount();
var secret = Secret.GenerateSecret();
var declarations = new List <TxDeclaration>()
{
new MultiSignature(new [] { account1.Address, account2.Address }, 2),
new HashLock(secret.ComputeSecretHash(SecretHashType.SHA3)),
new TimeLock(123),
new SecretRevelation(secret)
};
var inputs = new List <TxInput>()
{
new TxInput(account1, Currency.BTC, Amount.FromWholeValue(10)),
new TxInput(account2, Currency.LTC, Amount.FromWholeValue(30)),
};
var outputs = new List <TxOutput>()
{
new TxOutput(account2, Currency.BTC, Amount.FromWholeValue(10)),
new TxOutput(account1, Currency.LTC, Amount.FromWholeValue(30)),
};
var transaction = new Transaction(declarations, inputs, outputs, TransactionMessage.Empty, DateTime.UtcNow.Ticks);
var signed = new SignedTransaction(transaction);
var readed = WriteRead <SignedTransaction, ByteStream>(stream => stream.Write(signed), stream => stream.ReadSignedTransaction());
Assert.IsTrue(signed.CompareSigned(readed));
}
public async Task SerializeAndSignTransferTx()
{
var keyStore = new InMemoryKeyStore();
var keyPair = KeyPair.FromString("ed25519:3hoMW1HvnRLSFCLZnvPzWeoGwtdHzke34B2cTHM8rhcbG3TbuLKtShTv3DvyejnXKXKBiV7YPkLeqUHN1ghnqpFv");
await keyStore.SetKeyAsync("test", "test.near", keyPair);
var actions = new[] { Action.Transfer(1) };
var blockHash = Base58.Decode("244ZQ9cgj3CQ6bWBdytfrJMuMQ1jdXLFGnr4HhvtCTnM");
var signedTransaction = await SignedTransaction.SignTransactionAsync("whatever.near", 1, actions, new ByteArray32()
{
Buffer = blockHash
}, new InMemorySigner(keyStore), "test.near", "test");
const string expectedBase64String = "lpqDMyGG7pdV5IOTJVJYBuGJo9LSu0tHYOlEQ+l+HE8i3u7wBZqOlxMQDtpuGRRNp+ig735TmyBwi6HY0CG9AQ==";
var actualBase64String = Convert.ToBase64String(signedTransaction.Item2.Signature.Data.Buffer);
Assert.AreEqual(expectedBase64String, actualBase64String);
const string expectedHexString = "09000000746573742e6e65617200917b3d268d4b58f7fec1b150bd68d69be3ee5d4cc39855e341538465bb77860d01000000000000000d00000077686174657665722e6e6561720fa473fd26901df296be6adc4cc4df34d040efa2435224b6986910e630c2fef601000000030100000000000000000000000000000000969a83332186ee9755e4839325525806e189a3d2d2bb4b4760e94443e97e1c4f22deeef0059a8e9713100eda6e19144da7e8a0ef7e539b20708ba1d8d021bd01";
var serialized = signedTransaction.Item2.ToByteArray();
var actualHexString = BitConverter.ToString(serialized).Replace("-", "").ToLower();
Assert.AreEqual(expectedHexString, actualHexString);
}
private CustomTransactionFullInfo GetCustomTransactionFullInfo(SignedTransaction transaction,
TransactionInfo info)
{
CustomTransactionFullInfo ret = new CustomTransactionFullInfo();
if (transaction == null)
{
return(ret);
}
var customRawTransaction = new CustomRawTransaction(
transaction.SignedTxn.ToByteArray());
ret.RawTransaction = customRawTransaction;
// ret.SenderPublicKey = transaction..ToByteArray().ByteArryToString();
// ret.SenderSignature = transaction.SenderSignature.ToByteArray().ByteArryToString();
if (info != null)
{
ret.GasUsed = info.GasUsed;
}
else
{
ret.GasUsed = 0;
}
return(ret);
}
public async Task <SignedTransaction> SignTransaction(Transaction transaction, PrivateKey privateKey)
{
return(await Task.Run(() =>
{
SignedTransaction stx = new SignedTransaction()
{
Transaction = transaction
};
byte[] packed_trx;
using (MemoryStream ms = new MemoryStream())
using (BinaryWriter writer = new BinaryWriter(ms))
{
transaction.WriteBytes(writer);
packed_trx = ms.ToArray();
}
stx.PackedTransaction = packed_trx.ToHex();
byte[] data = transaction.ChainId.FromHex().Concat(packed_trx, new byte[32]);
string signature = privateKey.SignData(data);
stx.Signatures = new List <string>()
{
signature
};
// TODO: compression type
stx.Compression = "none";
return stx;
}));
}
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 async Task <string> BroadcastTransactionAsync(string signedTransaction)
{
var result = await new TransactionHttp(_nemUrl).Announce(SignedTransaction.FromJson(signedTransaction));
// see https://nemproject.github.io/#nemRequestResult
// for meaning of the code
switch (result.Code)
{
case 0:
case 1:
// success
break;
case 3:
case 9:
throw new BlockchainException(BlockchainErrorCode.BuildingShouldBeRepeated, "Transaction expired");
case 7:
throw new BlockchainException(BlockchainErrorCode.BuildingShouldBeRepeated, "Transaction hash duplicated");
case 5:
throw new BlockchainException(BlockchainErrorCode.NotEnoughBalance, "Not enough balance");
default:
throw new ArgumentException(result.Message);
}
return(null);
}
public static void DisplayTransaction(SignedTransaction signed)
{
var transaction = signed.Transaction;
var hash = signed.Hash;
var expire = TimeFormat.ToDateTime(transaction.Expire);
var message = TransactionMessageFormat.ToString(transaction.Message);
Console.WriteLine("------------------------------");
Console.WriteLine($"Transaction Hash {hash.ToBase64()} Expire {expire} Message {message}");
Console.WriteLine("Inputs :");
foreach (var input in transaction.Inputs)
{
DisplayTxInputOutput(input);
}
Console.WriteLine("Outputs :");
foreach (var output in transaction.Outputs)
{
DisplayTxInputOutput(output);
}
if (transaction.Fees != null)
{
DisplayTxInputOutput(transaction.Fees);
}
}
public override async Task <Success> SubmitAirDropTransaction(SignedTransaction request, ServerCallContext context)
{
await this.InitializeWalletsAsync();
var tx = stellar_dotnet_sdk.Transaction.FromEnvelopeXdr(request.Xdr);
tx.Sign(_airDropWallet.KeyPairWithSecretSeed, _airDropWallet.NetworkInfo);
var xdr = tx.ToEnvelopeXdrBase64();
Console.WriteLine(xdr);
Console.WriteLine();
Console.WriteLine();
var response = await _airDropWallet.Server.SubmitTransaction(tx);
if (!response.IsSuccess())
{
Console.WriteLine($"Failure Message: {response.ResultXdr}");
}
return(new Success()
{
Success_ = response.IsSuccess()
});
}
public void CheckVerificationMalformedSignature()
{
var randomKey = KeyWallet.Create();
var from = wallet.GetAddress();
var to = new Address("hx5bfdb090f43a808005ffc27c25b213145e80b7cd");
var transaction = TransactionBuilder.CreateBuilder()
.Nid(NetworkId.Main)
.From(from)
.To(to)
.Value(BigInteger.Parse("0de0b6b3a7640000", NumberStyles.AllowHexSpecifier))
.StepLimit(BigInteger.Parse("12345", NumberStyles.AllowHexSpecifier))
.Timestamp(BigInteger.Parse("563a6cf330136", NumberStyles.AllowHexSpecifier))
.Nonce(BigInteger.Parse("1"))
.Build();
var signedTransaction = new SignedTransaction(transaction, wallet);
var transactionProps = signedTransaction.GetTransactionProperties();
var allProps = signedTransaction.GetProperties();
var hash = SignedTransaction.GetTransactionHash(transactionProps);
var signature = Base64.Decode(allProps.GetItem("signature").ToString());
signature[64] = 212;
var result = EcdsaSignature.VerifySignature(randomKey.GetAddress(), signature, hash);
Assert.False(result);
}