public BatchWriter(IByteWriter target, int maxBufferSizeInBytes)
{
_target = target;
_pendingBuffer = new ByteBuffer(maxBufferSizeInBytes);
_flushBuffer = new ByteBuffer(maxBufferSizeInBytes);
_minFlushSize = maxBufferSizeInBytes/2;
}
public static void Encode(IByteWriter stream, ManageOfferOp encodedManageOfferOp) {
Asset.Encode(stream, encodedManageOfferOp.Selling);
Asset.Encode(stream, encodedManageOfferOp.Buying);
Int64.Encode(stream, encodedManageOfferOp.Amount);
Price.Encode(stream, encodedManageOfferOp.Price);
Uint64.Encode(stream, encodedManageOfferOp.OfferID);
}
public static void Encode(IByteWriter stream, TransactionHistoryResultEntryExt encodedTransactionHistoryResultEntryExt) {
XdrEncoding.EncodeInt32(encodedTransactionHistoryResultEntryExt.Discriminant, stream);
switch (encodedTransactionHistoryResultEntryExt.Discriminant) {
case 0:
break;
}
}
public static void Encode(IByteWriter stream, StellarValueExt encodedStellarValueExt) {
XdrEncoding.EncodeInt32(encodedStellarValueExt.Discriminant, stream);
switch (encodedStellarValueExt.Discriminant) {
case 0:
break;
}
}
public static void Encode(IByteWriter stream, LedgerEntryChanges encodedLedgerEntryChanges) {
int LedgerEntryChangesSize = encodedLedgerEntryChanges.InnerValue.Length;
XdrEncoding.EncodeInt32(LedgerEntryChangesSize, stream);
for (int i = 0; i < LedgerEntryChangesSize; i++) {
LedgerEntryChange.Encode(stream, encodedLedgerEntryChanges.InnerValue[i]);
}
}
public static void Encode(IByteWriter stream, LedgerHeaderHistoryEntryExt encodedLedgerHeaderHistoryEntryExt) {
XdrEncoding.EncodeInt32(encodedLedgerHeaderHistoryEntryExt.Discriminant, stream);
switch (encodedLedgerHeaderHistoryEntryExt.Discriminant) {
case 0:
break;
}
}
public static void Encode(IByteWriter stream, TransactionResultSet encodedTransactionResultSet) {
int resultssize = encodedTransactionResultSet.Results.Length;
XdrEncoding.EncodeInt32(resultssize, stream);
for (int i = 0; i < resultssize; i++) {
TransactionResultPair.Encode(stream, encodedTransactionResultSet.Results[i]);
}
}
public static void Encode(IByteWriter stream, OfferEntryExt encodedOfferEntryExt) {
XdrEncoding.EncodeInt32(encodedOfferEntryExt.Discriminant, stream);
switch (encodedOfferEntryExt.Discriminant) {
case 0:
break;
}
}
/// <summary>
/// Encodes the UInt32.
/// http://tools.ietf.org/html/rfc4506#section-4.2
/// </summary>
public static void EncodeUInt32(uint v, IByteWriter w)
{
w.Write((byte)((v >> 0x18) & 0xff));
w.Write((byte)((v >> 0x10) & 0xff));
w.Write((byte)((v >> 8) & 0xff));
w.Write((byte)(v & 0xff));
}
public static void Encode(IByteWriter stream, PublicKey encodedPublicKey) {
XdrEncoding.EncodeInt32((int)encodedPublicKey.Discriminant.InnerValue, stream);
switch (encodedPublicKey.Discriminant.InnerValue) {
case CryptoKeyType.CryptoKeyTypeEnum.KEY_TYPE_ED25519:
Uint256.Encode(stream, encodedPublicKey.Ed25519);
break;
}
}
public static void Encode(IByteWriter stream, SCPHistoryEntry encodedSCPHistoryEntry) {
XdrEncoding.EncodeInt32(encodedSCPHistoryEntry.Discriminant, stream);
switch (encodedSCPHistoryEntry.Discriminant) {
case 0:
SCPHistoryEntryV0.Encode(stream, encodedSCPHistoryEntry.V0);
break;
}
}
public static void Encode(IByteWriter stream, TransactionEnvelope encodedTransactionEnvelope) {
Transaction.Encode(stream, encodedTransactionEnvelope.Tx);
int signaturessize = encodedTransactionEnvelope.Signatures.Length;
XdrEncoding.EncodeInt32(signaturessize, stream);
for (int i = 0; i < signaturessize; i++) {
DecoratedSignature.Encode(stream, encodedTransactionEnvelope.Signatures[i]);
}
}
public static void Encode(IByteWriter stream, TrustLineEntry encodedTrustLineEntry) {
AccountID.Encode(stream, encodedTrustLineEntry.AccountID);
Asset.Encode(stream, encodedTrustLineEntry.Asset);
Int64.Encode(stream, encodedTrustLineEntry.Balance);
Int64.Encode(stream, encodedTrustLineEntry.Limit);
Uint32.Encode(stream, encodedTrustLineEntry.Flags);
TrustLineEntryExt.Encode(stream, encodedTrustLineEntry.Ext);
}
public static void Encode(IByteWriter stream, LedgerSCPMessages encodedLedgerSCPMessages) {
Uint32.Encode(stream, encodedLedgerSCPMessages.LedgerSeq);
int messagessize = encodedLedgerSCPMessages.Messages.Length;
XdrEncoding.EncodeInt32(messagessize, stream);
for (int i = 0; i < messagessize; i++) {
SCPEnvelope.Encode(stream, encodedLedgerSCPMessages.Messages[i]);
}
}
public static void Encode(IByteWriter stream, ClaimOfferAtom encodedClaimOfferAtom) {
AccountID.Encode(stream, encodedClaimOfferAtom.SellerID);
Uint64.Encode(stream, encodedClaimOfferAtom.OfferID);
Asset.Encode(stream, encodedClaimOfferAtom.AssetSold);
Int64.Encode(stream, encodedClaimOfferAtom.AmountSold);
Asset.Encode(stream, encodedClaimOfferAtom.AssetBought);
Int64.Encode(stream, encodedClaimOfferAtom.AmountBought);
}
public static void Encode(IByteWriter stream, TransactionSet encodedTransactionSet) {
Hash.Encode(stream, encodedTransactionSet.PreviousLedgerHash);
int txssize = encodedTransactionSet.Txs.Length;
XdrEncoding.EncodeInt32(txssize, stream);
for (int i = 0; i < txssize; i++) {
TransactionEnvelope.Encode(stream, encodedTransactionSet.Txs[i]);
}
}
public static void Encode(IByteWriter stream, PathPaymentResultSuccess encodedPathPaymentResultSuccess) {
int offerssize = encodedPathPaymentResultSuccess.Offers.Length;
XdrEncoding.EncodeInt32(offerssize, stream);
for (int i = 0; i < offerssize; i++) {
ClaimOfferAtom.Encode(stream, encodedPathPaymentResultSuccess.Offers[i]);
}
SimplePaymentResult.Encode(stream, encodedPathPaymentResultSuccess.Last);
}
public static void Encode(IByteWriter stream, SCPHistoryEntryV0 encodedSCPHistoryEntryV0) {
int quorumSetssize = encodedSCPHistoryEntryV0.QuorumSets.Length;
XdrEncoding.EncodeInt32(quorumSetssize, stream);
for (int i = 0; i < quorumSetssize; i++) {
SCPQuorumSet.Encode(stream, encodedSCPHistoryEntryV0.QuorumSets[i]);
}
LedgerSCPMessages.Encode(stream, encodedSCPHistoryEntryV0.LedgerMessages);
}
public static void Encode(IByteWriter stream, ManageOfferSuccessResult encodedManageOfferSuccessResult) {
int offersClaimedsize = encodedManageOfferSuccessResult.OffersClaimed.Length;
XdrEncoding.EncodeInt32(offersClaimedsize, stream);
for (int i = 0; i < offersClaimedsize; i++) {
ClaimOfferAtom.Encode(stream, encodedManageOfferSuccessResult.OffersClaimed[i]);
}
ManageOfferSuccessResultOffer.Encode(stream, encodedManageOfferSuccessResult.Offer);
}
public static void Encode(IByteWriter stream, AuthenticatedMessage encodedAuthenticatedMessage) {
XdrEncoding.EncodeInt32((int)encodedAuthenticatedMessage.Discriminant.InnerValue, stream);
switch (encodedAuthenticatedMessage.Discriminant.InnerValue) {
case 0:
AuthenticatedMessageV0.Encode(stream, encodedAuthenticatedMessage.V0);
break;
}
}
public static void Encode(IByteWriter stream, SetOptionsResult encodedSetOptionsResult) {
XdrEncoding.EncodeInt32((int)encodedSetOptionsResult.Discriminant.InnerValue, stream);
switch (encodedSetOptionsResult.Discriminant.InnerValue) {
case SetOptionsResultCode.SetOptionsResultCodeEnum.SET_OPTIONS_SUCCESS:
break;
default:
break;
}
}
public static void Encode(IByteWriter stream, ChangeTrustResult encodedChangeTrustResult) {
XdrEncoding.EncodeInt32((int)encodedChangeTrustResult.Discriminant.InnerValue, stream);
switch (encodedChangeTrustResult.Discriminant.InnerValue) {
case ChangeTrustResultCode.ChangeTrustResultCodeEnum.CHANGE_TRUST_SUCCESS:
break;
default:
break;
}
}
public static void Encode(IByteWriter stream, ManageDataResult encodedManageDataResult) {
XdrEncoding.EncodeInt32((int)encodedManageDataResult.Discriminant.InnerValue, stream);
switch (encodedManageDataResult.Discriminant.InnerValue) {
case ManageDataResultCode.ManageDataResultCodeEnum.MANAGE_DATA_SUCCESS:
break;
default:
break;
}
}
public static void Encode(IByteWriter stream, AllowTrustResult encodedAllowTrustResult) {
XdrEncoding.EncodeInt32((int)encodedAllowTrustResult.Discriminant.InnerValue, stream);
switch (encodedAllowTrustResult.Discriminant.InnerValue) {
case AllowTrustResultCode.AllowTrustResultCodeEnum.ALLOW_TRUST_SUCCESS:
break;
default:
break;
}
}
public static void Encode(IByteWriter stream, Operation encodedOperation) {
if (encodedOperation.SourceAccount != null) {
XdrEncoding.EncodeInt32(1, stream);
AccountID.Encode(stream, encodedOperation.SourceAccount);
} else {
XdrEncoding.EncodeInt32(0, stream);
}
OperationBody.Encode(stream, encodedOperation.Body);
}
public static void Encode(IByteWriter stream, PaymentResult encodedPaymentResult) {
XdrEncoding.EncodeInt32((int)encodedPaymentResult.Discriminant.InnerValue, stream);
switch (encodedPaymentResult.Discriminant.InnerValue) {
case PaymentResultCode.PaymentResultCodeEnum.PAYMENT_SUCCESS:
break;
default:
break;
}
}
public static void Encode(IByteWriter stream, CreateAccountResult encodedCreateAccountResult) {
XdrEncoding.EncodeInt32((int)encodedCreateAccountResult.Discriminant.InnerValue, stream);
switch (encodedCreateAccountResult.Discriminant.InnerValue) {
case CreateAccountResultCode.CreateAccountResultCodeEnum.CREATE_ACCOUNT_SUCCESS:
break;
default:
break;
}
}
public static void Encode(IByteWriter stream, ManageDataOp encodedManageDataOp) {
String64.Encode(stream, encodedManageDataOp.DataName);
if (encodedManageDataOp.DataValue != null) {
XdrEncoding.EncodeInt32(1, stream);
DataValue.Encode(stream, encodedManageDataOp.DataValue);
} else {
XdrEncoding.EncodeInt32(0, stream);
}
}
public static void Encode(IByteWriter stream, SetOptionsOp encodedSetOptionsOp) {
if (encodedSetOptionsOp.InflationDest != null) {
XdrEncoding.EncodeInt32(1, stream);
AccountID.Encode(stream, encodedSetOptionsOp.InflationDest);
} else {
XdrEncoding.EncodeInt32(0, stream);
}
if (encodedSetOptionsOp.ClearFlags != null) {
XdrEncoding.EncodeInt32(1, stream);
Uint32.Encode(stream, encodedSetOptionsOp.ClearFlags);
} else {
XdrEncoding.EncodeInt32(0, stream);
}
if (encodedSetOptionsOp.SetFlags != null) {
XdrEncoding.EncodeInt32(1, stream);
Uint32.Encode(stream, encodedSetOptionsOp.SetFlags);
} else {
XdrEncoding.EncodeInt32(0, stream);
}
if (encodedSetOptionsOp.MasterWeight != null) {
XdrEncoding.EncodeInt32(1, stream);
Uint32.Encode(stream, encodedSetOptionsOp.MasterWeight);
} else {
XdrEncoding.EncodeInt32(0, stream);
}
if (encodedSetOptionsOp.LowThreshold != null) {
XdrEncoding.EncodeInt32(1, stream);
Uint32.Encode(stream, encodedSetOptionsOp.LowThreshold);
} else {
XdrEncoding.EncodeInt32(0, stream);
}
if (encodedSetOptionsOp.MedThreshold != null) {
XdrEncoding.EncodeInt32(1, stream);
Uint32.Encode(stream, encodedSetOptionsOp.MedThreshold);
} else {
XdrEncoding.EncodeInt32(0, stream);
}
if (encodedSetOptionsOp.HighThreshold != null) {
XdrEncoding.EncodeInt32(1, stream);
Uint32.Encode(stream, encodedSetOptionsOp.HighThreshold);
} else {
XdrEncoding.EncodeInt32(0, stream);
}
if (encodedSetOptionsOp.HomeDomain != null) {
XdrEncoding.EncodeInt32(1, stream);
String32.Encode(stream, encodedSetOptionsOp.HomeDomain);
} else {
XdrEncoding.EncodeInt32(0, stream);
}
if (encodedSetOptionsOp.Signer != null) {
XdrEncoding.EncodeInt32(1, stream);
Signer.Encode(stream, encodedSetOptionsOp.Signer);
} else {
XdrEncoding.EncodeInt32(0, stream);
}
}
public static void Encode(IByteWriter stream, OperationResult encodedOperationResult) {
XdrEncoding.EncodeInt32((int)encodedOperationResult.Discriminant.InnerValue, stream);
switch (encodedOperationResult.Discriminant.InnerValue) {
case OperationResultCode.OperationResultCodeEnum.opINNER:
OperationResultTr.Encode(stream, encodedOperationResult.Tr);
break;
default:
break;
}
}
public static void Encode(IByteWriter stream, PathPaymentResult encodedPathPaymentResult)
{
XdrEncoding.EncodeInt32((int)encodedPathPaymentResult.Discriminant.InnerValue, stream);
switch (encodedPathPaymentResult.Discriminant.InnerValue)
{
case PathPaymentResultCode.PathPaymentResultCodeEnum.PATH_PAYMENT_SUCCESS:
PathPaymentResultSuccess.Encode(stream, encodedPathPaymentResult.Success);
break;
case PathPaymentResultCode.PathPaymentResultCodeEnum.PATH_PAYMENT_NO_ISSUER:
Asset.Encode(stream, encodedPathPaymentResult.NoIssuer);
break;
default:
break;
}
}
public static void Encode(IByteWriter stream, InflationResult encodedInflationResult)
{
XdrEncoding.EncodeInt32((int)encodedInflationResult.Discriminant.InnerValue, stream);
switch (encodedInflationResult.Discriminant.InnerValue)
{
case InflationResultCode.InflationResultCodeEnum.INFLATION_SUCCESS:
int payoutssize = encodedInflationResult.Payouts.Length;
XdrEncoding.EncodeInt32(payoutssize, stream);
for (int i = 0; i < payoutssize; i++)
{
InflationPayout.Encode(stream, encodedInflationResult.Payouts[i]);
}
break;
default:
break;
}
}
public static void Encode(IByteWriter stream, SignerKey encodedSignerKey)
{
XdrEncoding.EncodeInt32((int)encodedSignerKey.Discriminant.InnerValue, stream);
switch (encodedSignerKey.Discriminant.InnerValue)
{
case SignerKeyType.SignerKeyTypeEnum.SIGNER_KEY_TYPE_ED25519:
Uint256.Encode(stream, encodedSignerKey.Ed25519);
break;
case SignerKeyType.SignerKeyTypeEnum.SIGNER_KEY_TYPE_PRE_AUTH_TX:
Uint256.Encode(stream, encodedSignerKey.PreAuthTx);
break;
case SignerKeyType.SignerKeyTypeEnum.SIGNER_KEY_TYPE_HASH_X:
Uint256.Encode(stream, encodedSignerKey.HashX);
break;
}
}
public void Serialize(IByteWriter buffer)
{
for (var i = 0; i < ChunkSize3D; i++)
{
buffer.WriteUInt16(_blockIds[i]);
}
buffer.WriteUInt16((ushort)_blockData.Count);
foreach (var pair in _blockData)
{
var index = pair.Key;
var data = pair.Value;
buffer.WriteUInt16(index);
data.Serialize(buffer);
}
}
public static void Encode(IByteWriter stream, LedgerUpgrade encodedLedgerUpgrade)
{
XdrEncoding.EncodeInt32((int)encodedLedgerUpgrade.Discriminant.InnerValue, stream);
switch (encodedLedgerUpgrade.Discriminant.InnerValue)
{
case LedgerUpgradeType.LedgerUpgradeTypeEnum.LEDGER_UPGRADE_VERSION:
Uint32.Encode(stream, encodedLedgerUpgrade.NewLedgerVersion);
break;
case LedgerUpgradeType.LedgerUpgradeTypeEnum.LEDGER_UPGRADE_BASE_FEE:
Uint32.Encode(stream, encodedLedgerUpgrade.NewBaseFee);
break;
case LedgerUpgradeType.LedgerUpgradeTypeEnum.LEDGER_UPGRADE_MAX_TX_SET_SIZE:
Uint32.Encode(stream, encodedLedgerUpgrade.NewMaxTxSetSize);
break;
}
}
public static void Encode(IByteWriter stream, SCPQuorumSet encodedSCPQuorumSet)
{
Uint32.Encode(stream, encodedSCPQuorumSet.Threshold);
int validatorssize = encodedSCPQuorumSet.Validators.Length;
XdrEncoding.EncodeInt32(validatorssize, stream);
for (int i = 0; i < validatorssize; i++)
{
PublicKey.Encode(stream, encodedSCPQuorumSet.Validators[i]);
}
int innerSetssize = encodedSCPQuorumSet.InnerSets.Length;
XdrEncoding.EncodeInt32(innerSetssize, stream);
for (int i = 0; i < innerSetssize; i++)
{
SCPQuorumSet.Encode(stream, encodedSCPQuorumSet.InnerSets[i]);
}
}
public static void Encode(IByteWriter stream, SCPNomination encodedSCPNomination)
{
Hash.Encode(stream, encodedSCPNomination.QuorumSetHash);
int votessize = encodedSCPNomination.Votes.Length;
XdrEncoding.EncodeInt32(votessize, stream);
for (int i = 0; i < votessize; i++)
{
Value.Encode(stream, encodedSCPNomination.Votes[i]);
}
int acceptedsize = encodedSCPNomination.Accepted.Length;
XdrEncoding.EncodeInt32(acceptedsize, stream);
for (int i = 0; i < acceptedsize; i++)
{
Value.Encode(stream, encodedSCPNomination.Accepted[i]);
}
}
/// <summary>
/// 发送消息包。
/// </summary>
/// <param name="buffer">发送的包实例。</param>
/// <returns>返回当前执行的结果。</returns>
protected async Task <bool> SendAsync(IByteWriter buffer)
{
if (!Socket.Connected)
{
return(false);
}
await using var ms = new MemoryStream();
await using var bw = new ByteWriter(ms);
buffer.Write(bw);
var bytes = ms.ToArray();
Actived = DateTimeOffset.Now;
await _semaphore.WaitAsync(TimeSpan.FromMinutes(1));
var count = await Socket.SendAsync(bytes, SocketFlags.None);
_semaphore.Release();
return(count > 0);
}
public static void Encode(IByteWriter stream, TransactionResultResult encodedTransactionResultResult)
{
XdrEncoding.EncodeInt32((int)encodedTransactionResultResult.Discriminant.InnerValue, stream);
switch (encodedTransactionResultResult.Discriminant.InnerValue)
{
case TransactionResultCode.TransactionResultCodeEnum.txSUCCESS:
case TransactionResultCode.TransactionResultCodeEnum.txFAILED:
int resultssize = encodedTransactionResultResult.Results.Length;
XdrEncoding.EncodeInt32(resultssize, stream);
for (int i = 0; i < resultssize; i++)
{
OperationResult.Encode(stream, encodedTransactionResultResult.Results[i]);
}
break;
default:
break;
}
}
public static void Encode(IByteWriter stream, Memo encodedMemo) {
XdrEncoding.EncodeInt32((int)encodedMemo.Discriminant.InnerValue, stream);
switch (encodedMemo.Discriminant.InnerValue) {
case MemoType.MemoTypeEnum.MEMO_NONE:
break;
case MemoType.MemoTypeEnum.MEMO_TEXT:
XdrEncoding.WriteString(stream, encodedMemo.Text);
break;
case MemoType.MemoTypeEnum.MEMO_ID:
Uint64.Encode(stream, encodedMemo.Id);
break;
case MemoType.MemoTypeEnum.MEMO_HASH:
Hash.Encode(stream, encodedMemo.Hash);
break;
case MemoType.MemoTypeEnum.MEMO_RETURN:
Hash.Encode(stream, encodedMemo.RetHash);
break;
}
}
public static void WriteVarOpaque(IByteWriter w, uint max, byte[] v)
{
uint len = (uint)v.LongLength;
if (len > max)
{
throw new FormatException("unexpected length: " + len.ToString());
}
try
{
EncodeUInt32(len, w);
}
catch (SystemException ex)
{
throw new FormatException("can't write length", ex);
}
NoCheckWriteFixOpaque(w, len, v);
}
public void BuildRpcMessage(IByteWriter bw)
{
rpc_msg reqHeader = new rpc_msg()
{
xid = Xid,
body = new body()
{
mtype = msg_type.CALL,
cbody = _callBody
}
};
Writer xw = Toolkit.CreateWriter(bw);
xw.Write(reqHeader);
xw.Write(_reqArgs);
_callBody = null;
_reqArgs = default(TReq);
}
public static void Encode(IByteWriter stream, LedgerEntryData encodedLedgerEntryData)
{
XdrEncoding.EncodeInt32((int)encodedLedgerEntryData.Discriminant.InnerValue, stream);
switch (encodedLedgerEntryData.Discriminant.InnerValue)
{
case LedgerEntryType.LedgerEntryTypeEnum.ACCOUNT:
AccountEntry.Encode(stream, encodedLedgerEntryData.Account);
break;
case LedgerEntryType.LedgerEntryTypeEnum.TRUSTLINE:
TrustLineEntry.Encode(stream, encodedLedgerEntryData.TrustLine);
break;
case LedgerEntryType.LedgerEntryTypeEnum.OFFER:
OfferEntry.Encode(stream, encodedLedgerEntryData.Offer);
break;
case LedgerEntryType.LedgerEntryTypeEnum.DATA:
DataEntry.Encode(stream, encodedLedgerEntryData.Data);
break;
}
}
public static void Encode(IByteWriter stream, LedgerEntryChange encodedLedgerEntryChange)
{
XdrEncoding.EncodeInt32((int)encodedLedgerEntryChange.Discriminant.InnerValue, stream);
switch (encodedLedgerEntryChange.Discriminant.InnerValue)
{
case LedgerEntryChangeType.LedgerEntryChangeTypeEnum.LEDGER_ENTRY_CREATED:
LedgerEntry.Encode(stream, encodedLedgerEntryChange.Created);
break;
case LedgerEntryChangeType.LedgerEntryChangeTypeEnum.LEDGER_ENTRY_UPDATED:
LedgerEntry.Encode(stream, encodedLedgerEntryChange.Updated);
break;
case LedgerEntryChangeType.LedgerEntryChangeTypeEnum.LEDGER_ENTRY_REMOVED:
LedgerKey.Encode(stream, encodedLedgerEntryChange.Removed);
break;
case LedgerEntryChangeType.LedgerEntryChangeTypeEnum.LEDGER_ENTRY_STATE:
LedgerEntry.Encode(stream, encodedLedgerEntryChange.State);
break;
}
}
public static void Encode(IByteWriter stream, SCPStatementPledges encodedSCPStatementPledges)
{
XdrEncoding.EncodeInt32((int)encodedSCPStatementPledges.Discriminant.InnerValue, stream);
switch (encodedSCPStatementPledges.Discriminant.InnerValue)
{
case SCPStatementType.SCPStatementTypeEnum.SCP_ST_PREPARE:
SCPStatementPrepare.Encode(stream, encodedSCPStatementPledges.Prepare);
break;
case SCPStatementType.SCPStatementTypeEnum.SCP_ST_CONFIRM:
SCPStatementConfirm.Encode(stream, encodedSCPStatementPledges.Confirm);
break;
case SCPStatementType.SCPStatementTypeEnum.SCP_ST_EXTERNALIZE:
SCPStatementExternalize.Encode(stream, encodedSCPStatementPledges.Externalize);
break;
case SCPStatementType.SCPStatementTypeEnum.SCP_ST_NOMINATE:
SCPNomination.Encode(stream, encodedSCPStatementPledges.Nominate);
break;
}
}
public static void Encode(IByteWriter stream, LedgerKey encodedLedgerKey)
{
XdrEncoding.EncodeInt32((int)encodedLedgerKey.Discriminant.InnerValue, stream);
switch (encodedLedgerKey.Discriminant.InnerValue)
{
case LedgerEntryType.LedgerEntryTypeEnum.ACCOUNT:
LedgerKeyAccount.Encode(stream, encodedLedgerKey.Account);
break;
case LedgerEntryType.LedgerEntryTypeEnum.TRUSTLINE:
LedgerKeyTrustLine.Encode(stream, encodedLedgerKey.TrustLine);
break;
case LedgerEntryType.LedgerEntryTypeEnum.OFFER:
LedgerKeyOffer.Encode(stream, encodedLedgerKey.Offer);
break;
case LedgerEntryType.LedgerEntryTypeEnum.DATA:
LedgerKeyData.Encode(stream, encodedLedgerKey.Data);
break;
}
}
private byte WriteData(int index, IByteWriter writer)
{
_buffer.Clear();
while (true)
{
var entry = _table[index];
_buffer.Add(entry.Value);
index = entry.PrefixIndex;
if (index != -1)
{
continue;
}
foreach (var dataByte in _buffer.AsEnumerable().Reverse())
{
writer.WriteByte(dataByte);
}
return(_buffer.Last());
}
}
public static void Encode(IByteWriter stream, LedgerHeader encodedLedgerHeader)
{
Uint32.Encode(stream, encodedLedgerHeader.LedgerVersion);
Hash.Encode(stream, encodedLedgerHeader.PreviousLedgerHash);
StellarValue.Encode(stream, encodedLedgerHeader.ScpValue);
Hash.Encode(stream, encodedLedgerHeader.TxSetResultHash);
Hash.Encode(stream, encodedLedgerHeader.BucketListHash);
Uint32.Encode(stream, encodedLedgerHeader.LedgerSeq);
Int64.Encode(stream, encodedLedgerHeader.TotalCoins);
Int64.Encode(stream, encodedLedgerHeader.FeePool);
Uint32.Encode(stream, encodedLedgerHeader.InflationSeq);
Uint64.Encode(stream, encodedLedgerHeader.IdPool);
Uint32.Encode(stream, encodedLedgerHeader.BaseFee);
Uint32.Encode(stream, encodedLedgerHeader.BaseReserve);
Uint32.Encode(stream, encodedLedgerHeader.MaxTxSetSize);
int skipListsize = encodedLedgerHeader.SkipList.Length;
for (int i = 0; i < skipListsize; i++)
{
Hash.Encode(stream, encodedLedgerHeader.SkipList[i]);
}
LedgerHeaderExt.Encode(stream, encodedLedgerHeader.Ext);
}
bool WriteBytes(IByteWriter byteWriter, SerialPort serialPort)
{
var sendMessage = new byte[11];
sendMessage = byteWriter.WriteBytes(sendMessage);
try
{
serialPort.Write(sendMessage, 0, sendMessage.Length);
}
catch (Exception e)
{
if (e is TimeoutException)
{
recoverCount++;
}
else if (e is IOException || e is InvalidOperationException)
{
return(false);
}
}
return(true);
}
public bool ProcessNextCode(int code, IByteWriter writer, out bool reset)
{
reset = false;
if (code == _resetTable)
{
reset = true;
Reset();
}
else if (code == _endOfStream)
{
return(false);
}
else if (_oldCode == -1)
{
WriteData(code, writer);
_oldCode = code;
}
else if (code < Count)
{
var fbyte = WriteData(code, writer);
Add(_oldCode, fbyte);
_oldCode = code;
}
else
{
var fbyte = WriteData(_oldCode, writer);
writer.WriteByte(fbyte);
Add(_oldCode, fbyte);
_oldCode = code;
}
return(true);
}
public static void Encode(IByteWriter stream, Transaction encodedTransaction)
{
AccountID.Encode(stream, encodedTransaction.SourceAccount);
Uint32.Encode(stream, encodedTransaction.Fee);
SequenceNumber.Encode(stream, encodedTransaction.SeqNum);
if (encodedTransaction.TimeBounds != null)
{
XdrEncoding.EncodeInt32(1, stream);
TimeBounds.Encode(stream, encodedTransaction.TimeBounds);
}
else
{
XdrEncoding.EncodeInt32(0, stream);
}
Memo.Encode(stream, encodedTransaction.Memo);
int operationssize = encodedTransaction.Operations.Length;
XdrEncoding.EncodeInt32(operationssize, stream);
for (int i = 0; i < operationssize; i++)
{
Operation.Encode(stream, encodedTransaction.Operations[i]);
}
TransactionExt.Encode(stream, encodedTransaction.Ext);
}
public static void Encode(IByteWriter stream, CreateAccountOp encodedCreateAccountOp)
{
AccountID.Encode(stream, encodedCreateAccountOp.Destination);
Int64.Encode(stream, encodedCreateAccountOp.StartingBalance);
}
public static void Encode(IByteWriter stream, PathPaymentResultCode value)
{
XdrEncoding.EncodeInt32((int)value.InnerValue, stream);
}
public static void Encode(IByteWriter stream, AuthCert encodedAuthCert)
{
Curve25519Public.Encode(stream, encodedAuthCert.Pubkey);
Uint64.Encode(stream, encodedAuthCert.Expiration);
Signature.Encode(stream, encodedAuthCert.Sig);
}
public static void Encode(IByteWriter stream, Uint32 encodedUint32)
{
XdrEncoding.EncodeUInt32(encodedUint32.InnerValue, stream);
}
public static void Encode(IByteWriter stream, InflationPayout encodedInflationPayout)
{
AccountID.Encode(stream, encodedInflationPayout.Destination);
Int64.Encode(stream, encodedInflationPayout.Amount);
}
public static void Encode(IByteWriter stream, TransactionSignaturePayload encodedTransactionSignaturePayload)
{
Hash.Encode(stream, encodedTransactionSignaturePayload.NetworkId);
TransactionSignaturePayloadTaggedTransaction.Encode(stream, encodedTransactionSignaturePayload.TaggedTransaction);
}
public static void Encode(IByteWriter stream, SimplePaymentResult encodedSimplePaymentResult)
{
AccountID.Encode(stream, encodedSimplePaymentResult.Destination);
Asset.Encode(stream, encodedSimplePaymentResult.Asset);
Int64.Encode(stream, encodedSimplePaymentResult.Amount);
}
public static void Encode(IByteWriter stream, OfferEntryFlags value)
{
XdrEncoding.EncodeInt32((int)value.InnerValue, stream);
}
public static void Encode(IByteWriter stream, SCPEnvelope encodedSCPEnvelope)
{
SCPStatement.Encode(stream, encodedSCPEnvelope.Statement);
Signature.Encode(stream, encodedSCPEnvelope.Signature);
}
