internal MultiSigTransaction(Connectivity.Connection connection, PublicKey publicKey, int deadline, int length)
{
if (null == connection)
{
throw new ArgumentNullException(nameof(connection));
}
if (null == publicKey)
{
throw new ArgumentNullException(nameof(publicKey));
}
InnerLength = length;
Serializer = new Serializer();
NetworkVersion = connection.GetNetworkVersion();
TimeStamp = TimeDateUtils.EpochTimeInMilliSeconds();
Deadline = deadline == 0 ? TimeStamp + 1000 : TimeStamp + deadline;
PublicKey = publicKey;
Fee = TransactionFee.MultisigWrapper;
Serialize();
MultiSigBytes = ByteUtils.TruncateByteArray(Serializer.GetBytes(), StructureLength.MultiSigHeader);
MultiSigBytes[7] = NetworkVersion;
}
internal CreateMosaic(Connectivity.Connection connection, PublicKey signer, MosaicDefinition data) : base(connection, data.Model.MultisigAccount ?? signer, data.Model.Deadline)
{
// set connection
Con = connection;
// set signer of the transaction
Signer = signer;
// set mosaic definition data
MosaicDefinition = data;
// set the mosaic levy (sometimes null)
Levy = data.Model.MosaicLevy;
// serialize the data
Serialize();
// truncate bytes
Bytes = ByteUtils.TruncateByteArray(_serializer.GetBytes(), Length);
// update fee, transaction type, transaction version and concatonate all the parts of the transaction data bytes
finalize();
// add multisig headers if transaction is multisig and concatonate bytes
AppendMultisig();
}
internal MultisigSignature(Connectivity.Connection connection, PublicKey senderPublicKey,
MultisigSignatureTransactionData data)
: base(connection, senderPublicKey, data.Deadline)
{
Data = data;
Serialize();
finalize();
}
internal Transaction(Connectivity.Connection connection, PublicKey publicKey, int deadline)
{
Serializer = new Serializer();
NetworkVersion = connection.GetNetworkVersion();
TimeStamp = TimeDateUtils.EpochTimeInSeconds();
Deadline = RoundUp(deadline == 0 ? TimeStamp + 3600 : TimeStamp + deadline);
PublicKey = publicKey;
Serialize();
}
private void AppendMultisig(Connectivity.Connection con, ImportanceTransferData data)
{
if (data.MultisigAccount == null)
{
return;
}
var multisig = new MultiSigTransaction(con, data.DelegatedAccount, data.Deadline, ImportanceBytes.Length);
ImportanceBytes = ByteUtils.ConcatonatetBytes(multisig.GetBytes(), ImportanceBytes);
}
private void AppendMultisig(Connectivity.Connection con)
{
if (Data.MultisigAccount == null)
{
return;
}
var multisig = new MultiSigTransaction(con, PublicKey, Data.Deadline, Length);
SupplyChangeBytes = ByteUtils.ConcatonatetBytes(multisig.GetBytes(), SupplyChangeBytes);
}
internal MosaicList(List <Mosaic> mosaicList, Connectivity.Connection connection, PublicKey sender)
{
Sender = sender;
Connection = connection;
Serializer = new Serializer();
ListOfMosaics = mosaicList;
Serialize();
Bytes = ByteUtils.TruncateByteArray(Serializer.GetBytes(), Length);
CalculateMosaicTransferFee();
}
internal TransferTransaction(Connectivity.Connection connection, PublicKey senderPublicKey, PrivateKey senderPrivateKey,
TransferTransactionData transactionData)
: base(connection, transactionData.MultisigAccountKey ?? senderPublicKey, transactionData.Deadline)
{
SenderPublicKey = senderPublicKey;
SenderPrivateKey = senderPrivateKey;
Data = transactionData;
Con = connection;
Recipient = Data.RecipientAddress;
SerializeTransferPart();
finalize();
AppendMultisig();
}
internal AggregateModificatioList(Connectivity.Connection connection, PublicKey sender, AggregateModificationData data)
: base(connection, data.MultisigAccount ?? sender, data.Deadline) // todo : fee
{
Data = data;
PublicKey = sender;
Serializer = new Serializer();
Serialize();
SetFee();
UpdateTransactionTypeAndVersion();
CombineBytes();
AppendMultisig(connection);
}
internal SupplyChange(Connectivity.Connection con, PublicKey sender, MosaicSupplyChangeData data)
: base(con, data.MultisigAccount ?? sender, data.Deadline)
{
PublicKey = sender;
Data = data;
NameSpaceId = Encoding.Default.GetBytes(data.NameSpaceId);
MosaicName = Encoding.Default.GetBytes(data.MosaicName);
Length = 24 + NameSpaceId.Length + MosaicName.Length;
Serialize();
Bytes = ByteUtils.TruncateByteArray(_serializer.GetBytes(), Length);
finalize();
AppendMultisig(con);
}
internal ImportanceTransfer(Connectivity.Connection con, PublicKey sender, ImportanceTransferData data) : base(con, data.MultisigAccount ?? sender, data.Deadline)
{
if (!StringUtils.OnlyHexInString(data.DelegatedAccount.Raw) || data.DelegatedAccount.Raw.Length != 64)
{
throw new ArgumentNullException(nameof(con));
}
TransferMode = data.Activate ? DefaultBytes.Activate : DefaultBytes.Deactivate;
Serialize(data.DelegatedAccount);
TransferBytes = ByteUtils.TruncateByteArray(Serializer.GetBytes(), StructureLength.ImportnaceTransfer);
finalize();
AppendMultisig(con, data);
}
/*
* Constructs the message object and initiates its serialization
*
* @Param: Serializer, The serializer to use during serialization
* @Param: Message, The message string. Note: if null, a zero value byte[4] is serialized instead
* @Param: Encrypted, Whether the message should be encrypted or not
*/
internal Message(Connectivity.Connection con, PrivateKey senderKey, string address, string message, bool encrypted)
{
Encrypted = encrypted;
MessageString = message;
if (MessageString != null)
{
if (Encrypted)
{
var a = new AccountClient(con).BeginGetAccountInfoFromAddress(body =>
{
if (body.Content.Account.PublicKey == null)
{
throw new Exception("recipient public key cannot be null for encryption");
}
PublicKey = body.Content.Account.PublicKey;
}, address);
a.AsyncWaitHandle.WaitOne();
if (PublicKey == null)
{
throw new ArgumentNullException("could not find recipient public key");
}
Sender = new PrivateKeyAccountClient(con, senderKey);
MessageBytes = new Ed25519BlockCipher(Sender, PublicKey).Encrypt(Encoding.UTF8.GetBytes(MessageString));
}
else
{
MessageBytes = Encoding.UTF8.GetBytes(MessageString);
}
PayloadLengthInBytes = MessageBytes.Length;
}
Serialize();
CalculateMessageFee();
}
internal ProvisionNamespace(Connectivity.Connection connection, PublicKey sender, ProvisionNameSpaceData data)
: base(connection, data.MultisigAccount ?? sender, data.Deadline)
{
SenderPublicKey = sender;
Con = connection;
Data = data;
if (Data.Parent == null)
{
Data.Parent = DefaultValues.EmptyString;
}
LengthOfNewPart = Encoding.Default.GetBytes(Data.NewPart).Length;
LengthOfParent = Encoding.Default.GetBytes(Data.Parent).Length;
Serialize();
finalize();
AppendMultisig();
}
private void AppendMultisig(Connectivity.Connection con)
{
var multisig = new MultiSigTransaction(con, PublicKey, Data.Deadline, TotalBytesLength);
ModificationBytes = ByteUtils.ConcatonatetBytes(multisig.GetBytes(), ModificationBytes);
}
/*
* Prepare the transaction for announcement
*
* @Connection The connection to use
* @ PrivateKey The private key used to sign the transaction
*/
internal Prepare(Connectivity.Connection connection, PrivateKey privateKey)
{
Connection = connection;
PrivateKey = privateKey;
}
