public Operation.OperationBody GetFirstOperationFromTxEnvelope(TransactionEnvelope txEnvelope)
{
if (txEnvelope.Discriminant.InnerValue == EnvelopeType.EnvelopeTypeEnum.ENVELOPE_TYPE_TX_V0)
{
if (txEnvelope?.V0?.Tx.Operations == null || txEnvelope?.V0?.Tx.Operations.Length < 1 ||
txEnvelope?.V0?.Tx.Operations[0].Body == null)
{
throw new HorizonApiException($"Failed to extract first operation from transaction.");
}
var operation = txEnvelope?.V0?.Tx.Operations[0].Body;
return(operation);
}
if (txEnvelope.Discriminant.InnerValue == EnvelopeType.EnvelopeTypeEnum.ENVELOPE_TYPE_TX)
{
if (txEnvelope?.V1?.Tx.Operations == null || txEnvelope?.V1?.Tx.Operations.Length < 1 ||
txEnvelope?.V1?.Tx.Operations[0].Body == null)
{
throw new HorizonApiException($"Failed to extract first operation from transaction.");
}
var operation = txEnvelope?.V1?.Tx.Operations[0].Body;
return(operation);
}
throw new HorizonApiException($"Failed to extract first operation from transaction.");
}
private TransactionEnvelope ToEnvelopeXdr(TransactionXdrVersion version, DecoratedSignature[] signatures)
{
var thisXdr = new TransactionEnvelope();
if (version == TransactionXdrVersion.V0)
{
thisXdr.Discriminant = new EnvelopeType {
InnerValue = EnvelopeType.EnvelopeTypeEnum.ENVELOPE_TYPE_TX_V0
};
thisXdr.V0 = new TransactionV0Envelope();
var transaction = ToXdrV0();
thisXdr.V0.Tx = transaction;
thisXdr.V0.Signatures = signatures;
}
else if (version == TransactionXdrVersion.V1)
{
thisXdr.Discriminant = new EnvelopeType {
InnerValue = EnvelopeType.EnvelopeTypeEnum.ENVELOPE_TYPE_TX
};
thisXdr.V1 = new TransactionV1Envelope();
var transaction = ToXdrV1();
thisXdr.V1.Tx = transaction;
thisXdr.V1.Signatures = signatures;
}
else
{
throw new Exception($"Invalid TransactionXdrVersion {version}");
}
return(thisXdr);
}
public static Transaction FromEnvelopeXdr(TransactionEnvelope envelope)
{
xdr.Transaction transactionXdr = envelope.Tx;
int fee = transactionXdr.Fee.InnerValue;
KeyPair sourceAccount = KeyPair.FromXdrPublicKey(transactionXdr.SourceAccount.InnerValue);
long sequenceNumber = transactionXdr.SeqNum.InnerValue.InnerValue;
Memo memo = Memo.FromXdr(transactionXdr.Memo);
TimeBounds timeBounds = TimeBounds.FromXdr(transactionXdr.TimeBounds);
Operation[] operations = new Operation[transactionXdr.Operations.Length];
for (int i = 0; i < transactionXdr.Operations.Length; i++)
{
operations[i] = Operation.FromXdr(transactionXdr.Operations[i]);
}
Transaction transaction = new Transaction(sourceAccount, fee, sequenceNumber, operations, memo, timeBounds);
foreach (DecoratedSignature signature in envelope.Signatures)
{
transaction.Signatures.Add(signature);
}
return(transaction);
}
public static async Task <string> SignTransaction(KeyPair keyPair, string xdrData)
{
try {
var bytes = Convert.FromBase64String(xdrData);
var transEnv = TransactionEnvelope.Decode(new XdrDataInputStream(bytes));
var sourceKP = KeyPair.FromXdrPublicKey(transEnv.Tx.SourceAccount.InnerValue);
var server = new Server(horizon_url);
var accResponse = await server.Accounts.Account(sourceKP);
var source = new Account(sourceKP, accResponse.SequenceNumber);
var builder = new stellar_dotnetcore_sdk.Transaction.Builder(source);
foreach (var o in transEnv.Tx.Operations)
{
var operation = PaymentOperation.FromXdr(o);
builder.AddOperation(operation);
}
if (transEnv.Tx.Memo != null && transEnv.Tx.Memo.Text != null)
{
var m = stellar_dotnetcore_sdk.Memo.Text(transEnv.Tx.Memo.Text);
builder.AddMemo(m);
}
var trans = builder.Build();
trans.Sign(keyPair);
var signedXdrData = trans.ToEnvelopeXdrBase64();
return(signedXdrData);
} catch (Exception ex) {
System.Diagnostics.Debug.WriteLine(ex);
return(null);
}
}
public static Transaction FromEnvelopeXdr(string envelope)
{
byte[] bytes = Convert.FromBase64String(envelope);
TransactionEnvelope transactionEnvelope = TransactionEnvelope.Decode(new XdrDataInputStream(bytes));
return FromEnvelopeXdr(transactionEnvelope);
}
public Operation.OperationBody GetFirstOperationFromTxEnvelopeXdr(string xdrBase64)
{
var xdr = Convert.FromBase64String(xdrBase64);
var reader = new XdrDataInputStream(xdr);
var txEnvelope = TransactionEnvelope.Decode(reader);
return(GetFirstOperationFromTxEnvelope(txEnvelope));
}
/// <summary>
/// Returns base64-encoded TransactionEnvelope XDR object. Transaction need to have at least one signature.
/// </summary>
/// <returns></returns>
public string ToEnvelopeXdrBase64()
{
var envelope = ToEnvelopeXdr();
var writer = new XdrDataOutputStream();
TransactionEnvelope.Encode(writer, envelope);
return Convert.ToBase64String(writer.ToArray());
}
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]);
}
}
/// <summary>
/// Generates TransactionEnvelope XDR object. This transaction MUST be signed before being useful
/// </summary>
/// <returns></returns>
public string ToUnsignedEnvelopeXdrBase64(TransactionXdrVersion version = TransactionXdrVersion.V1)
{
var envelope = ToUnsignedEnvelopeXdr(version);
var writer = new XdrDataOutputStream();
TransactionEnvelope.Encode(writer, envelope);
return(Convert.ToBase64String(writer.ToArray()));
}
/// <summary>
/// Generates TransactionEnvelope XDR object. This transaction MUST be signed before being useful
/// </summary>
/// <returns></returns>
public string ToUnsignedEnvelopeXdrBase64()
{
TransactionEnvelope envelope = ToUnsignedEnvelopeXdr();
XdrDataOutputStream writer = new XdrDataOutputStream();
TransactionEnvelope.Encode(writer, envelope);
return(Convert.ToBase64String(writer.ToArray()));
}
public static TransactionEnvelope Decode(IByteReader stream) {
TransactionEnvelope decodedTransactionEnvelope = new TransactionEnvelope();
decodedTransactionEnvelope.Tx = Transaction.Decode(stream);
int signaturessize = XdrEncoding.DecodeInt32(stream);
decodedTransactionEnvelope.Signatures = new DecoratedSignature[signaturessize];
for (int i = 0; i < signaturessize; i++) {
decodedTransactionEnvelope.Signatures[i] = DecoratedSignature.Decode(stream);
}
return decodedTransactionEnvelope;
}
public static void Encode(XdrDataOutputStream stream, TransactionEnvelope encodedTransactionEnvelope)
{
Transaction.Encode(stream, encodedTransactionEnvelope.Tx);
var signaturessize = encodedTransactionEnvelope.Signatures.Length;
stream.WriteInt(signaturessize);
for (var i = 0; i < signaturessize; i++)
{
DecoratedSignature.Encode(stream, encodedTransactionEnvelope.Signatures[i]);
}
}
public static void Encode(XdrDataOutputStream stream, TransactionSet encodedTransactionSet)
{
Hash.Encode(stream, encodedTransactionSet.PreviousLedgerHash);
var txssize = encodedTransactionSet.Txs.Length;
stream.WriteInt(txssize);
for (var i = 0; i < txssize; i++)
{
TransactionEnvelope.Encode(stream, encodedTransactionSet.Txs[i]);
}
}
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, 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]);
}
}
/// <summary>
/// Generates TransactionEnvelope XDR object. This transaction MUST be signed before being useful
/// </summary>
/// <returns></returns>
public TransactionEnvelope ToUnsignedEnvelopeXdr()
{
if (Signatures.Count > 0)
throw new TooManySignaturesException("Transaction must not be signed. Use ToEnvelopeXDR.");
var thisXdr = new TransactionEnvelope();
var transaction = ToXdr();
thisXdr.Tx = transaction;
thisXdr.Signatures = new DecoratedSignature[0];
return thisXdr;
}
/// <summary>
/// Generates TransactionEnvelope XDR object. Transaction need to have at least one signature.
/// </summary>
/// <returns></returns>
public TransactionEnvelope ToEnvelopeXdr()
{
if (Signatures.Count == 0)
throw new NotEnoughSignaturesException("Transaction must be signed by at least one signer. Use transaction.sign().");
var thisXdr = new TransactionEnvelope();
var transaction = ToXdr();
thisXdr.Tx = transaction;
var signatures = Signatures.ToArray();
thisXdr.Signatures = signatures;
return thisXdr;
}
public static TransactionEnvelope Decode(IByteReader stream)
{
TransactionEnvelope decodedTransactionEnvelope = new TransactionEnvelope();
decodedTransactionEnvelope.Tx = Transaction.Decode(stream);
int signaturessize = XdrEncoding.DecodeInt32(stream);
decodedTransactionEnvelope.Signatures = new DecoratedSignature[signaturessize];
for (int i = 0; i < signaturessize; i++)
{
decodedTransactionEnvelope.Signatures[i] = DecoratedSignature.Decode(stream);
}
return(decodedTransactionEnvelope);
}
public static TransactionEnvelope Decode(XdrDataInputStream stream)
{
var decodedTransactionEnvelope = new TransactionEnvelope();
decodedTransactionEnvelope.Tx = Transaction.Decode(stream);
var signaturessize = stream.ReadInt();
decodedTransactionEnvelope.Signatures = new DecoratedSignature[signaturessize];
for (var i = 0; i < signaturessize; i++)
{
decodedTransactionEnvelope.Signatures[i] = DecoratedSignature.Decode(stream);
}
return(decodedTransactionEnvelope);
}
/// <summary>
/// Generates TransactionEnvelope XDR object. This transaction MUST be signed before being useful
/// </summary>
/// <returns></returns>
public TransactionEnvelope ToUnsignedEnvelopeXdr()
{
if (Signatures.Count > 0)
{
throw new TooManySignaturesException("Transaction must not be signed. Use ToEnvelopeXDR.");
}
var thisXdr = new TransactionEnvelope();
var transaction = ToXdr();
thisXdr.Tx = transaction;
return(thisXdr);
}
public static TransactionSet Decode(XdrDataInputStream stream)
{
var decodedTransactionSet = new TransactionSet();
decodedTransactionSet.PreviousLedgerHash = Hash.Decode(stream);
var txssize = stream.ReadInt();
decodedTransactionSet.Txs = new TransactionEnvelope[txssize];
for (var i = 0; i < txssize; i++)
{
decodedTransactionSet.Txs[i] = TransactionEnvelope.Decode(stream);
}
return(decodedTransactionSet);
}
public static TransactionSet Decode(IByteReader stream)
{
TransactionSet decodedTransactionSet = new TransactionSet();
decodedTransactionSet.PreviousLedgerHash = Hash.Decode(stream);
int txssize = XdrEncoding.DecodeInt32(stream);
decodedTransactionSet.Txs = new TransactionEnvelope[txssize];
for (int i = 0; i < txssize; i++)
{
decodedTransactionSet.Txs[i] = TransactionEnvelope.Decode(stream);
}
return(decodedTransactionSet);
}
public void TestTransactionEnvelopeWithMemo()
{
var transactionEnvelopeToDecode = "AAAAACq1Ixcw1fchtF5aLTSw1zaYAYjb3WbBRd4jqYJKThB9AAAAZAA8tDoAAAALAAAAAAAAAAEAAAAZR29sZCBwYXltZW50IGZvciBzZXJ2aWNlcwAAAAAAAAEAAAAAAAAAAQAAAAARREGslec48mbJJygIwZoLvRtL6/gGL4ss2TOpnOUOhgAAAAFHT0xEAAAAACq1Ixcw1fchtF5aLTSw1zaYAYjb3WbBRd4jqYJKThB9AAAAADuaygAAAAAAAAAAAA==";
var bytes = Convert.FromBase64String(transactionEnvelopeToDecode);
var transactionEnvelope = TransactionEnvelope.Decode(new XdrDataInputStream(bytes));
Assert.AreEqual(1, transactionEnvelope.Tx.Operations.Length);
var expected = Encoding.UTF8.GetBytes(new[] { 'G', 'O', 'L', 'D' });
var actual = transactionEnvelope.Tx.Operations[0].Body.PaymentOp.Asset.AlphaNum4.AssetCode;
Assert.IsTrue(expected.SequenceEqual(actual));
}
private string CreateEnvelopeXdrBase64(StellarBase.Generated.Transaction tx, DecoratedSignature signature)
{
var txEnvelope = new TransactionEnvelope
{
Tx = tx,
Signatures = new[] { signature }
};
var writer = new ByteWriter();
TransactionEnvelope.Encode(writer, txEnvelope);
var data = writer.ToArray();
return(Convert.ToBase64String(data));
}
public PaymentOp GetFirstPaymentFromTransaction(TransactionDetails tx)
{
var xdr = Convert.FromBase64String(tx.EnvelopeXdr);
var reader = new ByteReader(xdr);
var txEnvelope = TransactionEnvelope.Decode(reader);
if (txEnvelope?.Tx?.Operations == null || txEnvelope.Tx.Operations.Length < 1 ||
txEnvelope.Tx.Operations[0].Body?.PaymentOp == null)
{
throw new HorizonApiException($"Failed to extract first payment operation from transaction. hash={tx.Hash}");
}
var paymentOp = txEnvelope.Tx.Operations[0].Body.PaymentOp;
return(paymentOp);
}
public void TestDecodeTxBody()
{
// pubnet - ledgerseq 5845058, txid d5ec6645d86cdcae8212cbe60feaefb8d6b1a8b7d11aeea590608b0863ace4de
var txBody = "AAAAAERmsKL73CyLV/HvjyQCERDXXpWE70Xhyb6MR5qPO3yQAAAAZAAIbkEAACD7AAAAAAAAAAN43bSwpXw8tSAhl7TBtQeOZTQAXwAAAAAAAAAAAAAAAAAAAAEAAAABAAAAAP1qe44j+i4uIT+arbD4QDQBt8ryEeJd7a0jskQ3nwDeAAAAAAAAAADdVhDVFrUiS/jPrRpblXY4bAW9u4hbRI2Hhw+2ATsFpQAAAAAtPWvAAAAAAAAAAAGPO3yQAAAAQHGWVHCBsjTyap/OY9JjPHmzWtN2Y2sL98aMERc/xJ3hcWz6kdQAwjlEhilItCyokDHCrvALZy3v/1TlaDqprA0=";
var bytes = Convert.FromBase64String(txBody);
GetDebugBytes(bytes);
var unused = new MemoryStream(bytes);
var transactionEnvelope = TransactionEnvelope.Decode(new XdrDataInputStream(bytes));
var uint64 = transactionEnvelope.Tx.SeqNum.InnerValue.InnerValue;
Assert.AreEqual(2373025265623291L, uint64);
}
public static Transaction FromEnvelopeXdr(TransactionEnvelope envelope)
{
{
switch (envelope.Discriminant.InnerValue)
{
case EnvelopeType.EnvelopeTypeEnum.ENVELOPE_TYPE_TX_V0:
return(FromEnvelopeXdrV0(envelope.V0));
case EnvelopeType.EnvelopeTypeEnum.ENVELOPE_TYPE_TX:
return(FromEnvelopeXdrV1(envelope.V1));
default:
throw new ArgumentException($"Invalid TransactionEnvelope: expected an ENVELOPE_TYPE_TX or ENVELOPE_TYPE_TX_V0 but received {envelope.Discriminant.InnerValue}");
}
}
}
public bool CheckSignature(string xdrBase64)
{
bool isSignOk = true;
try
{
var xdr = Convert.FromBase64String(xdrBase64);
var reader = new XdrDataInputStream(xdr);
var txEnvelope = TransactionEnvelope.Decode(reader);
}
catch (Exception e)
{
isSignOk = false;
}
return(isSignOk);
}
/// <summary>
/// Generates TransactionEnvelope XDR object. Transaction need to have at least one signature.
/// </summary>
/// <returns></returns>
public TransactionEnvelope ToEnvelopeXdr()
{
if (Signatures.Count == 0)
{
throw new NotEnoughSignaturesException(
"Transaction must be signed by at least one signer. Use transaction.sign().");
}
TransactionEnvelope thisXdr = new TransactionEnvelope();
xdr.Transaction transaction = ToXdr();
thisXdr.Tx = transaction;
DecoratedSignature[] signatures = Signatures.ToArray();
thisXdr.Signatures = signatures;
return(thisXdr);
}
public static TransactionBase FromEnvelopeXdr(TransactionEnvelope envelope)
{
switch (envelope.Discriminant.InnerValue)
{
case EnvelopeType.EnvelopeTypeEnum.ENVELOPE_TYPE_TX_V0:
return(Transaction.FromEnvelopeXdr(envelope));
case EnvelopeType.EnvelopeTypeEnum.ENVELOPE_TYPE_TX:
return(Transaction.FromEnvelopeXdr(envelope));
case EnvelopeType.EnvelopeTypeEnum.ENVELOPE_TYPE_TX_FEE_BUMP:
return(FeeBumpTransaction.FromEnvelopeXdr(envelope));
default:
throw new ArgumentException($"Unknown envelope type {envelope.Discriminant.InnerValue}");
}
}
public static void Encode(XdrDataOutputStream stream, TransactionEnvelope encodedTransactionEnvelope)
{
stream.WriteInt((int)encodedTransactionEnvelope.Discriminant.InnerValue);
switch (encodedTransactionEnvelope.Discriminant.InnerValue)
{
case EnvelopeType.EnvelopeTypeEnum.ENVELOPE_TYPE_TX_V0:
TransactionV0Envelope.Encode(stream, encodedTransactionEnvelope.V0);
break;
case EnvelopeType.EnvelopeTypeEnum.ENVELOPE_TYPE_TX:
TransactionV1Envelope.Encode(stream, encodedTransactionEnvelope.V1);
break;
case EnvelopeType.EnvelopeTypeEnum.ENVELOPE_TYPE_TX_FEE_BUMP:
FeeBumpTransactionEnvelope.Encode(stream, encodedTransactionEnvelope.FeeBump);
break;
}
}
public static TransactionEnvelope Decode(XdrDataInputStream stream)
{
TransactionEnvelope decodedTransactionEnvelope = new TransactionEnvelope();
EnvelopeType discriminant = EnvelopeType.Decode(stream);
decodedTransactionEnvelope.Discriminant = discriminant;
switch (decodedTransactionEnvelope.Discriminant.InnerValue)
{
case EnvelopeType.EnvelopeTypeEnum.ENVELOPE_TYPE_TX_V0:
decodedTransactionEnvelope.V0 = TransactionV0Envelope.Decode(stream);
break;
case EnvelopeType.EnvelopeTypeEnum.ENVELOPE_TYPE_TX:
decodedTransactionEnvelope.V1 = TransactionV1Envelope.Decode(stream);
break;
case EnvelopeType.EnvelopeTypeEnum.ENVELOPE_TYPE_TX_FEE_BUMP:
decodedTransactionEnvelope.FeeBump = FeeBumpTransactionEnvelope.Decode(stream);
break;
}
return(decodedTransactionEnvelope);
}
