public async Task GetNetworkType()
{
var expected = "mijinTest";
var a = await new NetworkHttp(host).GetNetworkType();
Assert.AreEqual(NetworkType.GetNetwork(expected), a);
}
public object Create(string network)
{
var acc = Account.GenerateNewAccount(NetworkType.GetNetwork(network));
return(new
{
acc.PrivateKey,
acc.Address
});
}
public async Task OnExecute()
{
var httpClient = new HttpClient();
httpClient.DefaultRequestHeaders.Add("ApiKey", Key);
var acc = Account.GenerateNewAccount(NetworkType.GetNetwork(Network ?? "mainnet"));
var requestBody = JsonConvert.SerializeObject
(
new
{
acc.PrivateKey,
PublicAddress = acc.Address.Plain
}
);
var response = await httpClient.PostAsync($"{Url.TrimEnd('/')}/api/NEM/wallets/import", new StringContent(requestBody, Encoding.UTF8, "application/json"));
response.EnsureSuccessStatusCode();
Console.WriteLine($"Imported NEM {Network} address: {acc.Address.Plain}");
}
/// <summary>
/// Generates the bytes.
/// </summary>
/// <returns>The transaction bytes.</returns>
internal override byte[] GenerateBytes()
{
var builder = new FlatBufferBuilder(1);
var signer = TransferTransactionBuffer.CreatePublicKeyVector(builder, GetSigner());
var recipientVector = TransferTransactionBuffer.CreateRecipientVector(builder, Encoding.UTF8.GetBytes(Address.Plain));
if (Message == null)
{
Message = EmptyMessage.Create();
}
var messageBytePayload = Message.GetPayload();
var payload = MessageBuffer.CreatePayloadVector(builder, messageBytePayload);
var messageBuff = new Offset <MessageBuffer> [1];
MessageBuffer.StartMessageBuffer(builder);
if (messageBytePayload.Length > 0)
{
MessageBuffer.AddType(builder, Message.GetMessageType().GetValue());
}
if (messageBytePayload.Length > 0)
{
MessageBuffer.AddPayloadLen(builder, messageBytePayload.Length);
}
if (messageBytePayload.Length > 0)
{
MessageBuffer.AddPayload(builder, payload);
}
messageBuff[0] = MessageBuffer.EndMessageBuffer(builder);
var messageVector = TransferTransactionBuffer.CreateMessageVector(builder, messageBuff);
var mosaics = new Offset <MosaicBuffer> [Mosaics.Count];
for (var index = 0; index < Mosaics.Count; index++)
{
var mosaic = Mosaics[index];
var namespaceVector = MosaicBuffer.CreateNamespaceStringVector(builder, Encoding.UTF8.GetBytes(mosaic.NamespaceName));
var mosaicNameVector = MosaicBuffer.CreateMosaicIdStringVector(builder, Encoding.UTF8.GetBytes(mosaic.MosaicName));
MosaicBuffer.StartMosaicBuffer(builder);
var nsLen = Encoding.Default.GetBytes(mosaic.NamespaceName).Length;
var msLen = Encoding.Default.GetBytes(mosaic.MosaicName).Length;
MosaicBuffer.AddMosaicStructureLen(builder, 20 + nsLen + msLen);
MosaicBuffer.AddMosaicIdStructureLen(builder, nsLen + msLen + 8);
MosaicBuffer.AddNamespaceIdLen(builder, nsLen);
MosaicBuffer.AddNamespaceString(builder, namespaceVector);
MosaicBuffer.AddMosaicIdLen(builder, msLen);
MosaicBuffer.AddMosaicIdString(builder, mosaicNameVector);
MosaicBuffer.AddQuantity(builder, mosaic.Amount);
mosaics[index] = MosaicBuffer.EndMosaicBuffer(builder);
}
var mosaicsVector = TransferTransactionBuffer.CreateMosaicsVector(builder, mosaics);
TransferTransactionBuffer.StartTransferTransactionBuffer(builder);
TransferTransactionBuffer.AddTransactionType(builder, TransactionType.GetValue());
TransferTransactionBuffer.AddVersion(builder, BitConverter.ToInt16(new byte[] { ExtractVersion(Version), 0 }, 0));
TransferTransactionBuffer.AddNetwork(builder, BitConverter.ToInt16(new byte[] { 0, NetworkType.GetNetwork() }, 0));
TransferTransactionBuffer.AddTimestamp(builder, NetworkTime.EpochTimeInMilliSeconds());
TransferTransactionBuffer.AddPublicKeyLen(builder, 32);
TransferTransactionBuffer.AddPublicKey(builder, signer);
TransferTransactionBuffer.AddFee(builder, Fee);
TransferTransactionBuffer.AddDeadline(builder, Deadline.Ticks);
TransferTransactionBuffer.AddRecipientLen(builder, 40);
TransferTransactionBuffer.AddRecipient(builder, recipientVector);
TransferTransactionBuffer.AddAmount(builder, 1000000);
TransferTransactionBuffer.AddMessageFieldLen(builder, Message.GetLength() == 0 ? 0 : Message.GetLength() + 8);
TransferTransactionBuffer.AddMessage(builder, messageVector);
TransferTransactionBuffer.AddNoOfMosaics(builder, Mosaics.Count);
TransferTransactionBuffer.AddMosaics(builder, mosaicsVector);
var codedTransfer = TransferTransactionBuffer.EndTransferTransactionBuffer(builder);
builder.Finish(codedTransfer.Value);
return(new TransferTransactionSchema().Serialize(builder.SizedByteArray()));
}
internal override byte[] GenerateBytes()
{
var builder = new FlatBufferBuilder(1);
var signer = MosaicDefinitionTransactionBuffer.CreatePublicKeyVector(builder, GetSigner());
var creatorVector = MosaicDefinitionTransactionBuffer.CreateCreatorPublicKeyVector(builder, Creator.PublicKey.FromHex());
var descriptionVector = MosaicDefinitionTransactionBuffer.CreateDescriptionStringVector(builder, Encoding.UTF8.GetBytes(Description));
var nammespaceVector = MosaicDefinitionTransactionBuffer.CreateNamespaceIdStringVector(builder, Encoding.UTF8.GetBytes(Mosaic.NamespaceId));
var mosaicNameVector = MosaicDefinitionTransactionBuffer.CreateMosaicNameStringVector(builder, Encoding.UTF8.GetBytes(Mosaic.Name));
var feeSinkVector = MosaicDefinitionTransactionBuffer.CreateFeeSinkAddressVector(builder, Encoding.UTF8.GetBytes(new Address("53e140b5947f104cabc2d6fe8baedbc30ef9a0609c717d9613de593ec2a266d3", NetworkType).Plain));
var definitionStructureLength = 60 + Encoding.UTF8.GetBytes(Mosaic.NamespaceId).Length + Encoding.UTF8.GetBytes(Mosaic.Name).Length + Encoding.UTF8.GetBytes(Description).Length;
var propertiesOffset = new Offset <MosaicPropertyBuffer> [4];
foreach (var property in Properties.Properties)
{
var name = Encoding.Default.GetBytes(property.Item1);
var value = Encoding.Default.GetBytes(property.Item2.ToLower());
definitionStructureLength += 12 + name.Length + value.Length;
var nameVector = MosaicPropertyBuffer.CreatePropertyNameVector(builder, name);
var valueVector = MosaicPropertyBuffer.CreatePropertyValueVector(builder, value);
MosaicPropertyBuffer.StartMosaicPropertyBuffer(builder);
MosaicPropertyBuffer.AddLengthOfPropertyStructure(builder, 8 + name.Length + value.Length);
MosaicPropertyBuffer.AddLengthOfPropertyName(builder, name.Length);
MosaicPropertyBuffer.AddPropertyName(builder, nameVector);
MosaicPropertyBuffer.AddLengthOfPropertyValue(builder, value.Length);
MosaicPropertyBuffer.AddPropertyValue(builder, valueVector);
propertiesOffset[Properties.Properties.IndexOf(property)] = MosaicPropertyBuffer.EndMosaicPropertyBuffer(builder);
}
var mosaicPropertyVector = MosaicDefinitionTransactionBuffer.CreatePropertiesVector(builder, propertiesOffset);
var levyVector = new Offset <MosaicLevyBuffer> [1];
if (MosaicLevy != null)
{
var mosaicName = Encoding.UTF8.GetBytes(MosaicLevy.Name);
var namespaceName = Encoding.UTF8.GetBytes(MosaicLevy.NamespaceId);
var recipient = Encoding.UTF8.GetBytes(MosaicLevy.Recipient.Plain);
definitionStructureLength += 68 + namespaceName.Length + mosaicName.Length;
var mosaicLevyNameVector = MosaicLevyBuffer.CreateMosaicNameStringVector(builder, mosaicName);
var namespaceLevyNameVector = MosaicLevyBuffer.CreateNamespaceIdStringVector(builder, namespaceName);
var recipientVector = MosaicLevyBuffer.CreateRecipientAddressVector(builder, recipient);
MosaicLevyBuffer.StartMosaicLevyBuffer(builder);
MosaicLevyBuffer.AddLengthOfLevyStructure(builder, 68 + namespaceName.Length + mosaicName.Length);
MosaicLevyBuffer.AddFeeType(builder, MosaicLevy.FeeType);
MosaicLevyBuffer.AddLengthOfRecipientAddress(builder, 40);
MosaicLevyBuffer.AddRecipientAddress(builder, recipientVector);
MosaicLevyBuffer.AddLengthOfMosaicIdStructure(builder, 8 + namespaceName.Length + mosaicName.Length);
MosaicLevyBuffer.AddLengthOfMosaicNamespaceId(builder, namespaceName.Length);
MosaicLevyBuffer.AddNamespaceIdString(builder, namespaceLevyNameVector);
MosaicLevyBuffer.AddLengthMosaicNameString(builder, mosaicName.Length);
MosaicLevyBuffer.AddMosaicNameString(builder, mosaicLevyNameVector);
MosaicLevyBuffer.AddFeeQuantity(builder, MosaicLevy.Fee);
levyVector[0] = MosaicLevyBuffer.EndMosaicLevyBuffer(builder);
}
else
{
MosaicLevyBuffer.StartMosaicLevyBuffer(builder);
MosaicLevyBuffer.AddLengthOfLevyStructure(builder, 0);
levyVector[0] = MosaicLevyBuffer.EndMosaicLevyBuffer(builder);
}
var levyVectorOffset = MosaicDefinitionTransactionBuffer.CreateMosaicLevyVector(builder, levyVector);
MosaicDefinitionTransactionBuffer.StartMosaicDefinitionTransactionBuffer(builder);
var namespaceBytes = Encoding.UTF8.GetBytes(Mosaic.NamespaceId);
var mosaicNameBytes = Encoding.UTF8.GetBytes(Mosaic.Name);
var descriptionBytes = Encoding.UTF8.GetBytes(Description);
MosaicDefinitionTransactionBuffer.AddTransactionType(builder, TransactionType.GetValue());
MosaicDefinitionTransactionBuffer.AddVersion(builder, BitConverter.ToInt16(new byte[] { ExtractVersion(Version), 0 }, 0));
MosaicDefinitionTransactionBuffer.AddNetwork(builder, BitConverter.ToInt16(new byte[] { 0, NetworkType.GetNetwork() }, 0));
MosaicDefinitionTransactionBuffer.AddTimestamp(builder, NetworkTime.EpochTimeInMilliSeconds());
MosaicDefinitionTransactionBuffer.AddPublicKeyLen(builder, 32);
MosaicDefinitionTransactionBuffer.AddPublicKey(builder, signer);
MosaicDefinitionTransactionBuffer.AddFee(builder, Fee);
MosaicDefinitionTransactionBuffer.AddDeadline(builder, Deadline.TimeStamp);
MosaicDefinitionTransactionBuffer.AddMosaicDefinitionStructureLength(builder, definitionStructureLength);
MosaicDefinitionTransactionBuffer.AddLengthCreatorPublicKey(builder, 32);
MosaicDefinitionTransactionBuffer.AddCreatorPublicKey(builder, creatorVector);
MosaicDefinitionTransactionBuffer.AddLengthOfMosaicIdStructure(builder, 8 + namespaceBytes.Length + mosaicNameBytes.Length);
MosaicDefinitionTransactionBuffer.AddLengthOfNamespaceIdString(builder, namespaceBytes.Length);
MosaicDefinitionTransactionBuffer.AddNamespaceIdString(builder, nammespaceVector);
MosaicDefinitionTransactionBuffer.AddLengthOfMosaicNameString(builder, mosaicNameBytes.Length);
MosaicDefinitionTransactionBuffer.AddMosaicNameString(builder, mosaicNameVector);
MosaicDefinitionTransactionBuffer.AddLengthOfDescription(builder, descriptionBytes.Length);
MosaicDefinitionTransactionBuffer.AddDescriptionString(builder, descriptionVector);
MosaicDefinitionTransactionBuffer.AddNoOfProperties(builder, 4);
MosaicDefinitionTransactionBuffer.AddProperties(builder, mosaicPropertyVector);
MosaicDefinitionTransactionBuffer.AddMosaicLevy(builder, levyVectorOffset);
MosaicDefinitionTransactionBuffer.AddLenFeeSinkAddress(builder, 40);
MosaicDefinitionTransactionBuffer.AddFeeSinkAddress(builder, feeSinkVector);
MosaicDefinitionTransactionBuffer.AddFeeQuantity(builder, 10000000);
var transction = MosaicDefinitionTransactionBuffer.EndMosaicDefinitionTransactionBuffer(builder);
builder.Finish(transction.Value);
var temp = new MosaicDefinitionTransactionSchema().Serialize(builder.SizedByteArray());
return(MosaicLevy == null?temp.Take(temp.Length - 61).Concat(temp.Skip(temp.Length - 52)).ToArray() : temp); // hackery to remove default flatbuffers values when no levy is included.
}
internal override byte[] GenerateBytes()
{
var builder = new FlatBufferBuilder(1);
var mosaicName = Encoding.UTF8.GetBytes(MosaicId.Name);
var namespaceName = Encoding.UTF8.GetBytes(MosaicId.NamespaceId.Name);
var signerVector = SupplyChangeBuffer.CreatePublicKeyVector(builder, GetSigner());
var namespaceVector = SupplyChangeBuffer.CreateNamespaceIdstringVector(builder, namespaceName);
var mosaicNameVector = SupplyChangeBuffer.CreateMosaicNameStringVector(builder, mosaicName);
SupplyChangeBuffer.StartSupplyChangeBuffer(builder);
SupplyChangeBuffer.AddTransactionType(builder, TransactionType.GetValue());
SupplyChangeBuffer.AddVersion(builder, BitConverter.ToInt16(new byte[] { ExtractVersion(Version), 0 }, 0));
SupplyChangeBuffer.AddNetwork(builder, BitConverter.ToInt16(new byte[] { 0, NetworkType.GetNetwork() }, 0));
SupplyChangeBuffer.AddTimestamp(builder, NetworkTime.EpochTimeInMilliSeconds());
SupplyChangeBuffer.AddPublicKeyLen(builder, 32);
SupplyChangeBuffer.AddPublicKey(builder, signerVector);
SupplyChangeBuffer.AddFee(builder, Fee);
SupplyChangeBuffer.AddDeadline(builder, Deadline.Ticks);
SupplyChangeBuffer.AddLengthOfMosaicIdStructure(builder, 8 + namespaceName.Length + mosaicName.Length);
SupplyChangeBuffer.AddLengthOfNamespaceIdString(builder, namespaceName.Length);
SupplyChangeBuffer.AddNamespaceIdstring(builder, namespaceVector);
SupplyChangeBuffer.AddLengthOfMosaicNameString(builder, mosaicName.Length);
SupplyChangeBuffer.AddMosaicNameString(builder, mosaicNameVector);
SupplyChangeBuffer.AddSupplyType(builder, SupplyType);
SupplyChangeBuffer.AddDelta(builder, Delta);
var codedTransfer = ImportanceTransferBuffer.EndImportanceTransferBuffer(builder);
builder.Finish(codedTransfer.Value);
return(new SupplyChangeTransactionSchema().Serialize(builder.SizedByteArray()));
}
internal override byte[] GenerateBytes()
{
var builder = new FlatBufferBuilder(1);
var signer = ProvisionNamespaceTransactionBuffer.CreatePublicKeyVector(builder, GetSigner());
var sink = ProvisionNamespaceTransactionBuffer.CreateSinkAddressStringVector(builder, GetFeeSinkAddress());
var newPart = ProvisionNamespaceTransactionBuffer.CreateNewPartStringVector(builder, Encoding.UTF8.GetBytes(NewPart));
var parent = new VectorOffset();
if (Parent != null)
{
parent = ProvisionNamespaceTransactionBuffer.CreateParentStringVector(builder, Encoding.UTF8.GetBytes(Parent));
}
ProvisionNamespaceTransactionBuffer.StartProvisionNamespaceTransaction(builder);
ProvisionNamespaceTransactionBuffer.AddTransactionType(builder, TransactionType.GetValue());
ProvisionNamespaceTransactionBuffer.AddVersion(builder, BitConverter.ToInt16(new byte[] { ExtractVersion(Version), 0 }, 0));
ProvisionNamespaceTransactionBuffer.AddNetwork(builder, BitConverter.ToInt16(new byte[] { 0, NetworkType.GetNetwork() }, 0));
ProvisionNamespaceTransactionBuffer.AddTimestamp(builder, NetworkTime.EpochTimeInMilliSeconds());
ProvisionNamespaceTransactionBuffer.AddPublicKeyLen(builder, 32);
ProvisionNamespaceTransactionBuffer.AddPublicKey(builder, signer);
ProvisionNamespaceTransactionBuffer.AddFee(builder, Fee);
ProvisionNamespaceTransactionBuffer.AddDeadline(builder, Deadline.Ticks);
ProvisionNamespaceTransactionBuffer.AddSinkAddressLength(builder, 40);
ProvisionNamespaceTransactionBuffer.AddSinkAddressString(builder, sink);
ProvisionNamespaceTransactionBuffer.AddRentalFee(builder, Parent == null ? 0x5F5E100 : 0x989680);
ProvisionNamespaceTransactionBuffer.AddNewPartLength(builder, Encoding.UTF8.GetBytes(NewPart).Length);
ProvisionNamespaceTransactionBuffer.AddNewPartString(builder, newPart);
ProvisionNamespaceTransactionBuffer.AddParentLength(builder, Parent == null ? 4294967295 : (uint)Encoding.UTF8.GetBytes(Parent).Length); // 14
if (Parent != null)
{
ProvisionNamespaceTransactionBuffer.AddParentString(builder, parent);
}
var codedTransfer = ProvisionNamespaceTransactionBuffer.EndProvisionNamespaceTransaction(builder);
builder.Finish(codedTransfer.Value);
var tempBytes = new ProvisionNamespaceSchema().Serialize(builder.SizedByteArray());
return(Parent == null?tempBytes.Take(tempBytes.Length - 1).ToArray() : tempBytes);
}
internal override byte[] GenerateBytes()
{
var innerTransactionBytes = InnerTransaction.GenerateBytes();
var builder = new FlatBufferBuilder(1);
var signer = MultisigTransactionBuffer.CreatePublicKeyVector(builder, GetSigner());
var innerTransaction = MultisigTransactionBuffer.CreateInnerTransactionBytesVector(builder, innerTransactionBytes);
MultisigTransactionBuffer.StartMultisigTransactionBuffer(builder);
MultisigTransactionBuffer.AddTransactionType(builder, TransactionType.GetValue());
MultisigTransactionBuffer.AddVersion(builder, BitConverter.ToInt16(new byte[] { ExtractVersion(Version), 0 }, 0));
MultisigTransactionBuffer.AddNetwork(builder, BitConverter.ToInt16(new byte[] { 0, NetworkType.GetNetwork() }, 0));
MultisigTransactionBuffer.AddTimestamp(builder, NetworkTime.EpochTimeInMilliSeconds());
MultisigTransactionBuffer.AddPublicKeyLen(builder, 32);
MultisigTransactionBuffer.AddPublicKey(builder, signer);
MultisigTransactionBuffer.AddFee(builder, Fee);
MultisigTransactionBuffer.AddDeadline(builder, Deadline.Ticks);
MultisigTransactionBuffer.AddInnerTransactionLength(builder, innerTransactionBytes.Length);
MultisigTransactionBuffer.AddInnerTransactionBytes(builder, innerTransaction);
var codedTransfer = MultisigTransactionBuffer.EndMultisigTransactionBuffer(builder);
builder.Finish(codedTransfer.Value);
return(new MultisigTransactionSchema().Serialize(builder.SizedByteArray()));
}
internal override byte[] GenerateBytes()
{
var builder = new FlatBufferBuilder(1);
var signer = SignatureTransactionBuffer.CreatePublicKeyVector(builder, GetSigner());
var hash = SignatureTransactionBuffer.CreateHashVector(builder, OtherHash.FromHex());
var address = SignatureTransactionBuffer.CreateMultisigAddressVector(builder, Encoding.UTF8.GetBytes(MultisigAddress.Plain));
SignatureTransactionBuffer.StartSignatureTransactionBuffer(builder);
SignatureTransactionBuffer.AddTransactionType(builder, TransactionType.GetValue());
SignatureTransactionBuffer.AddVersion(builder, BitConverter.ToInt16(new byte[] { ExtractVersion(Version), 0 }, 0));
SignatureTransactionBuffer.AddNetwork(builder, BitConverter.ToInt16(new byte[] { 0, NetworkType.GetNetwork() }, 0));
SignatureTransactionBuffer.AddTimestamp(builder, NetworkTime.EpochTimeInMilliSeconds());
SignatureTransactionBuffer.AddPublicKeyLen(builder, 32);
SignatureTransactionBuffer.AddPublicKey(builder, signer);
SignatureTransactionBuffer.AddFee(builder, Fee);
SignatureTransactionBuffer.AddDeadline(builder, Deadline.Ticks);
SignatureTransactionBuffer.AddHashObjLength(builder, 0x24);
SignatureTransactionBuffer.AddSha3HashLength(builder, 0x20);
SignatureTransactionBuffer.AddHash(builder, hash);
SignatureTransactionBuffer.AddAddressLength(builder, 0x28);
SignatureTransactionBuffer.AddMultisigAddress(builder, address);
var result = SignatureTransactionBuffer.EndSignatureTransactionBuffer(builder);
builder.Finish(result.Value);
return(new SignatureTransactionSchema().Serialize(builder.SizedByteArray()));
}
internal override byte[] GenerateBytes()
{
var builder = new FlatBufferBuilder(1);
var signer = ImportanceTransferBuffer.CreatePublicKeyVector(builder, GetSigner());
var remote = ImportanceTransferBuffer.CreateRemotePublicKeyVector(builder, RemoteAccount.PublicKey.FromHex());
ImportanceTransferBuffer.StartImportanceTransferBuffer(builder);
ImportanceTransferBuffer.AddTransactionType(builder, TransactionType.GetValue());
ImportanceTransferBuffer.AddVersion(builder, BitConverter.ToInt16(new byte[] { ExtractVersion(Version), 0 }, 0));
ImportanceTransferBuffer.AddNetwork(builder, BitConverter.ToInt16(new byte[] { 0, NetworkType.GetNetwork() }, 0));
ImportanceTransferBuffer.AddTimestamp(builder, NetworkTime.EpochTimeInMilliSeconds());
ImportanceTransferBuffer.AddPublicKeyLen(builder, 32);
ImportanceTransferBuffer.AddPublicKey(builder, signer);
ImportanceTransferBuffer.AddFee(builder, Fee);
ImportanceTransferBuffer.AddDeadline(builder, Deadline.TimeStamp);
ImportanceTransferBuffer.AddMode(builder, Mode.GetValue());
ImportanceTransferBuffer.AddRemotePublicKeyLen(builder, 32);
ImportanceTransferBuffer.AddRemotePublicKey(builder, remote);
var codedTransfer = ImportanceTransferBuffer.EndImportanceTransferBuffer(builder);
builder.Finish(codedTransfer.Value);
return(new ImportanceTransferSchema().Serialize(builder.SizedByteArray()));
}
internal override byte[] GenerateBytes()
{
var builder = new FlatBufferBuilder(1);
var signer = MultisigAggregateModificationBuffer.CreatePublicKeyVector(builder, GetSigner());
var mods = new Offset <ModificationBuffer> [Modifications.Count];
for (var index = 0; index < Modifications.Count; index++)
{
var cosig = ModificationBuffer.CreateCosignatoryPublicKeyVector(builder, Modifications[index].CosignatoryPublicKey.PublicKey.FromHex());
ModificationBuffer.StartModificationBuffer(builder);
ModificationBuffer.AddStructureLength(builder, 0x28);
ModificationBuffer.AddModificationType(builder, Modifications[index].ModificationType.GetValue());
ModificationBuffer.AddCosignatoryPublicKeyLen(builder, 32);
ModificationBuffer.AddCosignatoryPublicKey(builder, cosig);
mods[index] = ModificationBuffer.EndModificationBuffer(builder);
}
var modificationsVector = MultisigAggregateModificationBuffer.CreateModificationsVector(builder, mods);
MultisigAggregateModificationBuffer.StartMultisigAggregateModificationBuffer(builder);
MultisigAggregateModificationBuffer.AddTransactionType(builder, TransactionType.GetValue());
MultisigAggregateModificationBuffer.AddVersion(builder, BitConverter.ToInt16(new byte[] { ExtractVersion(Version), 0 }, 0));
MultisigAggregateModificationBuffer.AddNetwork(builder, BitConverter.ToInt16(new byte[] { 0, NetworkType.GetNetwork() }, 0));
MultisigAggregateModificationBuffer.AddTimestamp(builder, NetworkTime.EpochTimeInMilliSeconds());
MultisigAggregateModificationBuffer.AddPublicKeyLen(builder, 32);
MultisigAggregateModificationBuffer.AddPublicKey(builder, signer);
MultisigAggregateModificationBuffer.AddFee(builder, Fee);
MultisigAggregateModificationBuffer.AddDeadline(builder, Deadline.Ticks);
MultisigAggregateModificationBuffer.AddNumerOfModifications(builder, Modifications.Count);
MultisigAggregateModificationBuffer.AddModifications(builder, modificationsVector);
MultisigAggregateModificationBuffer.AddMinimumCosignatoriesLength(builder, RelativeChange == 0 ? 0 : 0x04);
if (RelativeChange > 0)
{
MultisigAggregateModificationBuffer.AddRelativeChange(builder, RelativeChange);
}
var codedTransfer = MultisigAggregateModificationBuffer.EndMultisigAggregateModificationBuffer(builder);
builder.Finish(codedTransfer.Value);
var bytes = new MultisigAggregateModificationSchema().Serialize(builder.SizedByteArray());
return(RelativeChange > 0 ? bytes : bytes.Take(0, bytes.Length - 1)); // flatbuffers is appending 0x00 to the stream as a default value due to the missing relative change when its not included in the transaction so im just cutting off the 0x00 as a short term fix. will fix sometime this decade.
}
/// <summary>
/// Get current network type.
/// </summary>
/// <returns>an IObservable of NetworkTypeDTO</returns>
public IObservable <NetworkType.Types> GetNetworkType()
{
return(Observable.FromAsync(async ar => await NetworkRoutesApi.GetNetworkTypeAsync()).Select(e => NetworkType.GetNetwork(e.Name)));
}
