/// <summary>
/// Signs the aggregate transaction with cosigners.
/// </summary>
/// <param name="initiatorAccount">The initiator account.</param>
/// <param name="cosignatories">The cosignatories.</param>
/// <returns>SignedTransaction.</returns>
/// <exception cref="ArgumentNullException">
/// initiatorAccount
/// or
/// cosignatories
/// </exception>
public SignedTransaction SignTransactionWithCosigners(Account initiatorAccount, List <Account> cosignatories, string generationHash)
{
if (initiatorAccount == null)
{
throw new ArgumentNullException(nameof(initiatorAccount));
}
if (cosignatories == null)
{
throw new ArgumentNullException(nameof(cosignatories));
}
var signedTransaction = SignWith(initiatorAccount, generationHash);
var payload = signedTransaction.Payload.FromHex();
foreach (var cosignatory in cosignatories)
{
var bytes = signedTransaction.Hash.FromHex();
var signatureBytes = TransactionExtensions.SignHash(cosignatory.KeyPair, bytes);
payload = payload.Concat(cosignatory.KeyPair.PublicKey.Concat(signatureBytes)).ToArray();
Cosignatures.Add(new AggregateTransactionCosignature(signatureBytes.ToHexLower(),
new PublicAccount(cosignatory.KeyPair.PublicKey.ToHexLower(),
initiatorAccount.Address.NetworkType)));
}
payload = BitConverter.GetBytes(payload.Length).Concat(payload.Take(4, payload.Length - 4).ToArray())
.ToArray();
return(SignedTransaction.Create(payload, signedTransaction.Hash.FromHex(),
initiatorAccount.PublicKey.FromHex(), TransactionType, initiatorAccount.Address.NetworkType));
}
public CosignatureSignedTransaction SignWith(Account account)
{
if (account == null)
{
throw new ArgumentNullException(nameof(account));
}
var bytes = TransactionToCosign.TransactionInfo.Hash.FromHex();
var signatureBytes = TransactionExtensions.SignHash(account.KeyPair, bytes);
return(new CosignatureSignedTransaction(TransactionToCosign.TransactionInfo.Hash,
signatureBytes.ToHexLower(), account.PublicKey));
}
/// <summary>
/// Signs the transaction with the given <see cref="Account" />.
/// </summary>
/// <param name="account"></param>
/// <returns></returns>
public SignedTransaction SignWith(Account account, string generationHash)
{
if (account == null)
{
throw new ArgumentNullException(nameof(account));
}
var generationHashBytes = generationHash.DecodeHexString();
//Org.BouncyCastle.Utilities.Encoders.Hex.Decode(generationHash);
///var testHash = generationHash.DecodeHexString();
Bytes = GenerateBytes();
var signingBytes = new byte[Bytes.Length - 100 + 32];
Buffer.BlockCopy(generationHashBytes, 0, signingBytes, 0, 32);
Buffer.BlockCopy(Bytes, 100, signingBytes, 32, Bytes.Length - 100);
Signer = PublicAccount.CreateFromPublicKey(account.KeyPair.PublicKeyString, NetworkType);
var signature = TransactionExtensions.SignTransaction(account.KeyPair, signingBytes);
var payload = new byte[Bytes.Length];
Buffer.BlockCopy(Bytes, 0, payload, 0, 4);
Buffer.BlockCopy(signature, 0, payload, 4, signature.Length);
var rawSignerPublicKey = account.KeyPair.PublicKey;
Buffer.BlockCopy(rawSignerPublicKey, 0, payload, 64 + 4, rawSignerPublicKey.Length);
Buffer.BlockCopy(Bytes, 100, payload, 100, Bytes.Length - 100);
var hash = CreateTransactionHash(payload, generationHashBytes);
return(SignedTransaction.Create(payload, hash,
account.KeyPair.PublicKey, TransactionType, NetworkType));
}
