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]); } }
/// <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); }