/// <summary> /// GenerateBytes /// </summary> /// <returns></returns> internal override byte[] GenerateBytes() { var builder = new FlatBufferBuilder(1); // track the size of the whole metadata modification var totalSize = 0; // load modifications var modificationVectors = new Offset <PropertyModificationBuffer> [Modifications.Count]; for (var i = 0; i < modificationVectors.Length; i++) { var mod = Modifications[i]; var modType = mod.Type; var valueBytes = GetValueBytesFromModification(mod); var valueVector = PropertyModificationBuffer.CreateValueVector(builder, valueBytes); // compute number of bytes: modType + value bytes var modSize = 1 + valueBytes.Length; // increase total size totalSize += modSize; PropertyModificationBuffer.StartPropertyModificationBuffer(builder); PropertyModificationBuffer.AddValue(builder, valueVector); PropertyModificationBuffer.AddModificationType(builder, modType.GetValueInByte()); modificationVectors[i] = PropertyModificationBuffer.EndPropertyModificationBuffer(builder); } // create version var version = GetTxVersionSerialization(); var signatureVector = AccountPropertiesTransactionBuffer.CreateSignatureVector(builder, new byte[64]); var signerVector = AccountPropertiesTransactionBuffer.CreateSignerVector(builder, GetSigner()); var feeVector = AccountPropertiesTransactionBuffer.CreateMaxFeeVector(builder, MaxFee?.ToUInt8Array()); var deadlineVector = AccountPropertiesTransactionBuffer.CreateDeadlineVector(builder, Deadline.Ticks.ToUInt8Array()); var modificationsVector = AccountPropertiesTransactionBuffer.CreateModificationsVector(builder, modificationVectors); // add size of the header (120) + size of prop type (1) + size of mod count (1) var fixedSize = HEADER_SIZE + +1 + 1 + totalSize; AccountPropertiesTransactionBuffer.StartAccountPropertiesTransactionBuffer(builder); AccountPropertiesTransactionBuffer.AddSize(builder, (uint)fixedSize); AccountPropertiesTransactionBuffer.AddSignature(builder, signatureVector); AccountPropertiesTransactionBuffer.AddSigner(builder, signerVector); AccountPropertiesTransactionBuffer.AddVersion(builder, (uint)version); AccountPropertiesTransactionBuffer.AddType(builder, TransactionType.GetValue()); AccountPropertiesTransactionBuffer.AddMaxFee(builder, feeVector); AccountPropertiesTransactionBuffer.AddDeadline(builder, deadlineVector); AccountPropertiesTransactionBuffer.AddPropertyType(builder, PropertyType.GetValueInByte()); AccountPropertiesTransactionBuffer.AddModificationCount(builder, (byte)Modifications.Count); AccountPropertiesTransactionBuffer.AddModifications(builder, modificationsVector); // end build var codedTransfer = AccountPropertiesTransactionBuffer.EndAccountPropertiesTransactionBuffer(builder); builder.Finish(codedTransfer.Value); var output = new ModifyAccountPropertyTransactionSchema().Serialize(builder.SizedByteArray()); if (output.Length != fixedSize) { throw new SerializationException("Serialized form has incorrect length"); } return(output); }
internal override byte[] GenerateBytes() { var builder = new FlatBufferBuilder(1); // create version var version = GetTxVersionSerialization(); var signatureVector = CatapultUpgradeTransactionBuffer.CreateSignatureVector(builder, new byte[64]); var signerVector = CatapultUpgradeTransactionBuffer.CreateSignerVector(builder, GetSigner()); var feeVector = CatapultUpgradeTransactionBuffer.CreateMaxFeeVector(builder, MaxFee?.ToUInt8Array()); var deadlineVector = CatapultUpgradeTransactionBuffer.CreateDeadlineVector(builder, Deadline.Ticks.ToUInt8Array()); var upgradePeriodVector = CatapultUpgradeTransactionBuffer.CreateUpgradePeriodVector(builder, UpgradePeriod.ToUInt8Array()); var newCatapultVersionVector = CatapultUpgradeTransactionBuffer.CreateNewCatapultVersionVector(builder, NewVersion.GetVersionValue().ToUInt8Array()); // header, 2 uint64 var totalSize = GetPayloadSerializedSize(); CatapultUpgradeTransactionBuffer.StartCatapultUpgradeTransactionBuffer(builder); CatapultUpgradeTransactionBuffer.AddSize(builder, (uint)totalSize); CatapultUpgradeTransactionBuffer.AddSignature(builder, signatureVector); CatapultUpgradeTransactionBuffer.AddSigner(builder, signerVector); CatapultUpgradeTransactionBuffer.AddVersion(builder, (uint)version); CatapultUpgradeTransactionBuffer.AddType(builder, TransactionType.GetValue()); CatapultUpgradeTransactionBuffer.AddMaxFee(builder, feeVector); CatapultUpgradeTransactionBuffer.AddDeadline(builder, deadlineVector); CatapultUpgradeTransactionBuffer.AddNewCatapultVersion(builder, newCatapultVersionVector); CatapultUpgradeTransactionBuffer.AddUpgradePeriod(builder, upgradePeriodVector); // end build var codedTransfer = CatapultUpgradeTransactionBuffer.EndCatapultUpgradeTransactionBuffer(builder); builder.Finish(codedTransfer.Value); var output = new BlockchainUpgradeTransactionSchema().Serialize(builder.SizedByteArray()); if (output.Length != totalSize) { throw new SerializationException("Serialized form has incorrect length"); } return(output); }
/// <summary> /// Generates the bytes. /// </summary> /// <returns>System.Byte[].</returns> internal override byte[] GenerateBytes() { byte flags = 0; if (Properties.IsSupplyMutable) { flags += 1; } if (Properties.IsTransferable) { flags += 2; } if (Properties.IsLevyMutable) { flags += 4; } var builder = new FlatBufferBuilder(1); IList <KeyValuePair <MosaicPropertyId, ulong> > propertyList = new List <KeyValuePair <MosaicPropertyId, ulong> >(); var duration = Properties.Duration; if (duration > 0) { propertyList.Add(new KeyValuePair <MosaicPropertyId, ulong>(MosaicPropertyId.DURATION, duration)); } var mosaicProperties = new Offset <MosaicProperty> [propertyList.Count]; for (var index = 0; index < propertyList.Count; index++) { KeyValuePair <MosaicPropertyId, ulong> mp = propertyList[index]; var valueOffset = MosaicProperty.CreateValueVector(builder, mp.Value.ToUInt8Array()); MosaicProperty.StartMosaicProperty(builder); MosaicProperty.AddMosaicPropertyId(builder, mp.Key.GetValueInByte()); MosaicProperty.AddValue(builder, valueOffset); mosaicProperties[index] = MosaicProperty.EndMosaicProperty(builder); } // create vectors var signatureVector = MosaicDefinitionTransactionBuffer.CreateSignatureVector(builder, new byte[64]); var signerVector = MosaicDefinitionTransactionBuffer.CreateSignerVector(builder, GetSigner()); var feeVector = MosaicDefinitionTransactionBuffer.CreateMaxFeeVector(builder, MaxFee?.ToUInt8Array()); var deadlineVector = MosaicDefinitionTransactionBuffer.CreateDeadlineVector(builder, Deadline.Ticks.ToUInt8Array()); var mosaicIdVector = MosaicDefinitionTransactionBuffer.CreateMosaicIdVector(builder, MosaicId.Id.ToUInt8Array()); var optionalPropertiesVector = MosaicDefinitionTransactionBuffer.CreateOptionalPropertiesVector(builder, mosaicProperties); // create version var version = (uint)GetTxVersionSerialization(); // header + nonce + id + numOptProp + flags + divisibility + (id + value)*numOptProp var totalSize = GetSerializedSize(); //HEADER_SIZE + 4 + 8 + 1 + 1 + 1 + (1 + 8) * mosaicProperties.Length; // add vectors to buffer MosaicDefinitionTransactionBuffer.StartMosaicDefinitionTransactionBuffer(builder); MosaicDefinitionTransactionBuffer.AddSize(builder, (uint)totalSize); MosaicDefinitionTransactionBuffer.AddSignature(builder, signatureVector); MosaicDefinitionTransactionBuffer.AddSigner(builder, signerVector); MosaicDefinitionTransactionBuffer.AddVersion(builder, (uint)version); MosaicDefinitionTransactionBuffer.AddType(builder, TransactionType.GetValue()); MosaicDefinitionTransactionBuffer.AddMaxFee(builder, feeVector); MosaicDefinitionTransactionBuffer.AddDeadline(builder, deadlineVector); MosaicDefinitionTransactionBuffer.AddMosaicNonce(builder, BitConverter.ToUInt32(MosaicNonce.Nonce, 0)); MosaicDefinitionTransactionBuffer.AddMosaicId(builder, mosaicIdVector); MosaicDefinitionTransactionBuffer.AddNumOptionalProperties(builder, (byte)mosaicProperties.Length); MosaicDefinitionTransactionBuffer.AddFlags(builder, flags); MosaicDefinitionTransactionBuffer.AddDivisibility(builder, (byte)Properties.Divisibility); MosaicDefinitionTransactionBuffer.AddOptionalProperties(builder, optionalPropertiesVector); // Calculate size var codedMosaicDefinition = MosaicDefinitionTransactionBuffer.EndMosaicDefinitionTransactionBuffer(builder); builder.Finish(codedMosaicDefinition.Value); // validate size var output = new MosaicDefinitionTransactionSchema().Serialize(builder.SizedByteArray()); if (output.Length != totalSize) { throw new SerializationException("Serialized form has incorrect length"); } return(output); }
internal override byte[] GenerateBytes() { var builder = new FlatBufferBuilder(1); // create version var version = GetTxVersionSerialization(); var signatureVector = MetadataTransactionBuffer.CreateSignatureVector(builder, new byte[64]); var signerVector = MetadataTransactionBuffer.CreateSignerVector(builder, GetSigner()); var feeVector = MetadataTransactionBuffer.CreateMaxFeeVector(builder, MaxFee?.ToUInt8Array()); var deadlineVector = MetadataTransactionBuffer.CreateDeadlineVector(builder, Deadline.Ticks.ToUInt8Array()); var TargetIdVector = MetadataTransactionBuffer.CreateTargetIdVector(builder, TargetId.Id.ToUInt8Array()); var targetKeyVector = MetadataTransactionBuffer.CreateTargetKeyVector(builder, TargetPublicKey.PublicKey.DecodeHexString()); var scopedMetadataKeyVector = MetadataTransactionBuffer.CreateScopedMetadataKeyVector(builder, ScopedKey.ToUInt8Array()); var valueVector = MetadataTransactionBuffer.CreateValueVector(builder, valueDifference_Bytes); // add size of stuff with constant size and size of metadata id var totalSize = GetSerializedSize(); MetadataTransactionBuffer.StartMetadataTransactionBuffer(builder); MetadataTransactionBuffer.AddSize(builder, (uint)totalSize); MetadataTransactionBuffer.AddSignature(builder, signatureVector); MetadataTransactionBuffer.AddSigner(builder, signerVector); MetadataTransactionBuffer.AddVersion(builder, (uint)version); MetadataTransactionBuffer.AddType(builder, TransactionType.GetValue()); MetadataTransactionBuffer.AddMaxFee(builder, feeVector); MetadataTransactionBuffer.AddDeadline(builder, deadlineVector); MetadataTransactionBuffer.AddTargetKey(builder, targetKeyVector); MetadataTransactionBuffer.AddScopedMetadataKey(builder, scopedMetadataKeyVector); MetadataTransactionBuffer.AddTargetId(builder, TargetIdVector); MetadataTransactionBuffer.AddValueSizeDelta(builder, ValueSizeDelta); MetadataTransactionBuffer.AddValueSize(builder, ValueSize); MetadataTransactionBuffer.AddValue(builder, valueVector); // end build var codedTransfer = MetadataTransactionBuffer.EndMetadataTransactionBuffer(builder); builder.Finish(codedTransfer.Value); var output = new MetadataTransactionSchema().Serialize(builder.SizedByteArray()); if (output.Length != totalSize) { throw new SerializationException("Serialized form has incorrect length"); } return(output); }
internal override byte[] GenerateBytes() { var builder = new FlatBufferBuilder(1); // create vectors var signatureVector = SecretProofTransactionBuffer.CreateSignatureVector(builder, new byte[64]); var signerVector = SecretProofTransactionBuffer.CreateSignerVector(builder, GetSigner()); var feeVector = SecretProofTransactionBuffer.CreateMaxFeeVector(builder, MaxFee?.ToUInt8Array()); var deadlineVector = SecretProofTransactionBuffer.CreateDeadlineVector(builder, Deadline.Ticks.ToUInt8Array()); var secretVector = SecretLockTransactionBuffer.CreateSecretVector(builder, Secret.DecodeHexString()); var proofVector = SecretProofTransactionBuffer.CreateProofVector(builder, Proof.DecodeHexString()); var version = int.Parse(NetworkType.GetValueInByte().ToString("X") + "0" + Version.ToString("X"), NumberStyles.HexNumber); var recipientVector = SecretProofTransactionBuffer.CreateRecipientVector(builder, Recipient.GetBytes()); int totalSize = GetSerializedSize(); SecretProofTransactionBuffer.StartSecretProofTransactionBuffer(builder); SecretProofTransactionBuffer.AddSize(builder, (uint)totalSize); SecretProofTransactionBuffer.AddSignature(builder, signatureVector); SecretProofTransactionBuffer.AddSigner(builder, signerVector); SecretProofTransactionBuffer.AddVersion(builder, (uint)version); SecretProofTransactionBuffer.AddType(builder, TransactionType.GetValue()); SecretProofTransactionBuffer.AddMaxFee(builder, feeVector); SecretProofTransactionBuffer.AddDeadline(builder, deadlineVector); SecretProofTransactionBuffer.AddHashAlgorithm(builder, HashType.GetValueInByte()); SecretProofTransactionBuffer.AddRecipient(builder, recipientVector); SecretProofTransactionBuffer.AddSecret(builder, secretVector); SecretProofTransactionBuffer.AddProofSize(builder, Convert.ToUInt16(Proof.DecodeHexString().Length)); SecretProofTransactionBuffer.AddProof(builder, proofVector); var codedSecretProof = SecretProofTransactionBuffer.EndSecretProofTransactionBuffer(builder); builder.Finish(codedSecretProof.Value); var output = new SecretProofTransactionSchema().Serialize(builder.SizedByteArray()); if (output.Length != totalSize) { throw new SerializationException("Serialized form has incorrect length"); } return(output); }
internal override byte[] GenerateBytes() { var builder = new FlatBufferBuilder(1); // Create modifications vector var modificationsArray = new Offset <CosignatoryModificationBuffer> [Modifications.Count]; for (var index = 0; index < Modifications.Count; ++index) { var modification = Modifications[index]; var cosignatoryPublicKeyVector = CosignatoryModificationBuffer.CreateCosignatoryPublicKeyVector(builder, modification.CosignatoryPublicAccount.PublicKey.FromHex()); CosignatoryModificationBuffer.StartCosignatoryModificationBuffer(builder); CosignatoryModificationBuffer.AddType(builder, modification.Type.GetValueInByte()); CosignatoryModificationBuffer.AddCosignatoryPublicKey(builder, cosignatoryPublicKeyVector); modificationsArray[index] = CosignatoryModificationBuffer.EndCosignatoryModificationBuffer(builder); } // create vectors var signatureVector = ModifyMultisigAccountTransactionBuffer.CreateSignatureVector(builder, new byte[64]); var signerVector = ModifyMultisigAccountTransactionBuffer.CreateSignerVector(builder, GetSigner()); var feeVector = ModifyMultisigAccountTransactionBuffer.CreateMaxFeeVector(builder, MaxFee?.ToUInt8Array()); var deadlineVector = ModifyMultisigAccountTransactionBuffer.CreateDeadlineVector(builder, Deadline.Ticks.ToUInt8Array()); var modificationVector = ModifyMultisigAccountTransactionBuffer.CreateModificationsVector(builder, modificationsArray); // create version var version = GetTxVersionSerialization(); var totalSize = GetSerializedSize(); ModifyMultisigAccountTransactionBuffer.StartModifyMultisigAccountTransactionBuffer(builder); ModifyMultisigAccountTransactionBuffer.AddSize(builder, (uint)totalSize); ModifyMultisigAccountTransactionBuffer.AddSignature(builder, signatureVector); ModifyMultisigAccountTransactionBuffer.AddSigner(builder, signerVector); ModifyMultisigAccountTransactionBuffer.AddVersion(builder, (uint)version); ModifyMultisigAccountTransactionBuffer.AddType(builder, TransactionType.GetValue()); ModifyMultisigAccountTransactionBuffer.AddMaxFee(builder, feeVector); ModifyMultisigAccountTransactionBuffer.AddDeadline(builder, deadlineVector); ModifyMultisigAccountTransactionBuffer.AddMinRemovalDelta(builder, Convert.ToSByte(MinRemovalDelta)); ModifyMultisigAccountTransactionBuffer.AddMinApprovalDelta(builder, Convert.ToSByte(MinApprovalDelta)); ModifyMultisigAccountTransactionBuffer.AddNumModifications(builder, Convert.ToByte(Modifications.Count)); ModifyMultisigAccountTransactionBuffer.AddModifications(builder, modificationVector); // end build var codedTransfer = ModifyMultisigAccountTransactionBuffer.EndModifyMultisigAccountTransactionBuffer(builder); builder.Finish(codedTransfer.Value); var output = new ModifyMultisigAccountTransactionSchema().Serialize(builder.SizedByteArray()); if (output.Length != totalSize) { throw new SerializationException("Serialized form has incorrect length"); } return(output); }
internal override byte[] GenerateBytes() { var builder = new FlatBufferBuilder(1); // create vectors var mosaicidVector = Buffers.MosaicLevy.CreateMosaicIdVector(builder, LevyInfo.Mosaic.Id.ToUInt8Array()); var levyFeeVector = Buffers.MosaicLevy.CreateFeeVector(builder, LevyInfo.Amount.ToUInt8Array()); var levyRecipentVector = Buffers.MosaicLevy.CreateRecipientVector(builder, LevyInfo.Recipent.GetBytes()); Buffers.MosaicLevy.StartMosaicLevy(builder); Buffers.MosaicLevy.AddFee(builder, levyFeeVector); Buffers.MosaicLevy.AddMosaicId(builder, mosaicidVector); Buffers.MosaicLevy.AddRecipient(builder, levyRecipentVector); Buffers.MosaicLevy.AddType(builder, LevyInfo.Levytype.GetValueInByte()); var Mosaic = Buffers.MosaicLevy.EndMosaicLevy(builder); // create vectors var signatureVector = ModifyMosaicLevyTransactionBuffer.CreateSignatureVector(builder, new byte[64]); var signerVector = ModifyMosaicLevyTransactionBuffer.CreateSignerVector(builder, GetSigner()); var feeVector = ModifyMosaicLevyTransactionBuffer.CreateMaxFeeVector(builder, MaxFee?.ToUInt8Array()); var deadlineVector = ModifyMosaicLevyTransactionBuffer.CreateDeadlineVector(builder, Deadline.Ticks.ToUInt8Array()); var mosaicIdVector = ModifyMosaicLevyTransactionBuffer.CreateMosaicIdVector(builder, MosaicId.Id.ToUInt8Array()); // add size of the transaction int totalSize = GetSerializedSize(); // create version var version = GetTxVersionSerialization(); // add vectors to buffer ModifyMosaicLevyTransactionBuffer.StartModifyMosaicLevyTransactionBuffer(builder); ModifyMosaicLevyTransactionBuffer.AddSize(builder, (uint)totalSize); ModifyMosaicLevyTransactionBuffer.AddSignature(builder, signatureVector); ModifyMosaicLevyTransactionBuffer.AddSigner(builder, signerVector); ModifyMosaicLevyTransactionBuffer.AddVersion(builder, (uint)version); ModifyMosaicLevyTransactionBuffer.AddType(builder, TransactionType.GetValue()); ModifyMosaicLevyTransactionBuffer.AddMaxFee(builder, feeVector); ModifyMosaicLevyTransactionBuffer.AddDeadline(builder, deadlineVector); ModifyMosaicLevyTransactionBuffer.AddLevy(builder, Mosaic); ModifyMosaicLevyTransactionBuffer.AddMosaicId(builder, mosaicIdVector); // Calculate size var codedTransaction = ModifyMosaicLevyTransactionBuffer.EndModifyMosaicLevyTransactionBuffer(builder); builder.Finish(codedTransaction.Value); var output = new ModifyMosaicLevyTransactionSchema().Serialize(builder.SizedByteArray()); if (output.Length != totalSize) { throw new SerializationException("Serialized form has incorrect length"); } return(output); }
/// <summary> /// Generate Bytes /// </summary> /// <returns>byte[]</returns> internal override byte[] GenerateBytes() { var builder = new FlatBufferBuilder(1); // create vectors var signatureVector = RegisterNamespaceTransactionBuffer.CreateSignatureVector(builder, new byte[64]); var signerVector = RegisterNamespaceTransactionBuffer.CreateSignerVector(builder, GetSigner()); var feeVector = TransferTransactionBuffer.CreateMaxFeeVector(builder, MaxFee?.ToUInt8Array()); var deadlineVector = RegisterNamespaceTransactionBuffer.CreateDeadlineVector(builder, Deadline.Ticks.ToUInt8Array()); var namespaceIdVector = RegisterNamespaceTransactionBuffer.CreateNamespaceIdVector(builder, NamespaceId.Id.ToUInt8Array()); var durationParentId = NamespaceType == NamespaceType.ROOT_NAMESPACE ? Duration?.ToUInt8Array() : ParentId.Id.ToUInt8Array(); var durationParentIdVector = RegisterNamespaceTransactionBuffer.CreateDurationParentIdVector(builder, durationParentId); // header, ns type, duration, ns id, name size, name int totalSize = GetSerializedSize(); // create version var version = GetTxVersionSerialization(); var name = builder.CreateString(NamespaceName); // ADD to buffer RegisterNamespaceTransactionBuffer.StartRegisterNamespaceTransactionBuffer(builder); RegisterNamespaceTransactionBuffer.AddSize(builder, (uint)totalSize); RegisterNamespaceTransactionBuffer.AddSignature(builder, signatureVector); RegisterNamespaceTransactionBuffer.AddSigner(builder, signerVector); RegisterNamespaceTransactionBuffer.AddVersion(builder, (uint)version); RegisterNamespaceTransactionBuffer.AddType(builder, TransactionType.GetValue()); RegisterNamespaceTransactionBuffer.AddMaxFee(builder, feeVector); RegisterNamespaceTransactionBuffer.AddDeadline(builder, deadlineVector); RegisterNamespaceTransactionBuffer.AddNamespaceType(builder, NamespaceType.GetValueInByte()); RegisterNamespaceTransactionBuffer.AddDurationParentId(builder, durationParentIdVector); RegisterNamespaceTransactionBuffer.AddNamespaceId(builder, namespaceIdVector); RegisterNamespaceTransactionBuffer.AddNamespaceNameSize(builder, (byte)NamespaceName.Length); RegisterNamespaceTransactionBuffer.AddNamespaceName(builder, name); // Calculate size var codedNamespace = RegisterNamespaceTransactionBuffer.EndRegisterNamespaceTransactionBuffer(builder); builder.Finish(codedNamespace.Value); var output = new RegisterNamespaceTransactionSchema().Serialize(builder.SizedByteArray()); if (output.Length != totalSize) { throw new SerializationException("Serialized form has incorrect length"); } return(output); }
internal override byte[] GenerateBytes() { var builder = new FlatBufferBuilder(1); // create offers var offerOffsets = new Offset <RemoveExchangeOfferBuffer> [Offers.Count]; for (var i = 0; i < offerOffsets.Length; i++) { var offer = Offers[i]; var mosaicIdVector = RemoveExchangeOfferBuffer.CreateMosaicIdVector(builder, offer.MosaicId.Id.ToUInt8Array()); RemoveExchangeOfferBuffer.StartRemoveExchangeOfferBuffer(builder); RemoveExchangeOfferBuffer.AddMosaicId(builder, mosaicIdVector); RemoveExchangeOfferBuffer.AddType(builder, offer.Type.GetValueInByte()); offerOffsets[i] = RemoveExchangeOfferBuffer.EndRemoveExchangeOfferBuffer(builder); } // create vectors var signatureVector = RemoveExchangeOfferTransactionBuffer.CreateSignatureVector(builder, new byte[64]); var signerVector = RemoveExchangeOfferTransactionBuffer.CreateSignerVector(builder, GetSigner()); var feeVector = RemoveExchangeOfferTransactionBuffer.CreateMaxFeeVector(builder, MaxFee?.ToUInt8Array()); var deadlineVector = RemoveExchangeOfferTransactionBuffer.CreateDeadlineVector(builder, Deadline.Ticks.ToUInt8Array()); var offersVector = RemoveExchangeOfferTransactionBuffer.CreateOffersVector(builder, offerOffsets); // add size of the transaction int totalSize = GetSerializedSize(); // create version var version = GetTxVersionSerialization(); // ADD to buffer RemoveExchangeOfferTransactionBuffer.StartRemoveExchangeOfferTransactionBuffer(builder); RemoveExchangeOfferTransactionBuffer.AddSize(builder, (uint)totalSize); RemoveExchangeOfferTransactionBuffer.AddSignature(builder, signatureVector); RemoveExchangeOfferTransactionBuffer.AddSigner(builder, signerVector); RemoveExchangeOfferTransactionBuffer.AddVersion(builder, (uint)version); RemoveExchangeOfferTransactionBuffer.AddType(builder, TransactionType.GetValue()); RemoveExchangeOfferTransactionBuffer.AddMaxFee(builder, feeVector); RemoveExchangeOfferTransactionBuffer.AddDeadline(builder, deadlineVector); RemoveExchangeOfferTransactionBuffer.AddOffersCount(builder, (byte)offerOffsets.Length); RemoveExchangeOfferTransactionBuffer.AddOffers(builder, offersVector); // Calculate size var codedTransaction = RemoveExchangeOfferTransactionBuffer.EndRemoveExchangeOfferTransactionBuffer(builder); builder.Finish(codedTransaction.Value); var output = new ExchangeOfferRemoveTransactionSchema().Serialize(builder.SizedByteArray()); if (output.Length != totalSize) { throw new SerializationException("Serialized form has incorrect length"); } return(output); }
/// <summary> /// /// </summary> /// <returns></returns> internal override byte[] GenerateBytes() { var builder = new FlatBufferBuilder(1); // create vectors var signatureVector = AccountLinkTransactionBuffer.CreateSignatureVector(builder, new byte[64]); var signerVector = AccountLinkTransactionBuffer.CreateSignerVector(builder, GetSigner()); var feeVector = AccountLinkTransactionBuffer.CreateMaxFeeVector(builder, MaxFee?.ToUInt8Array()); var deadlineVector = AccountLinkTransactionBuffer.CreateDeadlineVector(builder, Deadline.Ticks.ToUInt8Array()); var remoteAccountVector = AccountLinkTransactionBuffer.CreateRemoteAccountKeyVector(builder, RemoteAccount.PublicKey.DecodeHexString()); /*var totalSize = * // header * HEADER_SIZE + * // remote account public key * 32 + * // link action * 1;*/ var totalSize = GetSerializedSize(); // create version var version = GetTxVersionSerialization(); AccountLinkTransactionBuffer.StartAccountLinkTransactionBuffer(builder); AccountLinkTransactionBuffer.AddSize(builder, (uint)totalSize); AccountLinkTransactionBuffer.AddSignature(builder, signatureVector); AccountLinkTransactionBuffer.AddSigner(builder, signerVector); AccountLinkTransactionBuffer.AddVersion(builder, (uint)version); AccountLinkTransactionBuffer.AddType(builder, TransactionType.GetValue()); AccountLinkTransactionBuffer.AddMaxFee(builder, feeVector); AccountLinkTransactionBuffer.AddDeadline(builder, deadlineVector); AccountLinkTransactionBuffer.AddRemoteAccountKey(builder, remoteAccountVector); AccountLinkTransactionBuffer.AddLinkAction(builder, Action.GetValueInByte()); // end build var codedTransaction = AccountLinkTransactionBuffer.EndAccountLinkTransactionBuffer(builder).Value; builder.Finish(codedTransaction); var output = new AccountLinkTransactionSchema().Serialize(builder.SizedByteArray()); if (output.Length != totalSize) { throw new SerializationException("Serialized form has incorrect length"); } return(output); }
internal override byte[] GenerateBytes() { var builder = new FlatBufferBuilder(1); byte[] aliasIdBytes; if (MosaicId != null) { aliasIdBytes = BitConverter.GetBytes(MosaicId.Id); } else if (Address != null) { aliasIdBytes = Address.Plain.FromBase32String(); } else { throw new Exception("Unsupported Alias"); } // create vectors var signatureVector = AliasTransactionBuffer.CreateSignatureVector(builder, new byte[64]); var signerVector = AliasTransactionBuffer.CreateSignerVector(builder, GetSigner()); var feeVector = AliasTransactionBuffer.CreateMaxFeeVector(builder, MaxFee?.ToUInt8Array()); var deadlineVector = AliasTransactionBuffer.CreateDeadlineVector(builder, Deadline.Ticks.ToUInt8Array()); var namespaceIdVector = AliasTransactionBuffer.CreateNamespaceIdVector(builder, NamespaceId.Id.ToUInt8Array()); var aliasIdVector = AliasTransactionBuffer.CreateAliasIdVector(builder, aliasIdBytes); //var fixedSize = HEADER_SIZE + aliasIdBytes.Length + 8 + 1; // header, 2 uint64 and int int totalSize = GetSerializedSize(); // create version var version = GetTxVersionSerialization(); AliasTransactionBuffer.StartAliasTransactionBuffer(builder); AliasTransactionBuffer.AddSize(builder, (uint)totalSize); AliasTransactionBuffer.AddSignature(builder, signatureVector); AliasTransactionBuffer.AddSigner(builder, signerVector); AliasTransactionBuffer.AddVersion(builder, (uint)version); AliasTransactionBuffer.AddType(builder, TransactionType.GetValue()); AliasTransactionBuffer.AddMaxFee(builder, feeVector); AliasTransactionBuffer.AddDeadline(builder, deadlineVector); AliasTransactionBuffer.AddAliasId(builder, aliasIdVector); AliasTransactionBuffer.AddNamespaceId(builder, namespaceIdVector); AliasTransactionBuffer.AddActionType(builder, AliasActionType.GetValueInByte()); // end build var codedTransaction = AliasTransactionBuffer.EndAliasTransactionBuffer(builder).Value; builder.Finish(codedTransaction); return(new AliasTransactionSchema().Serialize(builder.SizedByteArray())); }
internal override byte[] GenerateBytes() { var builder = new FlatBufferBuilder(1); // create transaction bytes var transactionsBytes = new byte[0]; transactionsBytes = InnerTransactions.Aggregate(transactionsBytes, (current, innerTransaction) => current.Concat(innerTransaction.ToAggregate()).ToArray()); // Create Vectors var signatureVector = AggregateTransactionBuffer.CreateSignatureVector(builder, new byte[64]); var signerVector = AggregateTransactionBuffer.CreateSignerVector(builder, GetSigner()); var deadlineVector = AggregateTransactionBuffer.CreateDeadlineVector(builder, Deadline.Ticks.ToUInt8Array()); var feeVector = AggregateTransactionBuffer.CreateMaxFeeVector(builder, MaxFee?.ToUInt8Array()); var transactionsVector = AggregateTransactionBuffer.CreateTransactionsVector(builder, transactionsBytes); // total size of transaction /*var totalSize = HEADER_SIZE + 4 + transactionsBytes.Length;*/ var totalSize = GetSerializedSize(); // create version var version = GetTxVersionSerialization(); // add vectors AggregateTransactionBuffer.StartAggregateTransactionBuffer(builder); AggregateTransactionBuffer.AddSize(builder, (uint)totalSize); AggregateTransactionBuffer.AddSignature(builder, signatureVector); AggregateTransactionBuffer.AddSigner(builder, signerVector); AggregateTransactionBuffer.AddVersion(builder, (uint)version); AggregateTransactionBuffer.AddType(builder, TransactionType.GetValue()); AggregateTransactionBuffer.AddMaxFee(builder, feeVector); AggregateTransactionBuffer.AddDeadline(builder, deadlineVector); AggregateTransactionBuffer.AddTransactionsSize(builder, (uint)transactionsBytes.Length); AggregateTransactionBuffer.AddTransactions(builder, transactionsVector); // end build var codedTransaction = AggregateTransactionBuffer.EndAggregateTransactionBuffer(builder).Value; builder.Finish(codedTransaction); var output = new AggregateTransactionSchema().Serialize(builder.SizedByteArray()); if (output.Length != totalSize) { throw new SerializationException("Serialized form has incorrect length"); } return(output); }
internal override byte[] GenerateBytes() { var builder = new FlatBufferBuilder(1); var signatureVector = MosaicSupplyChangeTransactionBuffer.CreateSignatureVector(builder, new byte[64]); var signerVector = MosaicSupplyChangeTransactionBuffer.CreateSignerVector(builder, GetSigner()); var feeVector = MosaicSupplyChangeTransactionBuffer.CreateMaxFeeVector(builder, MaxFee?.ToUInt8Array()); var deadlineVector = MosaicSupplyChangeTransactionBuffer.CreateDeadlineVector(builder, Deadline.Ticks.ToUInt8Array()); var mosaicIdVector = MosaicSupplyChangeTransactionBuffer.CreateMosaicIdVector(builder, MosaicId.Id.ToUInt8Array()); var deltaVector = MosaicSupplyChangeTransactionBuffer.CreateDeltaVector(builder, Delta.ToUInt8Array()); // create version var version = GetTxVersionSerialization(); int totalSize = GetSerializedSize(); MosaicSupplyChangeTransactionBuffer.StartMosaicSupplyChangeTransactionBuffer(builder); MosaicSupplyChangeTransactionBuffer.AddSize(builder, (uint)totalSize); MosaicSupplyChangeTransactionBuffer.AddSignature(builder, signatureVector); MosaicSupplyChangeTransactionBuffer.AddSigner(builder, signerVector); MosaicSupplyChangeTransactionBuffer.AddVersion(builder, (uint)version); MosaicSupplyChangeTransactionBuffer.AddType(builder, TransactionType.GetValue()); MosaicSupplyChangeTransactionBuffer.AddMaxFee(builder, feeVector); MosaicSupplyChangeTransactionBuffer.AddDeadline(builder, deadlineVector); MosaicSupplyChangeTransactionBuffer.AddMosaicId(builder, mosaicIdVector); MosaicSupplyChangeTransactionBuffer.AddDirection(builder, MosaicSupplyType.GetValueInByte()); MosaicSupplyChangeTransactionBuffer.AddDelta(builder, deltaVector); var codedTransaction = MosaicSupplyChangeTransactionBuffer.EndMosaicSupplyChangeTransactionBuffer(builder); builder.Finish(codedTransaction.Value); var output = new MosaicSupplyChangeTransactionSchema().Serialize(builder.SizedByteArray()); if (output.Length != totalSize) { throw new SerializationException("Serialized form has incorrect length"); } return(output); }
internal override byte[] GenerateBytes() { var builder = new FlatBufferBuilder(1); // create vectors var signatureVector = LockFundsTransactionBuffer.CreateSignatureVector(builder, new byte[64]); var signerVector = LockFundsTransactionBuffer.CreateSignerVector(builder, GetSigner()); var feeVector = LockFundsTransactionBuffer.CreateMaxFeeVector(builder, MaxFee?.ToUInt8Array()); var deadlineVector = LockFundsTransactionBuffer.CreateDeadlineVector(builder, Deadline.Ticks.ToUInt8Array()); var mosaicIdVector = LockFundsTransactionBuffer.CreateMosaicIdVector(builder, Mosaic.Id.Id.ToUInt8Array()); var mosaicAmountVector = LockFundsTransactionBuffer.CreateMosaicAmountVector(builder, Mosaic.Amount.ToUInt8Array()); var durationVector = LockFundsTransactionBuffer.CreateDurationVector(builder, Duration.ToUInt8Array()); var hashVector = LockFundsTransactionBuffer.CreateHashVector(builder, Transaction.Hash.FromHex()); // create version var version = GetTxVersionSerialization(); int totalSize = GetSerializedSize(); LockFundsTransactionBuffer.StartLockFundsTransactionBuffer(builder); LockFundsTransactionBuffer.AddSize(builder, (uint)totalSize); LockFundsTransactionBuffer.AddSignature(builder, signatureVector); LockFundsTransactionBuffer.AddSigner(builder, signerVector); LockFundsTransactionBuffer.AddVersion(builder, (uint)version); LockFundsTransactionBuffer.AddType(builder, TransactionType.GetValue()); LockFundsTransactionBuffer.AddMaxFee(builder, feeVector); LockFundsTransactionBuffer.AddDeadline(builder, deadlineVector); LockFundsTransactionBuffer.AddMosaicId(builder, mosaicIdVector); LockFundsTransactionBuffer.AddMosaicAmount(builder, mosaicAmountVector); LockFundsTransactionBuffer.AddDuration(builder, durationVector); LockFundsTransactionBuffer.AddHash(builder, hashVector); // end build var codedTransfer = LockFundsTransactionBuffer.EndLockFundsTransactionBuffer(builder); builder.Finish(codedTransfer.Value); var output = new LockFundsTransactionSchema().Serialize(builder.SizedByteArray()); if (output.Length != totalSize) { throw new SerializationException("Serialized form has incorrect length"); } return(output); }
internal override byte[] GenerateBytes() { var builder = new FlatBufferBuilder(1); // create message var bytePayload = Message.GetPayload(); var payload = MessageBuffer.CreatePayloadVector(builder, bytePayload); MessageBuffer.StartMessageBuffer(builder); MessageBuffer.AddType(builder, Message.GetMessageType()); MessageBuffer.AddPayload(builder, payload); var messageVector = MessageBuffer.EndMessageBuffer(builder); // create mosaics var mosaicBuffers = new Offset <MosaicBuffer> [Mosaics.Count]; for (var index = 0; index < Mosaics.Count; ++index) { var mosaic = Mosaics[index]; var id = MosaicBuffer.CreateIdVector(builder, mosaic.Id.Id.ToUInt8Array()); var amount = MosaicBuffer.CreateAmountVector(builder, mosaic.Amount.ToUInt8Array()); MosaicBuffer.StartMosaicBuffer(builder); MosaicBuffer.AddId(builder, id); MosaicBuffer.AddAmount(builder, amount); mosaicBuffers[index] = MosaicBuffer.EndMosaicBuffer(builder); } // create recipient byte[] recipientBytes = Recipient.GetBytes(); // create vectors var signatureVector = TransferTransactionBuffer.CreateSignatureVector(builder, new byte[64]); var signerVector = TransferTransactionBuffer.CreateSignerVector(builder, GetSigner()); var deadlineVector = TransferTransactionBuffer.CreateDeadlineVector(builder, Deadline.Ticks.ToUInt8Array()); var feeVector = TransferTransactionBuffer.CreateMaxFeeVector(builder, MaxFee?.ToUInt8Array()); var recipientVector = TransferTransactionBuffer.CreateRecipientVector(builder, recipientBytes); var mosaicsVector = TransferTransactionBuffer.CreateMosaicsVector(builder, mosaicBuffers); // total size of transaction /*var totalSize = HEADER_SIZE + 25 // recipient + 2 // message size is short + 1 // message type byte + 1 // no of mosaics + ((8 + 8) * Mosaics.Count) //each mosaic has id(8bytes) and amount(8bytes) + bytePayload.Length; // number of message bytes*/ var totalSize = GetSerializedSize(); // create version var version = GetTxVersionSerialization(); // add vectors TransferTransactionBuffer.StartTransferTransactionBuffer(builder); TransferTransactionBuffer.AddSize(builder, (uint)totalSize); TransferTransactionBuffer.AddSignature(builder, signatureVector); TransferTransactionBuffer.AddSigner(builder, signerVector); TransferTransactionBuffer.AddVersion(builder, (uint)version); TransferTransactionBuffer.AddType(builder, EntityType.TRANSFER.GetValue()); TransferTransactionBuffer.AddMaxFee(builder, feeVector); TransferTransactionBuffer.AddDeadline(builder, deadlineVector); TransferTransactionBuffer.AddRecipient(builder, recipientVector); TransferTransactionBuffer.AddNumMosaics(builder, (byte)Mosaics.Count); TransferTransactionBuffer.AddMessageSize(builder, (ushort)(bytePayload.Length + 1)); TransferTransactionBuffer.AddMessage(builder, messageVector); TransferTransactionBuffer.AddMosaics(builder, mosaicsVector); // end build var codedTransfer = TransferTransactionBuffer.EndTransferTransactionBuffer(builder); builder.Finish(codedTransfer.Value); // validate size var output = new TransferTransactionSchema().Serialize(builder.SizedByteArray()); if (output.Length != totalSize) { throw new SerializationException("Serialized form has incorrect length"); } return(output); }
internal override byte[] GenerateBytes() { var builder = new FlatBufferBuilder(1); // track the size of the whole metadata modification //var totalSize = 0; // load modifications var modificationVectors = new Offset<MetadataModificationBuffer>[Modifications.Count]; for (var i = 0; i < modificationVectors.Length; i++) { var mod = Modifications[i]; var modField = mod.Field; var modType = mod.Type; // prepare intermediate data var keyBytes = Encoding.UTF8.GetBytes(modField.Key); var valueBytes = modType == MetadataModificationType.REMOVE ? new byte[0] : Encoding.UTF8.GetBytes(modField.Value); // 2 bytes var valueSizeBytes = BitConverter.GetBytes((short) valueBytes.Length); // prepare vectors for collections var keyVector = MetadataModificationBuffer.CreateKeyVector(builder, keyBytes); var valueVector = MetadataModificationBuffer.CreateValueVector(builder, valueBytes); var valueSizeVector = MetadataModificationBuffer.CreateValueSizeVector(builder, valueSizeBytes); // compute number of bytes: size + modType + keySize + valueSize + key + value var modSize = 4 + 1 + 1 + 2 + keyBytes.Length + valueBytes.Length; // increase total size //totalSize += modSize; // populate flat-buffer MetadataModificationBuffer.StartMetadataModificationBuffer(builder); MetadataModificationBuffer.AddSize(builder, (uint) modSize); MetadataModificationBuffer.AddKeySize(builder, (byte) keyBytes.Length); MetadataModificationBuffer.AddKey(builder, keyVector); MetadataModificationBuffer.AddValueSize(builder, valueSizeVector); MetadataModificationBuffer.AddValue(builder, valueVector); MetadataModificationBuffer.AddModificationType(builder, modType.GetValueInByte()); modificationVectors[i] = MetadataModificationBuffer.EndMetadataModificationBuffer(builder); } // create version var version = GetTxVersionSerialization(); var signatureVector = ModifyMetadataTransactionBuffer.CreateSignatureVector(builder, new byte[64]); var signerVector = ModifyMetadataTransactionBuffer.CreateSignerVector(builder, GetSigner()); var feeVector = ModifyMetadataTransactionBuffer.CreateMaxFeeVector(builder, MaxFee?.ToUInt8Array()); var deadlineVector = ModifyMetadataTransactionBuffer.CreateDeadlineVector(builder, Deadline.Ticks.ToUInt8Array()); var metadataIdBytes = new byte[0]; switch (MetadataType) { case MetadataType.ADDRESS: metadataIdBytes = Address.Plain.FromBase32String(); break; case MetadataType.MOSAIC: case MetadataType.NAMESPACE: metadataIdBytes = MetadataId.HasValue ? BitConverter.GetBytes(MetadataId.Value) : new byte[0]; break; } var metadataIdVector = ModifyMetadataTransactionBuffer.CreateMetadataIdVector(builder, metadataIdBytes); var modificationsVector = ModifyMetadataTransactionBuffer.CreateModificationsVector(builder, modificationVectors); // add size of stuff with constant size and size of metadata id // var fixedSize = HEADER_SIZE + 1 + metadataIdBytes.Length + totalSize; var totalSize = GetSerializedSize(); ModifyMetadataTransactionBuffer.StartModifyMetadataTransactionBuffer(builder); ModifyMetadataTransactionBuffer.AddSize(builder, (uint)totalSize); ModifyMetadataTransactionBuffer.AddSignature(builder, signatureVector); ModifyMetadataTransactionBuffer.AddSigner(builder, signerVector); ModifyMetadataTransactionBuffer.AddVersion(builder, (uint)version); ModifyMetadataTransactionBuffer.AddType(builder, TransactionType.GetValue()); ModifyMetadataTransactionBuffer.AddMaxFee(builder, feeVector); ModifyMetadataTransactionBuffer.AddDeadline(builder, deadlineVector); ModifyMetadataTransactionBuffer.AddMetadataId(builder, metadataIdVector); ModifyMetadataTransactionBuffer.AddMetadataType(builder, MetadataType.GetValueInByte()); ModifyMetadataTransactionBuffer.AddModifications(builder, modificationsVector); // end build var codedTransfer = ModifyMetadataTransactionBuffer.EndModifyMetadataTransactionBuffer(builder); builder.Finish(codedTransfer.Value); var output = new ModifyMetadataTransactionSchema().Serialize(builder.SizedByteArray()); if (output.Length != totalSize) throw new SerializationException("Serialized form has incorrect length"); return output; }
internal override byte[] GenerateBytes() { var builder = new FlatBufferBuilder(1); // create version var version = GetTxVersionSerialization(); var signatureVector = CatapultConfigTransactionBuffer.CreateSignatureVector(builder, new byte[64]); var signerVector = CatapultConfigTransactionBuffer.CreateSignerVector(builder, GetSigner()); var feeVector = CatapultConfigTransactionBuffer.CreateMaxFeeVector(builder, MaxFee?.ToUInt8Array()); var deadlineVector = CatapultConfigTransactionBuffer.CreateDeadlineVector(builder, Deadline.Ticks.ToUInt8Array()); var configBytes = Encoding.UTF8.GetBytes(BlockchainConfig); var entityBytes = Encoding.UTF8.GetBytes(SupportedEntityVersions); var applyHeightVector = CatapultConfigTransactionBuffer.CreateApplyHeightDeltaVector(builder, ApplyHeightDelta.ToUInt8Array()); var configVector = CatapultConfigTransactionBuffer.CreateBlockChainConfigVector(builder, configBytes); var entityVector = CatapultConfigTransactionBuffer.CreateBlockChainConfigVector(builder, entityBytes); // header, 2 uint64 and int //var fixedSize = HEADER_SIZE + 8 + 2 + 2 + entityBytes.Length + configBytes.Length; var totalSize = GetPayloadSerializedSize(); CatapultConfigTransactionBuffer.StartCatapultConfigTransactionBuffer(builder); CatapultConfigTransactionBuffer.AddSize(builder, (uint)totalSize); CatapultConfigTransactionBuffer.AddSignature(builder, signatureVector); CatapultConfigTransactionBuffer.AddSigner(builder, signerVector); CatapultConfigTransactionBuffer.AddVersion(builder, (uint)version); CatapultConfigTransactionBuffer.AddType(builder, TransactionType.GetValue()); CatapultConfigTransactionBuffer.AddMaxFee(builder, feeVector); CatapultConfigTransactionBuffer.AddDeadline(builder, deadlineVector); CatapultConfigTransactionBuffer.AddApplyHeightDelta(builder, applyHeightVector); CatapultConfigTransactionBuffer.AddBlockChainConfig(builder, configVector); CatapultConfigTransactionBuffer.AddBlockChainConfigSize(builder, (ushort)configBytes.Length); CatapultConfigTransactionBuffer.AddSupportedEntityVersionsSize(builder, (ushort)entityBytes.Length); CatapultConfigTransactionBuffer.AddSupportedEntityVersions(builder, entityVector); // end build var codedTransfer = CatapultConfigTransactionBuffer.EndCatapultConfigTransactionBuffer(builder); builder.Finish(codedTransfer.Value); var output = new BlockchainConfigTransactionSchema().Serialize(builder.SizedByteArray()); if (output.Length != totalSize) { throw new SerializationException("Serialized form has incorrect length"); } return(output); }
internal override byte[] GenerateBytes() { var builder = new FlatBufferBuilder(1); // create vectors var signatureVector = SecretLockTransactionBuffer.CreateSignatureVector(builder, new byte[64]); var signerVector = SecretLockTransactionBuffer.CreateSignerVector(builder, GetSigner()); var feeVector = SecretLockTransactionBuffer.CreateMaxFeeVector(builder, MaxFee?.ToUInt8Array()); var deadlineVector = SecretLockTransactionBuffer.CreateDeadlineVector(builder, Deadline.Ticks.ToUInt8Array()); var mosaicIdVector = SecretLockTransactionBuffer.CreateMosaicIdVector(builder, Mosaic.Id.Id.ToUInt8Array()); var mosaicAmountVector = SecretLockTransactionBuffer.CreateMosaicAmountVector(builder, Mosaic.Amount.ToUInt8Array()); var durationVector = SecretLockTransactionBuffer.CreateDurationVector(builder, Duration.ToUInt8Array()); var secretVector = SecretLockTransactionBuffer.CreateSecretVector(builder, Secret.DecodeHexString()); var recipientVector = SecretLockTransactionBuffer.CreateRecipientVector(builder, Recipient.Plain.FromBase32String()); var version = int.Parse(NetworkType.GetValueInByte().ToString("X") + "0" + Version.ToString("X"), NumberStyles.HexNumber); // mosaicID, amount, duration, hash algo, secret, recipient var totalSize = GetSerializedSize(); SecretLockTransactionBuffer.StartSecretLockTransactionBuffer(builder); SecretLockTransactionBuffer.AddSize(builder, (uint)totalSize); SecretLockTransactionBuffer.AddSignature(builder, signatureVector); SecretLockTransactionBuffer.AddSigner(builder, signerVector); SecretLockTransactionBuffer.AddVersion(builder, (uint)version); SecretLockTransactionBuffer.AddType(builder, TransactionType.GetValue()); SecretLockTransactionBuffer.AddMaxFee(builder, feeVector); SecretLockTransactionBuffer.AddDeadline(builder, deadlineVector); SecretLockTransactionBuffer.AddMosaicId(builder, mosaicIdVector); SecretLockTransactionBuffer.AddMosaicAmount(builder, mosaicAmountVector); SecretLockTransactionBuffer.AddDuration(builder, durationVector); SecretLockTransactionBuffer.AddHashAlgorithm(builder, HashType.GetValueInByte()); SecretLockTransactionBuffer.AddSecret(builder, secretVector); SecretLockTransactionBuffer.AddRecipient(builder, recipientVector); // end build var codedTransfer = SecretLockTransactionBuffer.EndSecretLockTransactionBuffer(builder); builder.Finish(codedTransfer.Value); var output = new SecretLockTransactionSchema().Serialize(builder.SizedByteArray()); if (output.Length != totalSize) { throw new SerializationException("Serialized form has incorrect length"); } return(output); }