From 16a6c44c373cbac032988033d3ae3cf7597618c0 Mon Sep 17 00:00:00 2001 From: George Kudrayvtsev Date: Wed, 23 Mar 2022 12:43:41 -0700 Subject: [PATCH 01/19] Add first draft of new tx preconditions --- txnbuild/ledgerbounds.go | 24 +++++ txnbuild/preconditions.go | 154 +++++++++++++++++++++++++++++ txnbuild/preconditions_test.go | 173 +++++++++++++++++++++++++++++++++ txnbuild/transaction.go | 56 ++++++----- txnbuild/transaction_test.go | 8 +- 5 files changed, 384 insertions(+), 31 deletions(-) create mode 100644 txnbuild/ledgerbounds.go create mode 100644 txnbuild/preconditions.go create mode 100644 txnbuild/preconditions_test.go diff --git a/txnbuild/ledgerbounds.go b/txnbuild/ledgerbounds.go new file mode 100644 index 0000000000..a847e02e1b --- /dev/null +++ b/txnbuild/ledgerbounds.go @@ -0,0 +1,24 @@ +package txnbuild + +import "github.com/stellar/go/support/errors" + +// Ledgerbounds represent a transaction precondition that controls the ledger +// range for which a transaction is valid. +// +// Setting MaxLedger = 0 indicates there is no maximum ledger. +type Ledgerbounds struct { + MinLedger uint32 + MaxLedger uint32 +} + +func NewLedgerbounds(minLedger, maxLedger uint32) Ledgerbounds { + return Ledgerbounds{minLedger, maxLedger} +} + +func (lb *Ledgerbounds) Validate() error { + if lb.MaxLedger > 0 && lb.MaxLedger < lb.MinLedger { + return errors.New("invalid ledgerbound: max ledger < min ledger") + } + + return nil +} diff --git a/txnbuild/preconditions.go b/txnbuild/preconditions.go new file mode 100644 index 0000000000..9a5783bfbf --- /dev/null +++ b/txnbuild/preconditions.go @@ -0,0 +1,154 @@ +package txnbuild + +import ( + "github.com/stellar/go/support/errors" + "github.com/stellar/go/xdr" +) + +// Preconditions is a container for all transaction preconditions. +type Preconditions struct { + // Transaction is only valid during a certain time range. This is private + // because it should mirror the one set via TransactionParams, and this + // association should be done via `NewPreconditions()`. + timebounds *Timebounds + // Transaction is valid for ledger numbers n such that minLedger <= n < + // maxLedger (if maxLedger == 0, then only minLedger is checked) + Ledgerbounds *Ledgerbounds + // If nil, the transaction is only valid when sourceAccount's sequence + // number "N" is seqNum - 1. Otherwise, valid when N satisfies minSeqNum <= + // N < tx.seqNum. + MinSequenceNumber *int64 + // Transaction is valid if the current ledger time is at least + // minSequenceNumberAge greater than the source account's seqTime. + MinSequenceNumberAge xdr.Duration + // Transaction is valid if the current ledger number is at least + // minSequenceNumberLedgerGap greater than the source account's seqLedger. + MinSequenceNumberLedgerGap uint32 + // Transaction is valid if there is a signature corresponding to every + // Signer in this array, even if the signature is not otherwise required by + // the source account or operations. + ExtraSigners []xdr.SignerKey +} + +// NewPreconditions creates a set of preconditions with timebounds enabled +func NewPreconditions(timebounds *Timebounds) Preconditions { + cond := Preconditions{} + if err := cond.SetTimebounds(timebounds); err != nil { + panic(err) + } + return cond +} + +func NewPreconditionsFromTimebounds(minTime, maxTime int64) Preconditions { + tb := NewTimebounds(minTime, maxTime) + return NewPreconditions(&tb) +} + +// SetTimebounds enables the timebound precondition. +// +// Note that timebounds are a *required* precondition, but they're passed here +// by pointer in order to align with `TransactionParams.Timebound`. +func (cond *Preconditions) SetTimebounds(timebounds *Timebounds) error { + if cond.timebounds != nil && (cond.timebounds.MinTime != timebounds.MinTime || + cond.timebounds.MaxTime != timebounds.MaxTime) { + return errors.New("timebounds are already set") + } + + if err := timebounds.Validate(); err != nil { + return err + } + + if timebounds == nil { + return errors.New("timebounds are required") + } + + cond.timebounds = timebounds + return nil +} + +func (cond *Preconditions) Timebounds() Timebounds { + return *cond.timebounds +} + +// Validate ensures that all enabled preconditions are valid. +func (cond *Preconditions) Validate() error { + var err error + + if cond.timebounds == nil { + return errors.New("timebounds are required") + } + + if err = cond.timebounds.Validate(); err != nil { + return err + } + + if ok := cond.ValidateSigners(); !ok { + return errors.New("invalid signers") + } + + if cond.Ledgerbounds != nil { + err = cond.Ledgerbounds.Validate() + if err != nil { + return err + } + } + + return nil +} + +func (cond *Preconditions) ValidateSigners() bool { + return len(cond.ExtraSigners) <= 2 +} + +// HasV2Conditions determines whether or not this has conditions on top of +// the (required) timebound precondition. +func (cond *Preconditions) HasV2Conditions() bool { + return (cond.Ledgerbounds != nil || + cond.MinSequenceNumber != nil || + cond.MinSequenceNumberAge > xdr.Duration(0) || + cond.MinSequenceNumberLedgerGap > 0 || + len(cond.ExtraSigners) > 0) +} + +// BuildXDR will create a precondition structure that varies depending on +// whether or not there are additional preconditions besides timebounds (which +// are required). +func (cond *Preconditions) BuildXDR() xdr.Preconditions { + xdrCond := xdr.Preconditions{} + xdrTimeBounds := xdr.TimeBounds{ + MinTime: xdr.TimePoint(cond.timebounds.MinTime), + MaxTime: xdr.TimePoint(cond.timebounds.MaxTime), + } + + // Only build PRECOND_V2 structure if we need to + if cond.HasV2Conditions() { + xdrPrecond := xdr.PreconditionsV2{ + TimeBounds: &xdrTimeBounds, + MinSeqAge: cond.MinSequenceNumberAge, + MinSeqLedgerGap: xdr.Uint32(cond.MinSequenceNumberLedgerGap), + ExtraSigners: cond.ExtraSigners, + } + + // micro-optimization: if the ledgerbounds always succeed, omit them + if cond.Ledgerbounds != nil && !(cond.Ledgerbounds.MinLedger == 0 && + cond.Ledgerbounds.MaxLedger == 0) { + xdrPrecond.LedgerBounds = &xdr.LedgerBounds{ + MinLedger: xdr.Uint32(cond.Ledgerbounds.MinLedger), + MaxLedger: xdr.Uint32(cond.Ledgerbounds.MaxLedger), + } + } + + if cond.MinSequenceNumber != nil { + seqNum := xdr.SequenceNumber(*cond.MinSequenceNumber) + xdrPrecond.MinSeqNum = &seqNum + } + + xdrCond.Type = xdr.PreconditionTypePrecondV2 + xdrCond.V2 = &xdrPrecond + } else { + xdrCond.Type = xdr.PreconditionTypePrecondTime + xdrCond.TimeBounds = &xdrTimeBounds + } + + return xdrCond +} diff --git a/txnbuild/preconditions_test.go b/txnbuild/preconditions_test.go new file mode 100644 index 0000000000..ef7584e432 --- /dev/null +++ b/txnbuild/preconditions_test.go @@ -0,0 +1,173 @@ +package txnbuild + +import ( + "testing" + + "github.com/stellar/go/xdr" + "github.com/stretchr/testify/assert" +) + +var Signers = []xdr.SignerKey{ + xdr.MustSigner("GAOQJGUAB7NI7K7I62ORBXMN3J4SSWQUQ7FOEPSDJ322W2HMCNWPHXFB"), + xdr.MustSigner("GA7QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJVSGZ"), + xdr.MustSigner("PA7QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJUAAAAAQACAQDAQCQMBYIBEFAWDANBYHRAEISCMKBKFQXDAMRUGY4DUPB6IBZGM"), +} + +var ( + seqNum = int64(14) + xdrSeqNum = xdr.SequenceNumber(seqNum) + xdrCond = xdr.Preconditions{ + Type: xdr.PreconditionTypePrecondV2, + V2: &xdr.PreconditionsV2{ + TimeBounds: &xdr.TimeBounds{ + MinTime: xdr.TimePoint(27), + MaxTime: xdr.TimePoint(42), + }, + LedgerBounds: &xdr.LedgerBounds{ + MinLedger: xdr.Uint32(27), + MaxLedger: xdr.Uint32(42), + }, + MinSeqNum: &xdrSeqNum, + MinSeqAge: xdr.Duration(27), + MinSeqLedgerGap: xdr.Uint32(42), + ExtraSigners: Signers[:1], + }, + } + tb = NewTimebounds(27, 42) + pc = Preconditions{ + timebounds: &tb, + Ledgerbounds: &Ledgerbounds{27, 42}, + MinSequenceNumber: &seqNum, + MinSequenceNumberAge: xdr.Duration(27), + MinSequenceNumberLedgerGap: 42, + ExtraSigners: Signers[:1], + } +) + +// TestClassifyingPreconditions ensures that Preconditions will correctly +// differentiate V1 (timebounds-only) or V2 (all other) preconditions correctly. +func TestClassifyingPreconditions(t *testing.T) { + tbpc := NewPreconditions(&tb) + assert.False(t, (&Preconditions{}).HasV2Conditions()) + assert.False(t, tbpc.HasV2Conditions()) + assert.True(t, pc.HasV2Conditions()) +} + +// TestPreconditions ensures correct XDR is generated for a (non-exhaustive) +// handful of precondition combinations. +func TestPreconditions(t *testing.T) { + preconditionModifiers := []struct { + Name string + Modifier func() (xdr.Preconditions, Preconditions) + }{ + { + "unchanged", + func() (xdr.Preconditions, Preconditions) { + return xdrCond, pc + }, + }, + { + "only timebounds", + func() (xdr.Preconditions, Preconditions) { + tb := NewTimebounds(1, 2) + return xdr.Preconditions{ + Type: xdr.PreconditionTypePrecondTime, + TimeBounds: &xdr.TimeBounds{ + MinTime: xdr.TimePoint(1), + MaxTime: xdr.TimePoint(2), + }, + }, NewPreconditions(&tb) + }, + }, + { + "unbounded ledgerbounds", + func() (xdr.Preconditions, Preconditions) { + newCond, newPc := clone(xdrCond, pc) + newCond.V2.LedgerBounds.MaxLedger = 0 + newPc.Ledgerbounds.MaxLedger = 0 + return newCond, newPc + }, + }, + { + "nil ledgerbounds", + func() (xdr.Preconditions, Preconditions) { + newCond, newPc := clone(xdrCond, pc) + newCond.V2.LedgerBounds = nil + newPc.Ledgerbounds = nil + return newCond, newPc + }, + }, + { + "nil minSeq", + func() (xdr.Preconditions, Preconditions) { + newCond, newPc := clone(xdrCond, pc) + newCond.V2.MinSeqNum = nil + newPc.MinSequenceNumber = nil + return newCond, newPc + }, + }, + } + for _, testCase := range preconditionModifiers { + t.Run(testCase.Name, func(t *testing.T) { + xdrCond, precond := testCase.Modifier() + assert.NoError(t, precond.Validate()) + + expectedBytes, err := xdrCond.MarshalBinary() + assert.NoError(t, err) + + actualBytes, err := precond.BuildXDR().MarshalBinary() + assert.NoError(t, err) + assert.Equal(t, expectedBytes, actualBytes) + }) + } +} + +// TestPreconditionsValidation ensures that validation fails when necessary. +func TestPreconditionsValidation(t *testing.T) { + t.Run("too many signers", func(t *testing.T) { + pc.ExtraSigners = Signers + assert.Error(t, pc.Validate()) + }) +} + +func clone(pcXdr xdr.Preconditions, pc Preconditions) (xdr.Preconditions, Preconditions) { + return cloneXdrPreconditions(pcXdr), clonePreconditions(pc) +} + +func cloneXdrPreconditions(pc xdr.Preconditions) xdr.Preconditions { + binary, err := pc.MarshalBinary() + if err != nil { + panic(err) + } + + clone := xdr.Preconditions{} + if err = clone.UnmarshalBinary(binary); err != nil { + panic(err) + } + + return clone +} + +func clonePreconditions(precond Preconditions) Preconditions { + tb := NewTimebounds(precond.timebounds.MinTime, precond.timebounds.MaxTime) + cond := NewPreconditions(&tb) + if precond.Ledgerbounds != nil { + cond.Ledgerbounds = &Ledgerbounds{ + MinLedger: precond.Ledgerbounds.MinLedger, + MaxLedger: precond.Ledgerbounds.MaxLedger, + } + } + + if precond.MinSequenceNumber != nil { + cond.MinSequenceNumber = precond.MinSequenceNumber + } + + cond.MinSequenceNumberAge = precond.MinSequenceNumberAge + cond.MinSequenceNumberLedgerGap = precond.MinSequenceNumberLedgerGap + + if len(precond.ExtraSigners) > 0 { + cond.ExtraSigners = append(cond.ExtraSigners, precond.ExtraSigners...) + } + + return cond +} diff --git a/txnbuild/transaction.go b/txnbuild/transaction.go index d1e9c2dcd1..29855ac8e4 100644 --- a/txnbuild/transaction.go +++ b/txnbuild/transaction.go @@ -212,7 +212,7 @@ type Transaction struct { sourceAccount SimpleAccount operations []Operation memo Memo - timebounds Timebounds + preconditions Preconditions } // BaseFee returns the per operation fee for this transaction. @@ -242,7 +242,7 @@ func (t *Transaction) Memo() Memo { // Timebounds returns the Timebounds configured for this transaction. func (t *Transaction) Timebounds() Timebounds { - return t.timebounds + return t.preconditions.Timebounds() } // Operations returns the list of operations included in this transaction. @@ -770,11 +770,11 @@ func transactionFromParsedXDR(xdrEnv xdr.TransactionEnvelope) (*GenericTransacti }, operations: nil, memo: nil, - timebounds: Timebounds{}, } if timeBounds := xdrEnv.TimeBounds(); timeBounds != nil { - newTx.simple.timebounds = NewTimebounds(int64(timeBounds.MinTime), int64(timeBounds.MaxTime)) + newTx.simple.preconditions = NewPreconditionsFromTimebounds( + int64(timeBounds.MinTime), int64(timeBounds.MaxTime)) } newTx.simple.memo, err = memoFromXDR(xdrEnv.Memo()) @@ -797,23 +797,23 @@ func transactionFromParsedXDR(xdrEnv xdr.TransactionEnvelope) (*GenericTransacti // TransactionParams is a container for parameters // which are used to construct new Transaction instances type TransactionParams struct { - SourceAccount Account - IncrementSequenceNum bool - Operations []Operation - BaseFee int64 - Memo Memo - Timebounds Timebounds + SourceAccount Account + IncrementSequenceNum bool + Operations []Operation + BaseFee int64 + Memo Memo + Timebounds Timebounds + AdditionalPreconditions Preconditions } // NewTransaction returns a new Transaction instance func NewTransaction(params TransactionParams) (*Transaction, error) { - var sequence int64 - var err error - if params.SourceAccount == nil { return nil, errors.New("transaction has no source account") } + var sequence int64 + var err error if params.IncrementSequenceNum { sequence, err = params.SourceAccount.IncrementSequenceNumber() } else { @@ -823,15 +823,24 @@ func NewTransaction(params TransactionParams) (*Transaction, error) { return nil, errors.Wrap(err, "could not obtain account sequence") } + // Because both V1 and V2 preconditions allow timebounds, and we don't want + // to introduce a breaking change by dropping + // `TransactionParams.Timebounds`, nor require users to set up the + // `AdditionalPreconditions`, we need to coalesce the two values here. + err = params.AdditionalPreconditions.SetTimebounds(¶ms.Timebounds) + if err != nil { + return nil, errors.Wrap(err, "invalid timebounds") + } + tx := &Transaction{ baseFee: params.BaseFee, sourceAccount: SimpleAccount{ AccountID: params.SourceAccount.GetAccountID(), Sequence: sequence, }, - operations: params.Operations, - memo: params.Memo, - timebounds: params.Timebounds, + operations: params.Operations, + memo: params.Memo, + preconditions: params.AdditionalPreconditions, } var sourceAccount xdr.MuxedAccount if err = sourceAccount.SetAddress(tx.sourceAccount.AccountID); err != nil { @@ -854,10 +863,9 @@ func NewTransaction(params TransactionParams) (*Transaction, error) { } tx.maxFee = int64(lo) - // Check and set the timebounds - err = tx.timebounds.Validate() - if err != nil { - return nil, errors.Wrap(err, "invalid time bounds") + // Check that all preconditions are valid + if ok := tx.preconditions.Validate(); ok != nil { + return nil, errors.Wrap(err, "invalid preconditions") } envelope := xdr.TransactionEnvelope{ @@ -867,13 +875,7 @@ func NewTransaction(params TransactionParams) (*Transaction, error) { SourceAccount: sourceAccount, Fee: xdr.Uint32(tx.maxFee), SeqNum: xdr.SequenceNumber(sequence), - Cond: xdr.Preconditions{ - Type: xdr.PreconditionTypePrecondTime, - TimeBounds: &xdr.TimeBounds{ - MinTime: xdr.TimePoint(tx.timebounds.MinTime), - MaxTime: xdr.TimePoint(tx.timebounds.MaxTime), - }, - }, + Cond: tx.preconditions.BuildXDR(), }, Signatures: nil, }, diff --git a/txnbuild/transaction_test.go b/txnbuild/transaction_test.go index 24518ebcd3..285ee86934 100644 --- a/txnbuild/transaction_test.go +++ b/txnbuild/transaction_test.go @@ -26,7 +26,7 @@ func TestMissingTimebounds(t *testing.T) { BaseFee: MinBaseFee, }, ) - assert.EqualError(t, err, "invalid time bounds: timebounds must be constructed using NewTimebounds(), NewTimeout(), or NewInfiniteTimeout()") + assert.EqualError(t, err, "invalid timebounds: timebounds must be constructed using NewTimebounds(), NewTimeout(), or NewInfiniteTimeout()") } func TestTimebounds(t *testing.T) { @@ -42,9 +42,9 @@ func TestTimebounds(t *testing.T) { }, ) assert.NoError(t, err) - assert.Equal(t, tb, tx.timebounds) - assert.Equal(t, xdr.TimePoint(tb.MinTime), tx.envelope.V1.Tx.Cond.TimeBounds.MinTime) - assert.Equal(t, xdr.TimePoint(tb.MaxTime), tx.envelope.V1.Tx.Cond.TimeBounds.MaxTime) + assert.Equal(t, tb, tx.preconditions.Timebounds()) + assert.Equal(t, xdr.TimePoint(tb.MinTime), tx.envelope.TimeBounds().MinTime) + assert.Equal(t, xdr.TimePoint(tb.MaxTime), tx.envelope.TimeBounds().MaxTime) } func TestMissingSourceAccount(t *testing.T) { From 194b03bb24e834b45175ce7abaab67b2a014534d Mon Sep 17 00:00:00 2001 From: George Kudrayvtsev Date: Wed, 23 Mar 2022 13:20:34 -0700 Subject: [PATCH 02/19] Improve timebound precondition testing --- txnbuild/preconditions.go | 17 ++++++++--------- txnbuild/timebounds.go | 2 +- txnbuild/transaction.go | 12 ++++++++---- txnbuild/transaction_test.go | 37 +++++++++++++++++++++++++++++++++++- 4 files changed, 53 insertions(+), 15 deletions(-) diff --git a/txnbuild/preconditions.go b/txnbuild/preconditions.go index 9a5783bfbf..d780aab059 100644 --- a/txnbuild/preconditions.go +++ b/txnbuild/preconditions.go @@ -49,17 +49,20 @@ func NewPreconditionsFromTimebounds(minTime, maxTime int64) Preconditions { // Note that timebounds are a *required* precondition, but they're passed here // by pointer in order to align with `TransactionParams.Timebound`. func (cond *Preconditions) SetTimebounds(timebounds *Timebounds) error { - if cond.timebounds != nil && (cond.timebounds.MinTime != timebounds.MinTime || - cond.timebounds.MaxTime != timebounds.MaxTime) { - return errors.New("timebounds are already set") + if timebounds == nil { + return errors.New("timebounds are required") } if err := timebounds.Validate(); err != nil { return err } - if timebounds == nil { - return errors.New("timebounds are required") + if cond.timebounds != nil { + // only fail if they differ + if cond.timebounds.MinTime != timebounds.MinTime || + cond.timebounds.MaxTime != timebounds.MaxTime { + return errors.New("timebounds set twice") + } } cond.timebounds = timebounds @@ -74,10 +77,6 @@ func (cond *Preconditions) Timebounds() Timebounds { func (cond *Preconditions) Validate() error { var err error - if cond.timebounds == nil { - return errors.New("timebounds are required") - } - if err = cond.timebounds.Validate(); err != nil { return err } diff --git a/txnbuild/timebounds.go b/txnbuild/timebounds.go index ce1a0b66e7..ce4fc9397f 100644 --- a/txnbuild/timebounds.go +++ b/txnbuild/timebounds.go @@ -28,7 +28,7 @@ type Timebounds struct { // using a factory method. This is done to ensure that default Timebound structs (which have no limits) are not // valid - you must explicitly specifiy the Timebound you require. func (tb *Timebounds) Validate() error { - if !tb.wasBuilt { + if tb == nil || !tb.wasBuilt { return errors.New("timebounds must be constructed using NewTimebounds(), NewTimeout(), or NewInfiniteTimeout()") } if tb.MinTime < 0 { diff --git a/txnbuild/transaction.go b/txnbuild/transaction.go index 29855ac8e4..b2538fc948 100644 --- a/txnbuild/transaction.go +++ b/txnbuild/transaction.go @@ -827,9 +827,13 @@ func NewTransaction(params TransactionParams) (*Transaction, error) { // to introduce a breaking change by dropping // `TransactionParams.Timebounds`, nor require users to set up the // `AdditionalPreconditions`, we need to coalesce the two values here. - err = params.AdditionalPreconditions.SetTimebounds(¶ms.Timebounds) - if err != nil { - return nil, errors.Wrap(err, "invalid timebounds") + // + // TODO: Find a better way to determine if params.Timebounds was passed? + if params.Timebounds.wasBuilt { + err = params.AdditionalPreconditions.SetTimebounds(¶ms.Timebounds) + if err != nil { + return nil, errors.Wrap(err, "invalid timebounds") + } } tx := &Transaction{ @@ -864,7 +868,7 @@ func NewTransaction(params TransactionParams) (*Transaction, error) { tx.maxFee = int64(lo) // Check that all preconditions are valid - if ok := tx.preconditions.Validate(); ok != nil { + if err = tx.preconditions.Validate(); err != nil { return nil, errors.Wrap(err, "invalid preconditions") } diff --git a/txnbuild/transaction_test.go b/txnbuild/transaction_test.go index 285ee86934..f564997b3b 100644 --- a/txnbuild/transaction_test.go +++ b/txnbuild/transaction_test.go @@ -26,7 +26,7 @@ func TestMissingTimebounds(t *testing.T) { BaseFee: MinBaseFee, }, ) - assert.EqualError(t, err, "invalid timebounds: timebounds must be constructed using NewTimebounds(), NewTimeout(), or NewInfiniteTimeout()") + assert.EqualError(t, err, "invalid preconditions: timebounds must be constructed using NewTimebounds(), NewTimeout(), or NewInfiniteTimeout()") } func TestTimebounds(t *testing.T) { @@ -45,6 +45,41 @@ func TestTimebounds(t *testing.T) { assert.Equal(t, tb, tx.preconditions.Timebounds()) assert.Equal(t, xdr.TimePoint(tb.MinTime), tx.envelope.TimeBounds().MinTime) assert.Equal(t, xdr.TimePoint(tb.MaxTime), tx.envelope.TimeBounds().MaxTime) + + // Transactions with timebounds set and timebounds-only preconditions set + // should result in identical XDR. + cond := NewPreconditions(&tb) + tx2, err := NewTransaction( + TransactionParams{ + SourceAccount: &SimpleAccount{AccountID: kp0.Address(), Sequence: 1}, + Operations: []Operation{&BumpSequence{BumpTo: 0}}, + BaseFee: MinBaseFee, + + AdditionalPreconditions: cond, + }, + ) + assert.NoError(t, err) + + b1, err := tx.ToXDR().MarshalBinary() + assert.NoError(t, err) + + b2, err := tx2.ToXDR().MarshalBinary() + assert.NoError(t, err) + + assert.EqualValues(t, b1, b2) + + // Transactions built with both timebound options set should fail. + _, err = NewTransaction( + TransactionParams{ + SourceAccount: &SimpleAccount{AccountID: kp0.Address(), Sequence: 1}, + Operations: []Operation{&BumpSequence{BumpTo: 0}}, + BaseFee: MinBaseFee, + + AdditionalPreconditions: cond, + Timebounds: NewTimebounds(1, 2), + }, + ) + assert.EqualError(t, err, "invalid timebounds: timebounds set twice") } func TestMissingSourceAccount(t *testing.T) { From f52acac842a8d65fc5f977f07255bcdceb3c5a1a Mon Sep 17 00:00:00 2001 From: George Kudrayvtsev Date: Wed, 23 Mar 2022 13:33:33 -0700 Subject: [PATCH 03/19] Drop extra code, improve tests --- txnbuild/ledgerbounds.go | 9 ++---- txnbuild/transaction_test.go | 55 ++++++++++++++++-------------------- 2 files changed, 26 insertions(+), 38 deletions(-) diff --git a/txnbuild/ledgerbounds.go b/txnbuild/ledgerbounds.go index a847e02e1b..673100877d 100644 --- a/txnbuild/ledgerbounds.go +++ b/txnbuild/ledgerbounds.go @@ -3,18 +3,13 @@ package txnbuild import "github.com/stellar/go/support/errors" // Ledgerbounds represent a transaction precondition that controls the ledger -// range for which a transaction is valid. -// -// Setting MaxLedger = 0 indicates there is no maximum ledger. +// range for which a transaction is valid. Setting MaxLedger = 0 indicates there +// is no maximum ledger. type Ledgerbounds struct { MinLedger uint32 MaxLedger uint32 } -func NewLedgerbounds(minLedger, maxLedger uint32) Ledgerbounds { - return Ledgerbounds{minLedger, maxLedger} -} - func (lb *Ledgerbounds) Validate() error { if lb.MaxLedger > 0 && lb.MaxLedger < lb.MinLedger { return errors.New("invalid ledgerbound: max ledger < min ledger") diff --git a/txnbuild/transaction_test.go b/txnbuild/transaction_test.go index f564997b3b..dee1623ea8 100644 --- a/txnbuild/transaction_test.go +++ b/txnbuild/transaction_test.go @@ -31,16 +31,17 @@ func TestMissingTimebounds(t *testing.T) { func TestTimebounds(t *testing.T) { kp0 := newKeypair0() - tb := NewTimeout(300) - tx, err := NewTransaction( - TransactionParams{ - SourceAccount: &SimpleAccount{AccountID: kp0.Address(), Sequence: 1}, - Operations: []Operation{&BumpSequence{BumpTo: 0}}, - BaseFee: MinBaseFee, - Timebounds: tb, - }, - ) + + tp := TransactionParams{ + SourceAccount: &SimpleAccount{AccountID: kp0.Address(), Sequence: 1}, + Operations: []Operation{&BumpSequence{BumpTo: 0}}, + BaseFee: MinBaseFee, + } + + // Happy path: old timebound method used + tp.Timebounds = tb + tx, err := NewTransaction(tp) assert.NoError(t, err) assert.Equal(t, tb, tx.preconditions.Timebounds()) assert.Equal(t, xdr.TimePoint(tb.MinTime), tx.envelope.TimeBounds().MinTime) @@ -49,37 +50,29 @@ func TestTimebounds(t *testing.T) { // Transactions with timebounds set and timebounds-only preconditions set // should result in identical XDR. cond := NewPreconditions(&tb) - tx2, err := NewTransaction( - TransactionParams{ - SourceAccount: &SimpleAccount{AccountID: kp0.Address(), Sequence: 1}, - Operations: []Operation{&BumpSequence{BumpTo: 0}}, - BaseFee: MinBaseFee, - - AdditionalPreconditions: cond, - }, - ) + tp.Timebounds = Timebounds{} + tp.AdditionalPreconditions = cond + tx2, err := NewTransaction(tp) assert.NoError(t, err) + assert.Equal(t, tb, tx.preconditions.Timebounds()) b1, err := tx.ToXDR().MarshalBinary() assert.NoError(t, err) - b2, err := tx2.ToXDR().MarshalBinary() assert.NoError(t, err) - assert.EqualValues(t, b1, b2) - // Transactions built with both timebound options set should fail. - _, err = NewTransaction( - TransactionParams{ - SourceAccount: &SimpleAccount{AccountID: kp0.Address(), Sequence: 1}, - Operations: []Operation{&BumpSequence{BumpTo: 0}}, - BaseFee: MinBaseFee, - - AdditionalPreconditions: cond, - Timebounds: NewTimebounds(1, 2), - }, - ) + // Transactions built with both (and differing) ways to set a timebound + // precondition should fail... + tp.AdditionalPreconditions = cond + tp.Timebounds = NewTimebounds(1, 2) + _, err = NewTransaction(tp) assert.EqualError(t, err, "invalid timebounds: timebounds set twice") + + // ...but identical values should pass. + tp.Timebounds = *cond.timebounds + _, err = NewTransaction(tp) + assert.NoError(t, err) } func TestMissingSourceAccount(t *testing.T) { From 25ecc36371ff09821f1cde32edcb6ce4678865d9 Mon Sep 17 00:00:00 2001 From: George Kudrayvtsev Date: Wed, 23 Mar 2022 13:42:23 -0700 Subject: [PATCH 04/19] Add a way to compare timebounds --- txnbuild/timebounds.go | 6 ++++++ txnbuild/transaction.go | 8 +++----- 2 files changed, 9 insertions(+), 5 deletions(-) diff --git a/txnbuild/timebounds.go b/txnbuild/timebounds.go index ce4fc9397f..53a98a753d 100644 --- a/txnbuild/timebounds.go +++ b/txnbuild/timebounds.go @@ -48,6 +48,12 @@ func (tb *Timebounds) Validate() error { return nil } +func (tb Timebounds) Equals(other Timebounds) bool { + return tb.MinTime == other.MinTime && + tb.MaxTime == other.MaxTime && + tb.wasBuilt == other.wasBuilt +} + // NewTimebounds is a factory method that constructs a Timebounds object from a min and max time. // A Transaction cannot be built unless a Timebounds object is provided through a factory method. func NewTimebounds(minTime, maxTime int64) Timebounds { diff --git a/txnbuild/transaction.go b/txnbuild/transaction.go index b2538fc948..c8d2bbcffd 100644 --- a/txnbuild/transaction.go +++ b/txnbuild/transaction.go @@ -794,8 +794,8 @@ func transactionFromParsedXDR(xdrEnv xdr.TransactionEnvelope) (*GenericTransacti return newTx, nil } -// TransactionParams is a container for parameters -// which are used to construct new Transaction instances +// TransactionParams is a container for parameters which are used to construct +// new Transaction instances type TransactionParams struct { SourceAccount Account IncrementSequenceNum bool @@ -827,9 +827,7 @@ func NewTransaction(params TransactionParams) (*Transaction, error) { // to introduce a breaking change by dropping // `TransactionParams.Timebounds`, nor require users to set up the // `AdditionalPreconditions`, we need to coalesce the two values here. - // - // TODO: Find a better way to determine if params.Timebounds was passed? - if params.Timebounds.wasBuilt { + if !params.Timebounds.Equals(Timebounds{}) { err = params.AdditionalPreconditions.SetTimebounds(¶ms.Timebounds) if err != nil { return nil, errors.Wrap(err, "invalid timebounds") From 918fc4c5a9182c510e1331910f78084c411b7a96 Mon Sep 17 00:00:00 2001 From: George Kudrayvtsev Date: Wed, 23 Mar 2022 13:52:11 -0700 Subject: [PATCH 05/19] Improve timebound check, more tests --- txnbuild/preconditions.go | 2 +- txnbuild/timebounds.go | 6 ++---- txnbuild/transaction.go | 2 +- txnbuild/transaction_test.go | 24 ++++++++++++++++++++++++ 4 files changed, 28 insertions(+), 6 deletions(-) diff --git a/txnbuild/preconditions.go b/txnbuild/preconditions.go index d780aab059..2d453e1a79 100644 --- a/txnbuild/preconditions.go +++ b/txnbuild/preconditions.go @@ -128,7 +128,7 @@ func (cond *Preconditions) BuildXDR() xdr.Preconditions { ExtraSigners: cond.ExtraSigners, } - // micro-optimization: if the ledgerbounds always succeed, omit them + // micro-optimization: if the ledgerbounds will always succeed, omit them if cond.Ledgerbounds != nil && !(cond.Ledgerbounds.MinLedger == 0 && cond.Ledgerbounds.MaxLedger == 0) { xdrPrecond.LedgerBounds = &xdr.LedgerBounds{ diff --git a/txnbuild/timebounds.go b/txnbuild/timebounds.go index 53a98a753d..15b44dda89 100644 --- a/txnbuild/timebounds.go +++ b/txnbuild/timebounds.go @@ -48,10 +48,8 @@ func (tb *Timebounds) Validate() error { return nil } -func (tb Timebounds) Equals(other Timebounds) bool { - return tb.MinTime == other.MinTime && - tb.MaxTime == other.MaxTime && - tb.wasBuilt == other.wasBuilt +func (tb *Timebounds) IsEmpty() bool { + return tb == nil || *tb == Timebounds{} } // NewTimebounds is a factory method that constructs a Timebounds object from a min and max time. diff --git a/txnbuild/transaction.go b/txnbuild/transaction.go index c8d2bbcffd..66878b9939 100644 --- a/txnbuild/transaction.go +++ b/txnbuild/transaction.go @@ -827,7 +827,7 @@ func NewTransaction(params TransactionParams) (*Transaction, error) { // to introduce a breaking change by dropping // `TransactionParams.Timebounds`, nor require users to set up the // `AdditionalPreconditions`, we need to coalesce the two values here. - if !params.Timebounds.Equals(Timebounds{}) { + if !params.Timebounds.IsEmpty() { err = params.AdditionalPreconditions.SetTimebounds(¶ms.Timebounds) if err != nil { return nil, errors.Wrap(err, "invalid timebounds") diff --git a/txnbuild/transaction_test.go b/txnbuild/transaction_test.go index dee1623ea8..c9fc4201c0 100644 --- a/txnbuild/transaction_test.go +++ b/txnbuild/transaction_test.go @@ -75,6 +75,30 @@ func TestTimebounds(t *testing.T) { assert.NoError(t, err) } +func TestV2Preconditions(t *testing.T) { + kp0 := newKeypair0() + tb := NewTimeout(300) + + cond := NewPreconditions(&tb) + cond.Ledgerbounds = &Ledgerbounds{0, 1} + cond.MinSequenceNumber = nil + cond.MinSequenceNumberAge = xdr.Duration(10) + cond.MinSequenceNumberLedgerGap = 2 + assert.True(t, cond.HasV2Conditions()) + + tp := TransactionParams{ + SourceAccount: &SimpleAccount{AccountID: kp0.Address(), Sequence: 1}, + Operations: []Operation{&BumpSequence{BumpTo: 0}}, + BaseFee: MinBaseFee, + + AdditionalPreconditions: cond, + } + + tx, err := NewTransaction(tp) + assert.NoError(t, err) + assert.Equal(t, cond, tx.preconditions) +} + func TestMissingSourceAccount(t *testing.T) { _, err := NewTransaction(TransactionParams{}) assert.EqualError(t, err, "transaction has no source account") From d3b9e88b2d0294502fc13d0266848806a63ed9d8 Mon Sep 17 00:00:00 2001 From: George Kudrayvtsev Date: Wed, 23 Mar 2022 13:54:18 -0700 Subject: [PATCH 06/19] Absolutely elite Golang coding --- txnbuild/timebounds.go | 4 ---- txnbuild/transaction.go | 2 +- 2 files changed, 1 insertion(+), 5 deletions(-) diff --git a/txnbuild/timebounds.go b/txnbuild/timebounds.go index 15b44dda89..ce4fc9397f 100644 --- a/txnbuild/timebounds.go +++ b/txnbuild/timebounds.go @@ -48,10 +48,6 @@ func (tb *Timebounds) Validate() error { return nil } -func (tb *Timebounds) IsEmpty() bool { - return tb == nil || *tb == Timebounds{} -} - // NewTimebounds is a factory method that constructs a Timebounds object from a min and max time. // A Transaction cannot be built unless a Timebounds object is provided through a factory method. func NewTimebounds(minTime, maxTime int64) Timebounds { diff --git a/txnbuild/transaction.go b/txnbuild/transaction.go index 66878b9939..0c2a6415b9 100644 --- a/txnbuild/transaction.go +++ b/txnbuild/transaction.go @@ -827,7 +827,7 @@ func NewTransaction(params TransactionParams) (*Transaction, error) { // to introduce a breaking change by dropping // `TransactionParams.Timebounds`, nor require users to set up the // `AdditionalPreconditions`, we need to coalesce the two values here. - if !params.Timebounds.IsEmpty() { + if params.Timebounds != (Timebounds{}) { err = params.AdditionalPreconditions.SetTimebounds(¶ms.Timebounds) if err != nil { return nil, errors.Wrap(err, "invalid timebounds") From 59b6fc806f956b3155bcf96416e248f9293d1b44 Mon Sep 17 00:00:00 2001 From: George Kudrayvtsev Date: Wed, 23 Mar 2022 15:10:27 -0700 Subject: [PATCH 07/19] etc --- txnbuild/preconditions.go | 9 ++++----- txnbuild/transaction.go | 2 +- 2 files changed, 5 insertions(+), 6 deletions(-) diff --git a/txnbuild/preconditions.go b/txnbuild/preconditions.go index 2d453e1a79..f49b96acd0 100644 --- a/txnbuild/preconditions.go +++ b/txnbuild/preconditions.go @@ -39,15 +39,14 @@ func NewPreconditions(timebounds *Timebounds) Preconditions { return cond } -func NewPreconditionsFromTimebounds(minTime, maxTime int64) Preconditions { +func NewPreconditionsWithTimebounds(minTime, maxTime int64) Preconditions { tb := NewTimebounds(minTime, maxTime) return NewPreconditions(&tb) } -// SetTimebounds enables the timebound precondition. -// -// Note that timebounds are a *required* precondition, but they're passed here -// by pointer in order to align with `TransactionParams.Timebound`. +// SetTimebounds enables the timebound precondition. Note that timebounds are a +// *required* precondition, but they're passed here by pointer in order to align +// with `TransactionParams.Timebounds`. func (cond *Preconditions) SetTimebounds(timebounds *Timebounds) error { if timebounds == nil { return errors.New("timebounds are required") diff --git a/txnbuild/transaction.go b/txnbuild/transaction.go index 0c2a6415b9..ec2796c862 100644 --- a/txnbuild/transaction.go +++ b/txnbuild/transaction.go @@ -773,7 +773,7 @@ func transactionFromParsedXDR(xdrEnv xdr.TransactionEnvelope) (*GenericTransacti } if timeBounds := xdrEnv.TimeBounds(); timeBounds != nil { - newTx.simple.preconditions = NewPreconditionsFromTimebounds( + newTx.simple.preconditions = NewPreconditionsWithTimebounds( int64(timeBounds.MinTime), int64(timeBounds.MaxTime)) } From df7b4c2749d58cac1bf9f351b7a318ecd247ad5c Mon Sep 17 00:00:00 2001 From: George Kudrayvtsev Date: Thu, 24 Mar 2022 09:36:42 -0700 Subject: [PATCH 08/19] Remove global variables from tests: isolate to each case --- txnbuild/preconditions_test.go | 49 ++++++++++++++++++++-------------- 1 file changed, 29 insertions(+), 20 deletions(-) diff --git a/txnbuild/preconditions_test.go b/txnbuild/preconditions_test.go index ef7584e432..6870c20954 100644 --- a/txnbuild/preconditions_test.go +++ b/txnbuild/preconditions_test.go @@ -13,10 +13,24 @@ var Signers = []xdr.SignerKey{ xdr.MustSigner("PA7QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJUAAAAAQACAQDAQCQMBYIBEFAWDANBYHRAEISCMKBKFQXDAMRUGY4DUPB6IBZGM"), } -var ( - seqNum = int64(14) - xdrSeqNum = xdr.SequenceNumber(seqNum) - xdrCond = xdr.Preconditions{ +// TestClassifyingPreconditions ensures that Preconditions will correctly +// differentiate V1 (timebounds-only) or V2 (all other) preconditions correctly. +func TestClassifyingPreconditions(t *testing.T) { + tb := NewTimebounds(1, 2) + tbpc := NewPreconditions(&tb) + assert.False(t, (&Preconditions{}).HasV2Conditions()) + assert.False(t, tbpc.HasV2Conditions()) + + tbpc.MinSequenceNumberLedgerGap = 2 + assert.True(t, tbpc.HasV2Conditions()) +} + +// TestPreconditions ensures correct XDR is generated for a (non-exhaustive) +// handful of precondition combinations. +func TestPreconditions(t *testing.T) { + seqNum := int64(14) + xdrSeqNum := xdr.SequenceNumber(seqNum) + xdrCond := xdr.Preconditions{ Type: xdr.PreconditionTypePrecondV2, V2: &xdr.PreconditionsV2{ TimeBounds: &xdr.TimeBounds{ @@ -33,8 +47,8 @@ var ( ExtraSigners: Signers[:1], }, } - tb = NewTimebounds(27, 42) - pc = Preconditions{ + tb := NewTimebounds(27, 42) + pc := Preconditions{ timebounds: &tb, Ledgerbounds: &Ledgerbounds{27, 42}, MinSequenceNumber: &seqNum, @@ -42,20 +56,11 @@ var ( MinSequenceNumberLedgerGap: 42, ExtraSigners: Signers[:1], } -) -// TestClassifyingPreconditions ensures that Preconditions will correctly -// differentiate V1 (timebounds-only) or V2 (all other) preconditions correctly. -func TestClassifyingPreconditions(t *testing.T) { - tbpc := NewPreconditions(&tb) - assert.False(t, (&Preconditions{}).HasV2Conditions()) - assert.False(t, tbpc.HasV2Conditions()) - assert.True(t, pc.HasV2Conditions()) -} + // Note the pre-test invariant: xdrCond and pc match in structure. Each + // subtest clones these two structures, makes modifications, then ensures + // building the Preconditions version matches the XDR version. -// TestPreconditions ensures correct XDR is generated for a (non-exhaustive) -// handful of precondition combinations. -func TestPreconditions(t *testing.T) { preconditionModifiers := []struct { Name string Modifier func() (xdr.Preconditions, Preconditions) @@ -109,14 +114,15 @@ func TestPreconditions(t *testing.T) { } for _, testCase := range preconditionModifiers { t.Run(testCase.Name, func(t *testing.T) { - xdrCond, precond := testCase.Modifier() + xdrPrecond, precond := testCase.Modifier() assert.NoError(t, precond.Validate()) - expectedBytes, err := xdrCond.MarshalBinary() + expectedBytes, err := xdrPrecond.MarshalBinary() assert.NoError(t, err) actualBytes, err := precond.BuildXDR().MarshalBinary() assert.NoError(t, err) + assert.Equal(t, expectedBytes, actualBytes) }) } @@ -124,6 +130,9 @@ func TestPreconditions(t *testing.T) { // TestPreconditionsValidation ensures that validation fails when necessary. func TestPreconditionsValidation(t *testing.T) { + pc := NewPreconditionsWithTimebounds(27, 42) + pc.ExtraSigners = Signers + t.Run("too many signers", func(t *testing.T) { pc.ExtraSigners = Signers assert.Error(t, pc.Validate()) From 468e7de48982a96da3cebae4a27e726f86d1bd40 Mon Sep 17 00:00:00 2001 From: George Kudrayvtsev Date: Thu, 24 Mar 2022 09:53:21 -0700 Subject: [PATCH 09/19] Breaking change: move TransactionParams.Timebounds The field is now in TransactionParams.Preconditions.Timebounds --- clients/horizonclient/examples_test.go | 10 +- clients/horizonclient/main_test.go | 16 +- .../account_sign_signing_address_test.go | 60 ++-- .../webauth/internal/serve/token_test.go | 6 +- services/friendbot/init_friendbot.go | 2 +- services/friendbot/internal/minion.go | 2 +- .../integration/negative_seq_txsub_test.go | 2 +- .../internal/integration/sponsorship_test.go | 2 +- .../internal/test/integration/integration.go | 2 +- .../configureissuer/configureissuer.go | 4 +- .../internal/serve/api_tx_approve_test.go | 16 +- .../internal/serve/friendbot.go | 4 +- .../internal/serve/tx_approve.go | 2 +- .../internal/serve/tx_approve_test.go | 80 ++--- txnbuild/account_merge_test.go | 2 +- txnbuild/allow_trust_test.go | 4 +- txnbuild/bump_sequence_test.go | 2 +- txnbuild/change_trust_test.go | 6 +- txnbuild/clawback_test.go | 6 +- txnbuild/cmd/demo/operations/demo.go | 14 +- txnbuild/create_account_test.go | 4 +- txnbuild/create_claimable_balance_test.go | 2 +- txnbuild/create_passive_offer_test.go | 11 +- txnbuild/example_test.go | 59 ++-- txnbuild/fee_bump_test.go | 16 +- txnbuild/manage_buy_offer_test.go | 13 +- txnbuild/manage_data_test.go | 6 +- txnbuild/manage_offer_test.go | 13 +- txnbuild/operation_test.go | 4 +- txnbuild/path_payment_strict_send_test.go | 10 +- txnbuild/path_payment_test.go | 10 +- txnbuild/payment_test.go | 6 +- txnbuild/preconditions.go | 68 +--- txnbuild/preconditions_test.go | 18 +- txnbuild/signers_test.go | 35 +- txnbuild/transaction.go | 36 +- txnbuild/transaction_fee_test.go | 14 +- txnbuild/transaction_test.go | 323 ++++++++---------- 38 files changed, 409 insertions(+), 481 deletions(-) diff --git a/clients/horizonclient/examples_test.go b/clients/horizonclient/examples_test.go index 146bba681e..51387dc648 100644 --- a/clients/horizonclient/examples_test.go +++ b/clients/horizonclient/examples_test.go @@ -1100,7 +1100,7 @@ func ExampleClient_SubmitFeeBumpTransaction() { IncrementSequenceNum: false, Operations: []txnbuild.Operation{&op}, BaseFee: txnbuild.MinBaseFee, - Timebounds: txnbuild.NewInfiniteTimeout(), // Use a real timeout in production! + Preconditions: txnbuild.NewPreconditions(txnbuild.NewInfiniteTimeout()), // Use a real timeout in production! }, ) if err != nil { @@ -1154,7 +1154,7 @@ func ExampleClient_SubmitFeeBumpTransactionWithOptions() { IncrementSequenceNum: false, Operations: []txnbuild.Operation{&op}, BaseFee: txnbuild.MinBaseFee, - Timebounds: txnbuild.NewInfiniteTimeout(), // Use a real timeout in production! + Preconditions: txnbuild.NewPreconditions(txnbuild.NewInfiniteTimeout()), // Use a real timeout in production! }, ) if err != nil { @@ -1211,7 +1211,7 @@ func ExampleClient_SubmitTransaction() { IncrementSequenceNum: false, Operations: []txnbuild.Operation{&op}, BaseFee: txnbuild.MinBaseFee, - Timebounds: txnbuild.NewInfiniteTimeout(), // Use a real timeout in production! + Preconditions: txnbuild.NewPreconditions(txnbuild.NewInfiniteTimeout()), // Use a real timeout in production! }, ) if err != nil { @@ -1253,7 +1253,7 @@ func ExampleClient_SubmitTransactionWithOptions() { IncrementSequenceNum: false, Operations: []txnbuild.Operation{&op}, BaseFee: txnbuild.MinBaseFee, - Timebounds: txnbuild.NewInfiniteTimeout(), // Use a real timeout in production! + Preconditions: txnbuild.NewPreconditions(txnbuild.NewInfiniteTimeout()), // Use a real timeout in production! }, ) if err != nil { @@ -1295,7 +1295,7 @@ func ExampleClient_SubmitTransactionWithOptions_skip_memo_required_check() { IncrementSequenceNum: false, Operations: []txnbuild.Operation{&op}, BaseFee: txnbuild.MinBaseFee, - Timebounds: txnbuild.NewInfiniteTimeout(), // Use a real timeout in production! + Preconditions: txnbuild.NewPreconditions(txnbuild.NewInfiniteTimeout()), // Use a real timeout in production! }, ) if err != nil { diff --git a/clients/horizonclient/main_test.go b/clients/horizonclient/main_test.go index 9bd0d6f5ea..2c686147a7 100644 --- a/clients/horizonclient/main_test.go +++ b/clients/horizonclient/main_test.go @@ -146,7 +146,7 @@ func TestCheckMemoRequired(t *testing.T) { IncrementSequenceNum: true, Operations: tc.operations, BaseFee: txnbuild.MinBaseFee, - Timebounds: txnbuild.NewTimebounds(0, 10), + Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimebounds(0, 10)), }, ) tt.NoError(err) @@ -878,7 +878,7 @@ func TestSubmitTransactionRequest(t *testing.T) { IncrementSequenceNum: true, Operations: []txnbuild.Operation{&payment}, BaseFee: txnbuild.MinBaseFee, - Timebounds: txnbuild.NewTimebounds(0, 10), + Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimebounds(0, 10)), }, ) assert.NoError(t, err) @@ -946,7 +946,7 @@ func TestSubmitTransactionRequestMuxedAccounts(t *testing.T) { IncrementSequenceNum: true, Operations: []txnbuild.Operation{&payment}, BaseFee: txnbuild.MinBaseFee, - Timebounds: txnbuild.NewTimebounds(0, 10), + Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimebounds(0, 10)), }, ) assert.NoError(t, err) @@ -1006,7 +1006,7 @@ func TestSubmitFeeBumpTransaction(t *testing.T) { IncrementSequenceNum: true, Operations: []txnbuild.Operation{&payment}, BaseFee: txnbuild.MinBaseFee, - Timebounds: txnbuild.NewTimebounds(0, 10), + Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimebounds(0, 10)), }, ) assert.NoError(t, err) @@ -1075,7 +1075,7 @@ func TestSubmitTransactionWithOptionsRequest(t *testing.T) { IncrementSequenceNum: true, Operations: []txnbuild.Operation{&payment}, BaseFee: txnbuild.MinBaseFee, - Timebounds: txnbuild.NewTimebounds(0, 10), + Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimebounds(0, 10)), }, ) assert.NoError(t, err) @@ -1168,7 +1168,7 @@ func TestSubmitTransactionWithOptionsRequest(t *testing.T) { Operations: []txnbuild.Operation{&payment}, BaseFee: txnbuild.MinBaseFee, Memo: txnbuild.MemoText("HelloWorld"), - Timebounds: txnbuild.NewTimebounds(0, 10), + Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimebounds(0, 10)), }, ) assert.NoError(t, err) @@ -1202,7 +1202,7 @@ func TestSubmitFeeBumpTransactionWithOptions(t *testing.T) { IncrementSequenceNum: true, Operations: []txnbuild.Operation{&payment}, BaseFee: txnbuild.MinBaseFee, - Timebounds: txnbuild.NewTimebounds(0, 10), + Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimebounds(0, 10)), }, ) assert.NoError(t, err) @@ -1293,7 +1293,7 @@ func TestSubmitFeeBumpTransactionWithOptions(t *testing.T) { Operations: []txnbuild.Operation{&payment}, BaseFee: txnbuild.MinBaseFee, Memo: txnbuild.MemoText("HelloWorld"), - Timebounds: txnbuild.NewTimebounds(0, 10), + Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimebounds(0, 10)), }, ) assert.NoError(t, err) diff --git a/exp/services/recoverysigner/internal/serve/account_sign_signing_address_test.go b/exp/services/recoverysigner/internal/serve/account_sign_signing_address_test.go index 7246653230..65bd31e84d 100644 --- a/exp/services/recoverysigner/internal/serve/account_sign_signing_address_test.go +++ b/exp/services/recoverysigner/internal/serve/account_sign_signing_address_test.go @@ -349,8 +349,8 @@ func TestAccountSign_signingAddressAccountAuthenticatedButSigningAddressInvalid( }, }, }, - BaseFee: txnbuild.MinBaseFee, - Timebounds: txnbuild.NewTimebounds(0, 1), + BaseFee: txnbuild.MinBaseFee, + Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimebounds(0, 1)), }, ) require.NoError(t, err) @@ -411,8 +411,8 @@ func TestAccountSign_signingAddressAccountAuthenticatedOtherSignerSelected(t *te }, }, }, - BaseFee: txnbuild.MinBaseFee, - Timebounds: txnbuild.NewTimebounds(0, 1), + BaseFee: txnbuild.MinBaseFee, + Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimebounds(0, 1)), }, ) require.NoError(t, err) @@ -477,8 +477,8 @@ func TestAccountSign_signingAddressAccountAuthenticatedTxSourceAccountValid(t *t }, }, }, - BaseFee: txnbuild.MinBaseFee, - Timebounds: txnbuild.NewTimebounds(0, 1), + BaseFee: txnbuild.MinBaseFee, + Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimebounds(0, 1)), }, ) require.NoError(t, err) @@ -544,8 +544,8 @@ func TestAccountSign_signingAddressAccountAuthenticatedTxAndOpSourceAccountValid }, }, }, - BaseFee: txnbuild.MinBaseFee, - Timebounds: txnbuild.NewTimebounds(0, 1), + BaseFee: txnbuild.MinBaseFee, + Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimebounds(0, 1)), }, ) require.NoError(t, err) @@ -610,8 +610,8 @@ func TestAccountSign_signingAddressAccountAuthenticatedTxSourceAccountInvalid(t }, }, }, - BaseFee: txnbuild.MinBaseFee, - Timebounds: txnbuild.NewTimebounds(0, 1), + BaseFee: txnbuild.MinBaseFee, + Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimebounds(0, 1)), }, ) require.NoError(t, err) @@ -673,8 +673,8 @@ func TestAccountSign_signingAddressAccountAuthenticatedOpSourceAccountInvalid(t }, }, }, - BaseFee: txnbuild.MinBaseFee, - Timebounds: txnbuild.NewTimebounds(0, 1), + BaseFee: txnbuild.MinBaseFee, + Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimebounds(0, 1)), }, ) require.NoError(t, err) @@ -737,8 +737,8 @@ func TestAccountSign_signingAddressAccountAuthenticatedTxAndOpSourceAccountInval }, }, }, - BaseFee: txnbuild.MinBaseFee, - Timebounds: txnbuild.NewTimebounds(0, 1), + BaseFee: txnbuild.MinBaseFee, + Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimebounds(0, 1)), }, ) require.NoError(t, err) @@ -806,8 +806,8 @@ func TestAccountSign_signingAddressPhoneNumberOwnerAuthenticated(t *testing.T) { }, }, }, - BaseFee: txnbuild.MinBaseFee, - Timebounds: txnbuild.NewTimebounds(0, 1), + BaseFee: txnbuild.MinBaseFee, + Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimebounds(0, 1)), }, ) require.NoError(t, err) @@ -878,8 +878,8 @@ func TestAccountSign_signingAddressPhoneNumberOtherAuthenticated(t *testing.T) { }, }, }, - BaseFee: txnbuild.MinBaseFee, - Timebounds: txnbuild.NewTimebounds(0, 1), + BaseFee: txnbuild.MinBaseFee, + Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimebounds(0, 1)), }, ) require.NoError(t, err) @@ -950,8 +950,8 @@ func TestAccountSign_signingAddressEmailOwnerAuthenticated(t *testing.T) { }, }, }, - BaseFee: txnbuild.MinBaseFee, - Timebounds: txnbuild.NewTimebounds(0, 1), + BaseFee: txnbuild.MinBaseFee, + Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimebounds(0, 1)), }, ) require.NoError(t, err) @@ -1031,8 +1031,8 @@ func TestAccountSign_signingAddressEmailOwnerAuthenticatedOpSourceAccountIsAllow }, &txnbuild.EndSponsoringFutureReserves{}, }, - BaseFee: txnbuild.MinBaseFee, - Timebounds: txnbuild.NewTimebounds(0, 1), + BaseFee: txnbuild.MinBaseFee, + Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimebounds(0, 1)), }, ) require.NoError(t, err) @@ -1108,8 +1108,8 @@ func TestAccountSign_signingAddressEmailOwnerAuthenticatedOpSourceAccountInvalid }, &txnbuild.EndSponsoringFutureReserves{}, }, - BaseFee: txnbuild.MinBaseFee, - Timebounds: txnbuild.NewTimebounds(0, 1), + BaseFee: txnbuild.MinBaseFee, + Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimebounds(0, 1)), }, ) require.NoError(t, err) @@ -1175,8 +1175,8 @@ func TestAccountSign_signingAddressEmailOtherAuthenticated(t *testing.T) { }, }, }, - BaseFee: txnbuild.MinBaseFee, - Timebounds: txnbuild.NewTimebounds(0, 1), + BaseFee: txnbuild.MinBaseFee, + Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimebounds(0, 1)), }, ) require.NoError(t, err) @@ -1281,8 +1281,8 @@ func TestAccountSign_signingAddressRejectsFeeBumpTx(t *testing.T) { }, }, }, - BaseFee: txnbuild.MinBaseFee, - Timebounds: txnbuild.NewTimebounds(0, 1), + BaseFee: txnbuild.MinBaseFee, + Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimebounds(0, 1)), }, ) require.NoError(t, err) @@ -1351,8 +1351,8 @@ func TestAccountSign_signingAddressValidContentTypeForm(t *testing.T) { }, }, }, - BaseFee: txnbuild.MinBaseFee, - Timebounds: txnbuild.NewTimebounds(0, 1), + BaseFee: txnbuild.MinBaseFee, + Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimebounds(0, 1)), }, ) require.NoError(t, err) diff --git a/exp/services/webauth/internal/serve/token_test.go b/exp/services/webauth/internal/serve/token_test.go index ceb1c1e771..2134f14752 100644 --- a/exp/services/webauth/internal/serve/token_test.go +++ b/exp/services/webauth/internal/serve/token_test.go @@ -1136,9 +1136,9 @@ func TestToken_jsonInputNoWebAuthDomainSuccess(t *testing.T) { Value: []byte("ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg"), }, }, - BaseFee: txnbuild.MinBaseFee, - Memo: nil, - Timebounds: txnbuild.NewTimebounds(txMinTimebounds, txMaxTimebounds), + BaseFee: txnbuild.MinBaseFee, + Memo: nil, + Preconditions: txnbuild.NewPreconditionsWithTimebounds(txMinTimebounds, txMaxTimebounds), }, ) require.NoError(t, err) diff --git a/services/friendbot/init_friendbot.go b/services/friendbot/init_friendbot.go index ec8d1051cc..27ee56d6fc 100644 --- a/services/friendbot/init_friendbot.go +++ b/services/friendbot/init_friendbot.go @@ -120,7 +120,7 @@ func createMinionAccounts(botAccount internal.Account, botKeypair *keypair.Full, IncrementSequenceNum: true, Operations: ops, BaseFee: txnbuild.MinBaseFee, - Timebounds: txnbuild.NewTimeout(300), + Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimeout(300)), }, ) if err != nil { diff --git a/services/friendbot/internal/minion.go b/services/friendbot/internal/minion.go index 826826728e..707815c1fe 100644 --- a/services/friendbot/internal/minion.go +++ b/services/friendbot/internal/minion.go @@ -117,7 +117,7 @@ func (minion *Minion) makeTx(destAddress string) (string, error) { IncrementSequenceNum: true, Operations: []txnbuild.Operation{&createAccountOp}, BaseFee: minion.BaseFee, - Timebounds: txnbuild.NewInfiniteTimeout(), + Preconditions: txnbuild.NewPreconditions(txnbuild.NewInfiniteTimeout()), }, ) if err != nil { diff --git a/services/horizon/internal/integration/negative_seq_txsub_test.go b/services/horizon/internal/integration/negative_seq_txsub_test.go index 0abf2c7bcb..63a6c3ec20 100644 --- a/services/horizon/internal/integration/negative_seq_txsub_test.go +++ b/services/horizon/internal/integration/negative_seq_txsub_test.go @@ -55,7 +55,7 @@ func TestNegativeSequenceTxSubmission(t *testing.T) { SourceAccount: account, Operations: []txnbuild.Operation{&op2}, BaseFee: txnbuild.MinBaseFee, - Timebounds: txnbuild.NewInfiniteTimeout(), + Preconditions: txnbuild.NewPreconditions(txnbuild.NewInfiniteTimeout()), IncrementSequenceNum: false, } tx, err := txnbuild.NewTransaction(txParams) diff --git a/services/horizon/internal/integration/sponsorship_test.go b/services/horizon/internal/integration/sponsorship_test.go index 74a21dd385..c1675a0ead 100644 --- a/services/horizon/internal/integration/sponsorship_test.go +++ b/services/horizon/internal/integration/sponsorship_test.go @@ -311,7 +311,7 @@ func TestSponsorships(t *testing.T) { SourceAccount: newAccount, Operations: []txnbuild.Operation{preAuthOp}, BaseFee: txnbuild.MinBaseFee, - Timebounds: txnbuild.NewInfiniteTimeout(), + Preconditions: txnbuild.NewPreconditions(txnbuild.NewInfiniteTimeout()), IncrementSequenceNum: true, } preaAuthTx, err := txnbuild.NewTransaction(txParams) diff --git a/services/horizon/internal/test/integration/integration.go b/services/horizon/internal/test/integration/integration.go index bd7de611a9..60d11dae4f 100644 --- a/services/horizon/internal/test/integration/integration.go +++ b/services/horizon/internal/test/integration/integration.go @@ -694,7 +694,7 @@ func (i *Test) CreateSignedTransaction( SourceAccount: source, Operations: ops, BaseFee: txnbuild.MinBaseFee, - Timebounds: txnbuild.NewInfiniteTimeout(), + Preconditions: txnbuild.NewPreconditions(txnbuild.NewInfiniteTimeout()), IncrementSequenceNum: true, } diff --git a/services/regulated-assets-approval-server/internal/configureissuer/configureissuer.go b/services/regulated-assets-approval-server/internal/configureissuer/configureissuer.go index 611c92448d..acbe665f1e 100644 --- a/services/regulated-assets-approval-server/internal/configureissuer/configureissuer.go +++ b/services/regulated-assets-approval-server/internal/configureissuer/configureissuer.go @@ -119,8 +119,8 @@ func setup(opts Options, hClient horizonclient.ClientInterface) error { SourceAccount: trustorKP.Address(), }, }, - BaseFee: 300, - Timebounds: txnbuild.NewTimeout(300), + BaseFee: 300, + Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimeout(300)), }) if err != nil { return errors.Wrap(err, "building transaction") diff --git a/services/regulated-assets-approval-server/internal/serve/api_tx_approve_test.go b/services/regulated-assets-approval-server/internal/serve/api_tx_approve_test.go index bdba6a9825..7e4cee2041 100644 --- a/services/regulated-assets-approval-server/internal/serve/api_tx_approve_test.go +++ b/services/regulated-assets-approval-server/internal/serve/api_tx_approve_test.go @@ -114,8 +114,8 @@ func TestAPI_txApprove_revised(t *testing.T) { Asset: assetGOAT, }, }, - BaseFee: txnbuild.MinBaseFee, - Timebounds: txnbuild.NewInfiniteTimeout(), + BaseFee: txnbuild.MinBaseFee, + Preconditions: txnbuild.NewPreconditions(txnbuild.NewInfiniteTimeout()), }, ) require.NoError(t, err) @@ -234,8 +234,8 @@ func TestAPI_txAprove_actionRequired(t *testing.T) { Asset: assetGOAT, }, }, - BaseFee: txnbuild.MinBaseFee, - Timebounds: txnbuild.NewInfiniteTimeout(), + BaseFee: txnbuild.MinBaseFee, + Preconditions: txnbuild.NewPreconditions(txnbuild.NewInfiniteTimeout()), }, ) require.NoError(t, err) @@ -327,8 +327,8 @@ func TestAPI_txAprove_actionRequiredFlow(t *testing.T) { Asset: assetGOAT, }, }, - BaseFee: txnbuild.MinBaseFee, - Timebounds: txnbuild.NewInfiniteTimeout(), + BaseFee: txnbuild.MinBaseFee, + Preconditions: txnbuild.NewPreconditions(txnbuild.NewInfiniteTimeout()), }, ) require.NoError(t, err) @@ -538,8 +538,8 @@ func TestAPI_txApprove_success(t *testing.T) { SourceAccount: issuerKP.Address(), }, }, - BaseFee: 300, - Timebounds: txnbuild.NewTimeout(300), + BaseFee: 300, + Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimeout(300)), }) require.NoError(t, err) txe, err := tx.Base64() diff --git a/services/regulated-assets-approval-server/internal/serve/friendbot.go b/services/regulated-assets-approval-server/internal/serve/friendbot.go index 6da2936461..8f3ccdfeb0 100644 --- a/services/regulated-assets-approval-server/internal/serve/friendbot.go +++ b/services/regulated-assets-approval-server/internal/serve/friendbot.go @@ -157,8 +157,8 @@ func (h friendbotHandler) topUpAccountWithRegulatedAsset(ctx context.Context, in Authorize: false, }, }, - BaseFee: 300, - Timebounds: txnbuild.NewTimeout(300), + BaseFee: 300, + Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimeout(300)), }) if err != nil { err = errors.Wrap(err, "building transaction") diff --git a/services/regulated-assets-approval-server/internal/serve/tx_approve.go b/services/regulated-assets-approval-server/internal/serve/tx_approve.go index 47b82ae83c..121e008a84 100644 --- a/services/regulated-assets-approval-server/internal/serve/tx_approve.go +++ b/services/regulated-assets-approval-server/internal/serve/tx_approve.go @@ -231,7 +231,7 @@ func (h txApproveHandler) txApprove(ctx context.Context, in txApproveRequest) (r IncrementSequenceNum: true, Operations: revisedOperations, BaseFee: 300, - Timebounds: txnbuild.NewTimeout(300), + Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimeout(300)), }) if err != nil { return nil, errors.Wrap(err, "building transaction") diff --git a/services/regulated-assets-approval-server/internal/serve/tx_approve_test.go b/services/regulated-assets-approval-server/internal/serve/tx_approve_test.go index 1b8a19aa94..53b4dd57e1 100644 --- a/services/regulated-assets-approval-server/internal/serve/tx_approve_test.go +++ b/services/regulated-assets-approval-server/internal/serve/tx_approve_test.go @@ -143,7 +143,7 @@ func TestTxApproveHandler_validateInput(t *testing.T) { Sequence: "1", }, IncrementSequenceNum: true, - Timebounds: txnbuild.NewInfiniteTimeout(), + Preconditions: txnbuild.NewPreconditions(txnbuild.NewInfiniteTimeout()), BaseFee: 300, Operations: []txnbuild.Operation{ &txnbuild.Payment{ @@ -169,7 +169,7 @@ func TestTxApproveHandler_validateInput(t *testing.T) { Sequence: "1", }, IncrementSequenceNum: true, - Timebounds: txnbuild.NewInfiniteTimeout(), + Preconditions: txnbuild.NewPreconditions(txnbuild.NewInfiniteTimeout()), BaseFee: 300, Operations: []txnbuild.Operation{ &txnbuild.BumpSequence{}, @@ -197,7 +197,7 @@ func TestTxApproveHandler_validateInput(t *testing.T) { Sequence: "1", }, IncrementSequenceNum: true, - Timebounds: txnbuild.NewInfiniteTimeout(), + Preconditions: txnbuild.NewPreconditions(txnbuild.NewInfiniteTimeout()), BaseFee: 300, Operations: []txnbuild.Operation{ &txnbuild.Payment{ @@ -371,8 +371,8 @@ func TestTxApproveHandler_txApprove_rejected(t *testing.T) { Asset: assetGOAT, }, }, - BaseFee: txnbuild.MinBaseFee, - Timebounds: txnbuild.NewInfiniteTimeout(), + BaseFee: txnbuild.MinBaseFee, + Preconditions: txnbuild.NewPreconditions(txnbuild.NewInfiniteTimeout()), }, ) require.NoError(t, err) @@ -394,8 +394,8 @@ func TestTxApproveHandler_txApprove_rejected(t *testing.T) { Operations: []txnbuild.Operation{ &txnbuild.BumpSequence{}, }, - BaseFee: txnbuild.MinBaseFee, - Timebounds: txnbuild.NewInfiniteTimeout(), + BaseFee: txnbuild.MinBaseFee, + Preconditions: txnbuild.NewPreconditions(txnbuild.NewInfiniteTimeout()), }, ) require.NoError(t, err) @@ -424,8 +424,8 @@ func TestTxApproveHandler_txApprove_rejected(t *testing.T) { }, }, }, - BaseFee: txnbuild.MinBaseFee, - Timebounds: txnbuild.NewInfiniteTimeout(), + BaseFee: txnbuild.MinBaseFee, + Preconditions: txnbuild.NewPreconditions(txnbuild.NewInfiniteTimeout()), }, ) require.NoError(t, err) @@ -454,8 +454,8 @@ func TestTxApproveHandler_txApprove_rejected(t *testing.T) { }, }, }, - BaseFee: txnbuild.MinBaseFee, - Timebounds: txnbuild.NewInfiniteTimeout(), + BaseFee: txnbuild.MinBaseFee, + Preconditions: txnbuild.NewPreconditions(txnbuild.NewInfiniteTimeout()), }, ) require.NoError(t, err) @@ -481,8 +481,8 @@ func TestTxApproveHandler_txApprove_rejected(t *testing.T) { Asset: assetGOAT, }, }, - BaseFee: txnbuild.MinBaseFee, - Timebounds: txnbuild.NewInfiniteTimeout(), + BaseFee: txnbuild.MinBaseFee, + Preconditions: txnbuild.NewPreconditions(txnbuild.NewInfiniteTimeout()), }, ) require.NoError(t, err) @@ -568,8 +568,8 @@ func TestTxApproveHandler_txApprove_success(t *testing.T) { SourceAccount: issuerKP.Address(), }, }, - BaseFee: txnbuild.MinBaseFee, - Timebounds: txnbuild.NewInfiniteTimeout(), + BaseFee: txnbuild.MinBaseFee, + Preconditions: txnbuild.NewPreconditions(txnbuild.NewInfiniteTimeout()), }, ) require.NoError(t, err) @@ -630,8 +630,8 @@ func TestTxApproveHandler_txApprove_actionRequired(t *testing.T) { Asset: assetGOAT, }, }, - BaseFee: txnbuild.MinBaseFee, - Timebounds: txnbuild.NewInfiniteTimeout(), + BaseFee: txnbuild.MinBaseFee, + Preconditions: txnbuild.NewPreconditions(txnbuild.NewInfiniteTimeout()), }, ) require.NoError(t, err) @@ -706,8 +706,8 @@ func TestTxApproveHandler_txApprove_revised(t *testing.T) { Asset: assetGOAT, }, }, - BaseFee: txnbuild.MinBaseFee, - Timebounds: txnbuild.NewInfiniteTimeout(), + BaseFee: txnbuild.MinBaseFee, + Preconditions: txnbuild.NewPreconditions(txnbuild.NewInfiniteTimeout()), }, ) require.NoError(t, err) @@ -784,8 +784,8 @@ func TestValidateTransactionOperationsForSuccess(t *testing.T) { Asset: assetGOAT, }, }, - BaseFee: 300, - Timebounds: txnbuild.NewTimeout(300), + BaseFee: 300, + Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimeout(300)), }) require.NoError(t, err) @@ -808,8 +808,8 @@ func TestValidateTransactionOperationsForSuccess(t *testing.T) { &txnbuild.BumpSequence{}, &txnbuild.BumpSequence{}, }, - BaseFee: 300, - Timebounds: txnbuild.NewTimeout(300), + BaseFee: 300, + Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimeout(300)), }) require.NoError(t, err) @@ -837,8 +837,8 @@ func TestValidateTransactionOperationsForSuccess(t *testing.T) { &txnbuild.BumpSequence{}, &txnbuild.BumpSequence{}, }, - BaseFee: 300, - Timebounds: txnbuild.NewTimeout(300), + BaseFee: 300, + Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimeout(300)), }) require.NoError(t, err) @@ -886,8 +886,8 @@ func TestValidateTransactionOperationsForSuccess(t *testing.T) { SourceAccount: issuerKP.Address(), }, }, - BaseFee: 300, - Timebounds: txnbuild.NewTimeout(300), + BaseFee: 300, + Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimeout(300)), }) require.NoError(t, err) @@ -935,8 +935,8 @@ func TestValidateTransactionOperationsForSuccess(t *testing.T) { SourceAccount: issuerKP.Address(), }, }, - BaseFee: 300, - Timebounds: txnbuild.NewTimeout(300), + BaseFee: 300, + Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimeout(300)), }) require.NoError(t, err) @@ -1001,8 +1001,8 @@ func TestTxApproveHandler_handleSuccessResponseIfNeeded_revisable(t *testing.T) Asset: assetGOAT, }, }, - BaseFee: 300, - Timebounds: txnbuild.NewTimeout(300), + BaseFee: 300, + Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimeout(300)), }) require.NoError(t, err) @@ -1065,8 +1065,8 @@ func TestTxApproveHandler_handleSuccessResponseIfNeeded_rejected(t *testing.T) { &txnbuild.BumpSequence{}, &txnbuild.BumpSequence{}, }, - BaseFee: 300, - Timebounds: txnbuild.NewTimeout(300), + BaseFee: 300, + Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimeout(300)), }) require.NoError(t, err) @@ -1113,8 +1113,8 @@ func TestTxApproveHandler_handleSuccessResponseIfNeeded_rejected(t *testing.T) { SourceAccount: issuerKP.Address(), }, }, - BaseFee: 300, - Timebounds: txnbuild.NewTimeout(300), + BaseFee: 300, + Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimeout(300)), }) require.NoError(t, err) @@ -1163,7 +1163,7 @@ func TestTxApproveHandler_handleSuccessResponseIfNeeded_rejected(t *testing.T) { IncrementSequenceNum: true, Operations: compliantOps, BaseFee: 300, - Timebounds: txnbuild.NewTimeout(300), + Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimeout(300)), }) require.NoError(t, err) @@ -1246,8 +1246,8 @@ func TestTxApproveHandler_handleSuccessResponseIfNeeded_actionRequired(t *testin SourceAccount: issuerKP.Address(), }, }, - BaseFee: 300, - Timebounds: txnbuild.NewTimeout(300), + BaseFee: 300, + Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimeout(300)), }) require.NoError(t, err) @@ -1385,8 +1385,8 @@ func TestTxApproveHandler_handleSuccessResponseIfNeeded_success(t *testing.T) { SourceAccount: issuerKP.Address(), }, }, - BaseFee: 300, - Timebounds: txnbuild.NewTimeout(300), + BaseFee: 300, + Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimeout(300)), }) require.NoError(t, err) diff --git a/txnbuild/account_merge_test.go b/txnbuild/account_merge_test.go index 72cf9027ce..7c75928726 100644 --- a/txnbuild/account_merge_test.go +++ b/txnbuild/account_merge_test.go @@ -18,7 +18,7 @@ func TestAccountMergeValidate(t *testing.T) { TransactionParams{ SourceAccount: &sourceAccount, Operations: []Operation{&accountMerge}, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), BaseFee: MinBaseFee, }, ) diff --git a/txnbuild/allow_trust_test.go b/txnbuild/allow_trust_test.go index 607e58a81b..77901557b1 100644 --- a/txnbuild/allow_trust_test.go +++ b/txnbuild/allow_trust_test.go @@ -22,7 +22,7 @@ func TestAllowTrustValidateAsset(t *testing.T) { TransactionParams{ SourceAccount: &sourceAccount, Operations: []Operation{&allowTrust}, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), BaseFee: MinBaseFee, }, ) @@ -48,7 +48,7 @@ func TestAllowTrustValidateTrustor(t *testing.T) { TransactionParams{ SourceAccount: &sourceAccount, Operations: []Operation{&allowTrust}, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), BaseFee: MinBaseFee, }, ) diff --git a/txnbuild/bump_sequence_test.go b/txnbuild/bump_sequence_test.go index 067cdd0b8f..24dfa85f59 100644 --- a/txnbuild/bump_sequence_test.go +++ b/txnbuild/bump_sequence_test.go @@ -18,7 +18,7 @@ func TestBumpSequenceValidate(t *testing.T) { TransactionParams{ SourceAccount: &sourceAccount, Operations: []Operation{&bumpSequence}, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), BaseFee: MinBaseFee, }, ) diff --git a/txnbuild/change_trust_test.go b/txnbuild/change_trust_test.go index 9ba0c38ec4..23f4ace36f 100644 --- a/txnbuild/change_trust_test.go +++ b/txnbuild/change_trust_test.go @@ -21,7 +21,7 @@ func TestChangeTrustMaxLimit(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&changeTrust}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, network.TestNetworkPassphrase, kp0, @@ -46,7 +46,7 @@ func TestChangeTrustValidateInvalidAsset(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&changeTrust}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) if assert.Error(t, err) { @@ -70,7 +70,7 @@ func TestChangeTrustValidateInvalidLimit(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&changeTrust}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) if assert.Error(t, err) { diff --git a/txnbuild/clawback_test.go b/txnbuild/clawback_test.go index dab757c5a3..e9c558b9cb 100644 --- a/txnbuild/clawback_test.go +++ b/txnbuild/clawback_test.go @@ -22,7 +22,7 @@ func TestClawbackValidateFrom(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&clawback}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) if assert.Error(t, err) { @@ -47,7 +47,7 @@ func TestClawbackValidateAmount(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&clawback}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) if assert.Error(t, err) { @@ -72,7 +72,7 @@ func TestClawbackValidateAsset(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&clawback}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) if assert.Error(t, err) { diff --git a/txnbuild/cmd/demo/operations/demo.go b/txnbuild/cmd/demo/operations/demo.go index 9621773603..0450a6b096 100644 --- a/txnbuild/cmd/demo/operations/demo.go +++ b/txnbuild/cmd/demo/operations/demo.go @@ -215,7 +215,7 @@ func bumpSequence(source *hProtocol.Account, seqNum int64, signer Account) (stri IncrementSequenceNum: true, Operations: []txnbuild.Operation{&bumpSequenceOp}, BaseFee: txnbuild.MinBaseFee, - Timebounds: txnbuild.NewTimeout(300), + Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimeout(300)), }, ) if err != nil { @@ -245,7 +245,7 @@ func createAccount(source *hProtocol.Account, dest string, signer Account) (stri IncrementSequenceNum: true, Operations: []txnbuild.Operation{&createAccountOp}, BaseFee: txnbuild.MinBaseFee, - Timebounds: txnbuild.NewTimeout(300), + Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimeout(300)), }, ) if err != nil { @@ -274,7 +274,7 @@ func deleteData(source *hProtocol.Account, dataKey string, signer Account) (stri IncrementSequenceNum: true, Operations: []txnbuild.Operation{&manageDataOp}, BaseFee: txnbuild.MinBaseFee, - Timebounds: txnbuild.NewTimeout(300), + Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimeout(300)), }, ) if err != nil { @@ -305,7 +305,7 @@ func payment(source *hProtocol.Account, dest, amount string, asset txnbuild.Asse IncrementSequenceNum: true, Operations: []txnbuild.Operation{&paymentOp}, BaseFee: txnbuild.MinBaseFee, - Timebounds: txnbuild.NewTimeout(300), + Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimeout(300)), }, ) if err != nil { @@ -332,7 +332,7 @@ func deleteTrustline(source *hProtocol.Account, asset txnbuild.ChangeTrustAsset, IncrementSequenceNum: true, Operations: []txnbuild.Operation{&deleteTrustline}, BaseFee: txnbuild.MinBaseFee, - Timebounds: txnbuild.NewTimeout(300), + Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimeout(300)), }, ) if err != nil { @@ -362,7 +362,7 @@ func deleteOffer(source *hProtocol.Account, offerID int64, signer Account) (stri IncrementSequenceNum: true, Operations: []txnbuild.Operation{&deleteOffer}, BaseFee: txnbuild.MinBaseFee, - Timebounds: txnbuild.NewTimeout(300), + Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimeout(300)), }, ) if err != nil { @@ -391,7 +391,7 @@ func mergeAccount(source *hProtocol.Account, destAddress string, signer Account) IncrementSequenceNum: true, Operations: []txnbuild.Operation{&accountMerge}, BaseFee: txnbuild.MinBaseFee, - Timebounds: txnbuild.NewTimeout(300), + Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimeout(300)), }, ) if err != nil { diff --git a/txnbuild/create_account_test.go b/txnbuild/create_account_test.go index b715dca70d..a35df0426b 100644 --- a/txnbuild/create_account_test.go +++ b/txnbuild/create_account_test.go @@ -21,7 +21,7 @@ func TestCreateAccountValidateDestination(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&createAccount}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) if assert.Error(t, err) { @@ -45,7 +45,7 @@ func TestCreateAccountValidateAmount(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&createAccount}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) diff --git a/txnbuild/create_claimable_balance_test.go b/txnbuild/create_claimable_balance_test.go index d6516c7983..d35377fc34 100644 --- a/txnbuild/create_claimable_balance_test.go +++ b/txnbuild/create_claimable_balance_test.go @@ -78,7 +78,7 @@ func TestClaimableBalanceID(t *testing.T) { SourceAccount: &aAccount, IncrementSequenceNum: true, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), Operations: []Operation{&claimableBalanceEntry}, }, ) diff --git a/txnbuild/create_passive_offer_test.go b/txnbuild/create_passive_offer_test.go index d4d0efbea4..7d1615d00d 100644 --- a/txnbuild/create_passive_offer_test.go +++ b/txnbuild/create_passive_offer_test.go @@ -1,9 +1,10 @@ package txnbuild import ( - "github.com/stellar/go/xdr" "testing" + "github.com/stellar/go/xdr" + "github.com/stretchr/testify/assert" ) @@ -24,7 +25,7 @@ func TestCreatePassiveSellOfferValidateBuyingAsset(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&createPassiveOffer}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) if assert.Error(t, err) { @@ -51,7 +52,7 @@ func TestCreatePassiveSellOfferValidateSellingAsset(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&createPassiveOffer}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) if assert.Error(t, err) { @@ -78,7 +79,7 @@ func TestCreatePassiveSellOfferValidateAmount(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&createPassiveOffer}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) if assert.Error(t, err) { @@ -105,7 +106,7 @@ func TestCreatePassiveSellOfferValidatePrice(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&createPassiveOffer}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) if assert.Error(t, err) { diff --git a/txnbuild/example_test.go b/txnbuild/example_test.go index eea43fb3e0..67e49f3af7 100644 --- a/txnbuild/example_test.go +++ b/txnbuild/example_test.go @@ -2,9 +2,10 @@ package txnbuild import ( "fmt" + "time" + "github.com/stellar/go/price" "github.com/stellar/go/xdr" - "time" "github.com/stellar/go/keypair" "github.com/stellar/go/network" @@ -26,7 +27,7 @@ func ExampleInflation() { IncrementSequenceNum: true, Operations: []Operation{&op}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), // Use a real timeout in production! + Preconditions: NewPreconditions(NewInfiniteTimeout()), // Use a real timeout in production! }, ) check(err) @@ -59,7 +60,7 @@ func ExampleCreateAccount() { IncrementSequenceNum: true, Operations: []Operation{&op}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), // Use a real timeout in production! + Preconditions: NewPreconditions(NewInfiniteTimeout()), // Use a real timeout in production! }, ) check(err) @@ -93,7 +94,7 @@ func ExamplePayment() { IncrementSequenceNum: true, Operations: []Operation{&op}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), // Use a real timeout in production! + Preconditions: NewPreconditions(NewInfiniteTimeout()), // Use a real timeout in production! }, ) check(err) @@ -137,7 +138,7 @@ func ExamplePayment_setBaseFee() { IncrementSequenceNum: true, Operations: []Operation{&op1, &op2}, BaseFee: feeStats.MaxFee.P50, - Timebounds: NewInfiniteTimeout(), // Use a real timeout in production! + Preconditions: NewPreconditions(NewInfiniteTimeout()), // Use a real timeout in production! }, ) check(err) @@ -169,7 +170,7 @@ func ExampleBumpSequence() { IncrementSequenceNum: true, Operations: []Operation{&op}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), // Use a real timeout in production! + Preconditions: NewPreconditions(NewInfiniteTimeout()), // Use a real timeout in production! }, ) check(err) @@ -201,7 +202,7 @@ func ExampleAccountMerge() { IncrementSequenceNum: true, Operations: []Operation{&op}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), // Use a real timeout in production! + Preconditions: NewPreconditions(NewInfiniteTimeout()), // Use a real timeout in production! }, ) check(err) @@ -234,7 +235,7 @@ func ExampleManageData() { IncrementSequenceNum: true, Operations: []Operation{&op}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), // Use a real timeout in production! + Preconditions: NewPreconditions(NewInfiniteTimeout()), // Use a real timeout in production! }, ) check(err) @@ -266,7 +267,7 @@ func ExampleManageData_removeDataEntry() { IncrementSequenceNum: true, Operations: []Operation{&op}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), // Use a real timeout in production! + Preconditions: NewPreconditions(NewInfiniteTimeout()), // Use a real timeout in production! }, ) check(err) @@ -306,7 +307,7 @@ func ExampleSetOptions() { IncrementSequenceNum: true, Operations: []Operation{&op}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), // Use a real timeout in production! + Preconditions: NewPreconditions(NewInfiniteTimeout()), // Use a real timeout in production! }, ) check(err) @@ -342,7 +343,7 @@ func ExampleChangeTrust() { IncrementSequenceNum: true, Operations: []Operation{&op}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), // Use a real timeout in production! + Preconditions: NewPreconditions(NewInfiniteTimeout()), // Use a real timeout in production! }, ) check(err) @@ -372,7 +373,7 @@ func ExampleChangeTrust_removeTrustline() { IncrementSequenceNum: true, Operations: []Operation{&op}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), // Use a real timeout in production! + Preconditions: NewPreconditions(NewInfiniteTimeout()), // Use a real timeout in production! }, ) check(err) @@ -406,7 +407,7 @@ func ExampleAllowTrust() { IncrementSequenceNum: true, Operations: []Operation{&op}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), // Use a real timeout in production! + Preconditions: NewPreconditions(NewInfiniteTimeout()), // Use a real timeout in production! }, ) check(err) @@ -440,7 +441,7 @@ func ExampleManageSellOffer() { IncrementSequenceNum: true, Operations: []Operation{&op}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), // Use a real timeout in production! + Preconditions: NewPreconditions(NewInfiniteTimeout()), // Use a real timeout in production! }, ) check(err) @@ -472,7 +473,7 @@ func ExampleManageSellOffer_deleteOffer() { IncrementSequenceNum: true, Operations: []Operation{&op}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), // Use a real timeout in production! + Preconditions: NewPreconditions(NewInfiniteTimeout()), // Use a real timeout in production! }, ) check(err) @@ -507,7 +508,7 @@ func ExampleManageSellOffer_updateOffer() { IncrementSequenceNum: true, Operations: []Operation{&op}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), // Use a real timeout in production! + Preconditions: NewPreconditions(NewInfiniteTimeout()), // Use a real timeout in production! }, ) check(err) @@ -542,7 +543,7 @@ func ExampleCreatePassiveSellOffer() { IncrementSequenceNum: true, Operations: []Operation{&op}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), // Use a real timeout in production! + Preconditions: NewPreconditions(NewInfiniteTimeout()), // Use a real timeout in production! }, ) check(err) @@ -580,7 +581,7 @@ func ExamplePathPayment() { IncrementSequenceNum: true, Operations: []Operation{&op}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), // Use a real timeout in production! + Preconditions: NewPreconditions(NewInfiniteTimeout()), // Use a real timeout in production! }, ) check(err) @@ -618,7 +619,7 @@ func ExamplePathPaymentStrictReceive() { IncrementSequenceNum: true, Operations: []Operation{&op}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), // Use a real timeout in production! + Preconditions: NewPreconditions(NewInfiniteTimeout()), // Use a real timeout in production! }, ) check(err) @@ -656,7 +657,7 @@ func ExamplePathPaymentStrictSend() { IncrementSequenceNum: true, Operations: []Operation{&op}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), // Use a real timeout in production! + Preconditions: NewPreconditions(NewInfiniteTimeout()), // Use a real timeout in production! }, ) check(err) @@ -692,7 +693,7 @@ func ExampleManageBuyOffer() { IncrementSequenceNum: true, Operations: []Operation{&buyOffer}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), // Use a real timeout in production! + Preconditions: NewPreconditions(NewInfiniteTimeout()), // Use a real timeout in production! }, ) check(err) @@ -725,7 +726,7 @@ func ExampleFeeBumpTransaction() { IncrementSequenceNum: true, Operations: []Operation{&op}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), // Use a real timeout in production! + Preconditions: NewPreconditions(NewInfiniteTimeout()), // Use a real timeout in production! }, ) check(err) @@ -799,7 +800,7 @@ func ExampleCreateClaimableBalance() { SourceAccount: &aAccount, IncrementSequenceNum: true, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), Operations: []Operation{&claimableBalanceEntry}, }, ) @@ -827,7 +828,7 @@ func ExampleClaimClaimableBalance() { SourceAccount: &aAccount, // or Account B, depending on the condition! IncrementSequenceNum: true, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), Operations: []Operation{&claimBalance}, }, network.TestNetworkPassphrase, @@ -893,7 +894,7 @@ func ExampleBeginSponsoringFutureReserves() { TransactionParams{ SourceAccount: &test.Aaccount, Operations: sponsorTrustline, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), BaseFee: MinBaseFee, IncrementSequenceNum: true, }, @@ -934,7 +935,7 @@ func ExampleBeginSponsoringFutureReserves_transfer() { TransactionParams{ SourceAccount: &test.S1account, Operations: transferOps, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), BaseFee: MinBaseFee, IncrementSequenceNum: true, }, @@ -981,7 +982,7 @@ func ExampleRevokeSponsorship() { TransactionParams{ SourceAccount: &test.S2account, Operations: revokeOps, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), BaseFee: MinBaseFee, IncrementSequenceNum: true, }, @@ -1050,7 +1051,7 @@ func ExampleLiquidityPoolDeposit() { TransactionParams{ SourceAccount: &test.AAccount, Operations: depositOps, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), BaseFee: MinBaseFee, IncrementSequenceNum: true, }, @@ -1085,7 +1086,7 @@ func ExampleLiquidityPoolWithdraw() { TransactionParams{ SourceAccount: &test.AAccount, Operations: withdrawOps, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), BaseFee: MinBaseFee, IncrementSequenceNum: true, }, diff --git a/txnbuild/fee_bump_test.go b/txnbuild/fee_bump_test.go index 1a4915041a..c0e4027959 100644 --- a/txnbuild/fee_bump_test.go +++ b/txnbuild/fee_bump_test.go @@ -25,7 +25,7 @@ func TestFeeBumpInvalidFeeSource(t *testing.T) { SourceAccount: &sourceAccount, Operations: []Operation{&Inflation{}}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) assert.NoError(t, err) @@ -51,7 +51,7 @@ func TestFeeBumpUpgradesV0Transaction(t *testing.T) { Operations: []Operation{&Inflation{}}, BaseFee: 2 * MinBaseFee, Memo: MemoText("test-memo"), - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) assert.NoError(t, err) @@ -105,7 +105,7 @@ func TestFeeBumpInvalidInnerTransactionType(t *testing.T) { Operations: []Operation{&Inflation{}}, BaseFee: 2 * MinBaseFee, Memo: MemoText("test-memo"), - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) assert.NoError(t, err) @@ -143,7 +143,7 @@ func TestFeeBumpAllowsFeeAccountToEqualInnerSourceAccount(t *testing.T) { SourceAccount: &sourceAccount, Operations: []Operation{&Inflation{}}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) assert.NoError(t, err) @@ -202,7 +202,7 @@ func TestFeeBumpSignWithKeyString(t *testing.T) { SourceAccount: &sourceAccount, Operations: []Operation{&Inflation{}}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) assert.NoError(t, err) @@ -257,7 +257,7 @@ func TestFeeBumpSignHashX(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&payment}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) assert.NoError(t, err) @@ -300,7 +300,7 @@ func TestFeeBumpAddSignatureBase64(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&createAccount}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) assert.NoError(t, err) @@ -363,7 +363,7 @@ func TestFeeBumpMuxedAccounts(t *testing.T) { SourceAccount: &sourceAccount, Operations: []Operation{&Inflation{}}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) assert.NoError(t, err) diff --git a/txnbuild/manage_buy_offer_test.go b/txnbuild/manage_buy_offer_test.go index 4bd49f5a86..45a6d89b22 100644 --- a/txnbuild/manage_buy_offer_test.go +++ b/txnbuild/manage_buy_offer_test.go @@ -1,9 +1,10 @@ package txnbuild import ( + "testing" + "github.com/stellar/go/price" "github.com/stellar/go/xdr" - "testing" "github.com/stretchr/testify/assert" ) @@ -27,7 +28,7 @@ func TestManageBuyOfferValidateSellingAsset(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&buyOffer}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) if assert.Error(t, err) { @@ -55,7 +56,7 @@ func TestManageBuyOfferValidateBuyingAsset(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&buyOffer}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) if assert.Error(t, err) { @@ -83,7 +84,7 @@ func TestManageBuyOfferValidateAmount(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&buyOffer}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) if assert.Error(t, err) { @@ -111,7 +112,7 @@ func TestManageBuyOfferValidatePrice(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&buyOffer}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) if assert.Error(t, err) { @@ -139,7 +140,7 @@ func TestManageBuyOfferValidateOfferID(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&buyOffer}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) if assert.Error(t, err) { diff --git a/txnbuild/manage_data_test.go b/txnbuild/manage_data_test.go index 9c8074371a..33a096fbf8 100644 --- a/txnbuild/manage_data_test.go +++ b/txnbuild/manage_data_test.go @@ -22,7 +22,7 @@ func TestManageDataValidateName(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&manageData}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) if assert.Error(t, err) { @@ -46,7 +46,7 @@ func TestManageDataValidateValue(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&manageData}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) if assert.Error(t, err) { @@ -88,7 +88,7 @@ func TestManageDataRoundTrip(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&manageData}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) assert.NoError(t, err) diff --git a/txnbuild/manage_offer_test.go b/txnbuild/manage_offer_test.go index d8b7504209..cd4b5c95e8 100644 --- a/txnbuild/manage_offer_test.go +++ b/txnbuild/manage_offer_test.go @@ -1,9 +1,10 @@ package txnbuild import ( + "testing" + "github.com/stellar/go/price" "github.com/stellar/go/xdr" - "testing" "github.com/stretchr/testify/assert" ) @@ -25,7 +26,7 @@ func TestManageSellOfferValidateSellingAsset(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&createOffer}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) if assert.Error(t, err) { @@ -51,7 +52,7 @@ func TestManageSellOfferValidateBuyingAsset(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&createOffer}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) if assert.Error(t, err) { @@ -77,7 +78,7 @@ func TestManageSellOfferValidateAmount(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&createOffer}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) if assert.Error(t, err) { @@ -103,7 +104,7 @@ func TestManageSellOfferValidatePrice(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&createOffer}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) if assert.Error(t, err) { @@ -131,7 +132,7 @@ func TestManageSellOfferValidateOfferID(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&mso}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) if assert.Error(t, err) { diff --git a/txnbuild/operation_test.go b/txnbuild/operation_test.go index d462e3a9c5..48698a6634 100644 --- a/txnbuild/operation_test.go +++ b/txnbuild/operation_test.go @@ -56,7 +56,7 @@ func TestZeroBalanceAccount(t *testing.T) { Operations: ops, IncrementSequenceNum: true, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) @@ -466,7 +466,7 @@ func testOperationsMarshallingRoundtrip(t *testing.T, operations []Operation, wi TransactionParams{ SourceAccount: &sourceAccount, Operations: operations, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), BaseFee: MinBaseFee, }, ) diff --git a/txnbuild/path_payment_strict_send_test.go b/txnbuild/path_payment_strict_send_test.go index 3e3d73a01a..9c9695f147 100644 --- a/txnbuild/path_payment_strict_send_test.go +++ b/txnbuild/path_payment_strict_send_test.go @@ -27,7 +27,7 @@ func TestPathPaymentStrictSendValidateSendAsset(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&pathPayment}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) if assert.Error(t, err) { @@ -57,7 +57,7 @@ func TestPathPaymentStrictSendValidateDestAsset(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&pathPayment}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) if assert.Error(t, err) { @@ -87,7 +87,7 @@ func TestPathPaymentStrictSendValidateDestination(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&pathPayment}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) if assert.Error(t, err) { @@ -117,7 +117,7 @@ func TestPathPaymentStrictSendValidateSendMax(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&pathPayment}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) @@ -148,7 +148,7 @@ func TestPathPaymentStrictSendValidateDestAmount(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&pathPayment}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) if assert.Error(t, err) { diff --git a/txnbuild/path_payment_test.go b/txnbuild/path_payment_test.go index f5f78fafa7..d290d28ded 100644 --- a/txnbuild/path_payment_test.go +++ b/txnbuild/path_payment_test.go @@ -27,7 +27,7 @@ func TestPathPaymentValidateSendAsset(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&pathPayment}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) @@ -58,7 +58,7 @@ func TestPathPaymentValidateDestAsset(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&pathPayment}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) if assert.Error(t, err) { @@ -88,7 +88,7 @@ func TestPathPaymentValidateDestination(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&pathPayment}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) if assert.Error(t, err) { @@ -118,7 +118,7 @@ func TestPathPaymentValidateSendMax(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&pathPayment}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) if assert.Error(t, err) { @@ -148,7 +148,7 @@ func TestPathPaymentValidateDestAmount(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&pathPayment}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) if assert.Error(t, err) { diff --git a/txnbuild/payment_test.go b/txnbuild/payment_test.go index e82cd7b499..95a796e201 100644 --- a/txnbuild/payment_test.go +++ b/txnbuild/payment_test.go @@ -22,7 +22,7 @@ func TestPaymentValidateDestination(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&payment}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) if assert.Error(t, err) { @@ -47,7 +47,7 @@ func TestPaymentValidateAmount(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&payment}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) if assert.Error(t, err) { @@ -72,7 +72,7 @@ func TestPaymentValidateAsset(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&payment}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) if assert.Error(t, err) { diff --git a/txnbuild/preconditions.go b/txnbuild/preconditions.go index f49b96acd0..08e0cea2ee 100644 --- a/txnbuild/preconditions.go +++ b/txnbuild/preconditions.go @@ -10,7 +10,7 @@ type Preconditions struct { // Transaction is only valid during a certain time range. This is private // because it should mirror the one set via TransactionParams, and this // association should be done via `NewPreconditions()`. - timebounds *Timebounds + Timebounds Timebounds // Transaction is valid for ledger numbers n such that minLedger <= n < // maxLedger (if maxLedger == 0, then only minLedger is checked) Ledgerbounds *Ledgerbounds @@ -31,52 +31,20 @@ type Preconditions struct { } // NewPreconditions creates a set of preconditions with timebounds enabled -func NewPreconditions(timebounds *Timebounds) Preconditions { - cond := Preconditions{} - if err := cond.SetTimebounds(timebounds); err != nil { - panic(err) - } +func NewPreconditions(timebounds Timebounds) Preconditions { + cond := Preconditions{Timebounds: timebounds} return cond } func NewPreconditionsWithTimebounds(minTime, maxTime int64) Preconditions { - tb := NewTimebounds(minTime, maxTime) - return NewPreconditions(&tb) -} - -// SetTimebounds enables the timebound precondition. Note that timebounds are a -// *required* precondition, but they're passed here by pointer in order to align -// with `TransactionParams.Timebounds`. -func (cond *Preconditions) SetTimebounds(timebounds *Timebounds) error { - if timebounds == nil { - return errors.New("timebounds are required") - } - - if err := timebounds.Validate(); err != nil { - return err - } - - if cond.timebounds != nil { - // only fail if they differ - if cond.timebounds.MinTime != timebounds.MinTime || - cond.timebounds.MaxTime != timebounds.MaxTime { - return errors.New("timebounds set twice") - } - } - - cond.timebounds = timebounds - return nil -} - -func (cond *Preconditions) Timebounds() Timebounds { - return *cond.timebounds + return NewPreconditions(NewTimebounds(minTime, maxTime)) } // Validate ensures that all enabled preconditions are valid. func (cond *Preconditions) Validate() error { var err error - if err = cond.timebounds.Validate(); err != nil { + if err = cond.Timebounds.Validate(); err != nil { return err } @@ -98,28 +66,18 @@ func (cond *Preconditions) ValidateSigners() bool { return len(cond.ExtraSigners) <= 2 } -// HasV2Conditions determines whether or not this has conditions on top of -// the (required) timebound precondition. -func (cond *Preconditions) HasV2Conditions() bool { - return (cond.Ledgerbounds != nil || - cond.MinSequenceNumber != nil || - cond.MinSequenceNumberAge > xdr.Duration(0) || - cond.MinSequenceNumberLedgerGap > 0 || - len(cond.ExtraSigners) > 0) -} - // BuildXDR will create a precondition structure that varies depending on // whether or not there are additional preconditions besides timebounds (which // are required). func (cond *Preconditions) BuildXDR() xdr.Preconditions { xdrCond := xdr.Preconditions{} xdrTimeBounds := xdr.TimeBounds{ - MinTime: xdr.TimePoint(cond.timebounds.MinTime), - MaxTime: xdr.TimePoint(cond.timebounds.MaxTime), + MinTime: xdr.TimePoint(cond.Timebounds.MinTime), + MaxTime: xdr.TimePoint(cond.Timebounds.MaxTime), } // Only build PRECOND_V2 structure if we need to - if cond.HasV2Conditions() { + if cond.hasV2Conditions() { xdrPrecond := xdr.PreconditionsV2{ TimeBounds: &xdrTimeBounds, MinSeqAge: cond.MinSequenceNumberAge, @@ -150,3 +108,13 @@ func (cond *Preconditions) BuildXDR() xdr.Preconditions { return xdrCond } + +// hasV2Conditions determines whether or not this has conditions on top of +// the (required) timebound precondition. +func (cond *Preconditions) hasV2Conditions() bool { + return (cond.Ledgerbounds != nil || + cond.MinSequenceNumber != nil || + cond.MinSequenceNumberAge > xdr.Duration(0) || + cond.MinSequenceNumberLedgerGap > 0 || + len(cond.ExtraSigners) > 0) +} diff --git a/txnbuild/preconditions_test.go b/txnbuild/preconditions_test.go index 6870c20954..f9c8952ed9 100644 --- a/txnbuild/preconditions_test.go +++ b/txnbuild/preconditions_test.go @@ -16,13 +16,12 @@ var Signers = []xdr.SignerKey{ // TestClassifyingPreconditions ensures that Preconditions will correctly // differentiate V1 (timebounds-only) or V2 (all other) preconditions correctly. func TestClassifyingPreconditions(t *testing.T) { - tb := NewTimebounds(1, 2) - tbpc := NewPreconditions(&tb) - assert.False(t, (&Preconditions{}).HasV2Conditions()) - assert.False(t, tbpc.HasV2Conditions()) + tbpc := NewPreconditionsWithTimebounds(1, 2) + assert.False(t, (&Preconditions{}).hasV2Conditions()) + assert.False(t, tbpc.hasV2Conditions()) tbpc.MinSequenceNumberLedgerGap = 2 - assert.True(t, tbpc.HasV2Conditions()) + assert.True(t, tbpc.hasV2Conditions()) } // TestPreconditions ensures correct XDR is generated for a (non-exhaustive) @@ -47,9 +46,8 @@ func TestPreconditions(t *testing.T) { ExtraSigners: Signers[:1], }, } - tb := NewTimebounds(27, 42) pc := Preconditions{ - timebounds: &tb, + Timebounds: NewTimebounds(27, 42), Ledgerbounds: &Ledgerbounds{27, 42}, MinSequenceNumber: &seqNum, MinSequenceNumberAge: xdr.Duration(27), @@ -74,14 +72,13 @@ func TestPreconditions(t *testing.T) { { "only timebounds", func() (xdr.Preconditions, Preconditions) { - tb := NewTimebounds(1, 2) return xdr.Preconditions{ Type: xdr.PreconditionTypePrecondTime, TimeBounds: &xdr.TimeBounds{ MinTime: xdr.TimePoint(1), MaxTime: xdr.TimePoint(2), }, - }, NewPreconditions(&tb) + }, NewPreconditionsWithTimebounds(1, 2) }, }, { @@ -158,8 +155,7 @@ func cloneXdrPreconditions(pc xdr.Preconditions) xdr.Preconditions { } func clonePreconditions(precond Preconditions) Preconditions { - tb := NewTimebounds(precond.timebounds.MinTime, precond.timebounds.MaxTime) - cond := NewPreconditions(&tb) + cond := NewPreconditions(precond.Timebounds) if precond.Ledgerbounds != nil { cond.Ledgerbounds = &Ledgerbounds{ MinLedger: precond.Ledgerbounds.MinLedger, diff --git a/txnbuild/signers_test.go b/txnbuild/signers_test.go index 6dd98792cf..97567f77c5 100644 --- a/txnbuild/signers_test.go +++ b/txnbuild/signers_test.go @@ -1,9 +1,10 @@ package txnbuild import ( - "github.com/stellar/go/price" "testing" + "github.com/stellar/go/price" + "github.com/stellar/go/keypair" "github.com/stellar/go/xdr" @@ -28,7 +29,7 @@ func TestAccountMergeMultSigners(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&accountMerge}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, network.TestNetworkPassphrase, kp0, kp1, @@ -59,7 +60,7 @@ func TestAllowTrustMultSigners(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&allowTrust}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, network.TestNetworkPassphrase, kp0, kp1, @@ -87,7 +88,7 @@ func TestBumpSequenceMultSigners(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&bumpSequence}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, network.TestNetworkPassphrase, kp0, kp1, @@ -116,7 +117,7 @@ func TestChangeTrustMultSigners(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&changeTrust}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, network.TestNetworkPassphrase, kp0, kp1, @@ -145,7 +146,7 @@ func TestCreateAccountMultSigners(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&createAccount}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, network.TestNetworkPassphrase, kp0, kp1, @@ -176,7 +177,7 @@ func TestCreatePassiveSellOfferMultSigners(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&createPassiveOffer}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, network.TestNetworkPassphrase, kp0, kp1, @@ -203,7 +204,7 @@ func TestInflationMultSigners(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&inflation}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, network.TestNetworkPassphrase, kp0, kp1, @@ -232,7 +233,7 @@ func TestManageDataMultSigners(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&manageData}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, network.TestNetworkPassphrase, kp0, kp1, @@ -261,7 +262,7 @@ func TestManageOfferCreateMultSigners(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&createOffer}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, network.TestNetworkPassphrase, kp0, kp1, @@ -288,7 +289,7 @@ func TestManageOfferDeleteMultSigners(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&deleteOffer}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, network.TestNetworkPassphrase, kp0, kp1, @@ -318,7 +319,7 @@ func TestManageOfferUpdateMultSigners(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&updateOffer}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, network.TestNetworkPassphrase, kp0, kp1, @@ -352,7 +353,7 @@ func TestPathPaymentMultSigners(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&pathPayment}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, network.TestNetworkPassphrase, kp0, kp1, @@ -383,7 +384,7 @@ func TestPaymentMultSigners(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&payment}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, network.TestNetworkPassphrase, kp0, kp1, @@ -411,7 +412,7 @@ func TestSetOptionsMultSigners(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&setOptions}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, network.TestNetworkPassphrase, kp0, kp1, @@ -461,7 +462,7 @@ func TestSigningImmutability(t *testing.T) { SourceAccount: &sourceAccount, Operations: []Operation{&Inflation{}}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), } root, err := NewTransaction(params) assert.NoError(t, err) @@ -512,7 +513,7 @@ func TestFeeBumpSigningImmutability(t *testing.T) { SourceAccount: &sourceAccount, Operations: []Operation{&Inflation{}}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), } inner, err := NewTransaction(innerParams) assert.NoError(t, err) diff --git a/txnbuild/transaction.go b/txnbuild/transaction.go index ec2796c862..5ebd16b16c 100644 --- a/txnbuild/transaction.go +++ b/txnbuild/transaction.go @@ -242,7 +242,7 @@ func (t *Transaction) Memo() Memo { // Timebounds returns the Timebounds configured for this transaction. func (t *Transaction) Timebounds() Timebounds { - return t.preconditions.Timebounds() + return t.preconditions.Timebounds } // Operations returns the list of operations included in this transaction. @@ -797,13 +797,12 @@ func transactionFromParsedXDR(xdrEnv xdr.TransactionEnvelope) (*GenericTransacti // TransactionParams is a container for parameters which are used to construct // new Transaction instances type TransactionParams struct { - SourceAccount Account - IncrementSequenceNum bool - Operations []Operation - BaseFee int64 - Memo Memo - Timebounds Timebounds - AdditionalPreconditions Preconditions + SourceAccount Account + IncrementSequenceNum bool + Operations []Operation + BaseFee int64 + Memo Memo + Preconditions Preconditions } // NewTransaction returns a new Transaction instance @@ -823,17 +822,6 @@ func NewTransaction(params TransactionParams) (*Transaction, error) { return nil, errors.Wrap(err, "could not obtain account sequence") } - // Because both V1 and V2 preconditions allow timebounds, and we don't want - // to introduce a breaking change by dropping - // `TransactionParams.Timebounds`, nor require users to set up the - // `AdditionalPreconditions`, we need to coalesce the two values here. - if params.Timebounds != (Timebounds{}) { - err = params.AdditionalPreconditions.SetTimebounds(¶ms.Timebounds) - if err != nil { - return nil, errors.Wrap(err, "invalid timebounds") - } - } - tx := &Transaction{ baseFee: params.BaseFee, sourceAccount: SimpleAccount{ @@ -842,7 +830,7 @@ func NewTransaction(params TransactionParams) (*Transaction, error) { }, operations: params.Operations, memo: params.Memo, - preconditions: params.AdditionalPreconditions, + preconditions: params.Preconditions, } var sourceAccount xdr.MuxedAccount if err = sourceAccount.SetAddress(tx.sourceAccount.AccountID); err != nil { @@ -924,7 +912,7 @@ func convertToV1(tx *Transaction) (*Transaction, error) { Operations: tx.Operations(), BaseFee: tx.BaseFee(), Memo: tx.Memo(), - Timebounds: tx.Timebounds(), + Preconditions: NewPreconditions(tx.Timebounds()), }) if err != nil { return tx, err @@ -1060,9 +1048,9 @@ func BuildChallengeTx(serverSignerSecret, clientAccountID, webAuthDomain, homeDo Value: []byte(webAuthDomain), }, }, - BaseFee: MinBaseFee, - Memo: nil, - Timebounds: NewTimebounds(currentTime.Unix(), maxTime.Unix()), + BaseFee: MinBaseFee, + Memo: nil, + Preconditions: NewPreconditions(NewTimebounds(currentTime.Unix(), maxTime.Unix())), }, ) if err != nil { diff --git a/txnbuild/transaction_fee_test.go b/txnbuild/transaction_fee_test.go index 888f8a2483..eecda0bfc8 100644 --- a/txnbuild/transaction_fee_test.go +++ b/txnbuild/transaction_fee_test.go @@ -16,7 +16,7 @@ func TestBaseFeeCanBeZeroOrPositive(t *testing.T) { SourceAccount: &SimpleAccount{keypair.MustRandom().Address(), 1}, Operations: []Operation{&Inflation{}}, BaseFee: bf, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) assert.NoError(t, err) @@ -30,7 +30,7 @@ func TestBaseFeeErrorWhenNegative(t *testing.T) { SourceAccount: &SimpleAccount{keypair.MustRandom().Address(), 1}, Operations: []Operation{&Inflation{}}, BaseFee: -1, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) assert.EqualError(t, err, "base fee cannot be negative") @@ -45,7 +45,7 @@ func TestFeeBumpMinBaseFee(t *testing.T) { SourceAccount: &sourceAccount, Operations: []Operation{&Inflation{}}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) assert.NoError(t, err) @@ -70,7 +70,7 @@ func TestFeeOverflow(t *testing.T) { SourceAccount: &sourceAccount, Operations: []Operation{&Inflation{}, &Inflation{}}, BaseFee: math.MaxUint32 / 2, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) assert.NoError(t, err) @@ -80,7 +80,7 @@ func TestFeeOverflow(t *testing.T) { SourceAccount: &sourceAccount, Operations: []Operation{&Inflation{}, &Inflation{}, &Inflation{}}, BaseFee: math.MaxUint32 / 2, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) assert.EqualError(t, err, "base fee 2147483647 results in an overflow of max fee") @@ -95,7 +95,7 @@ func TestFeeBumpOverflow(t *testing.T) { SourceAccount: &sourceAccount, Operations: []Operation{&Inflation{}}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) assert.NoError(t, err) @@ -128,7 +128,7 @@ func TestFeeBumpFeeGreaterThanOrEqualInner(t *testing.T) { SourceAccount: &sourceAccount, Operations: []Operation{&Inflation{}}, BaseFee: 2 * MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) assert.NoError(t, err) diff --git a/txnbuild/transaction_test.go b/txnbuild/transaction_test.go index c9fc4201c0..c5b9a8f2b0 100644 --- a/txnbuild/transaction_test.go +++ b/txnbuild/transaction_test.go @@ -39,59 +39,30 @@ func TestTimebounds(t *testing.T) { BaseFee: MinBaseFee, } - // Happy path: old timebound method used - tp.Timebounds = tb + tp.Preconditions.Timebounds = tb tx, err := NewTransaction(tp) assert.NoError(t, err) - assert.Equal(t, tb, tx.preconditions.Timebounds()) + assert.Equal(t, tb, tx.preconditions.Timebounds) assert.Equal(t, xdr.TimePoint(tb.MinTime), tx.envelope.TimeBounds().MinTime) assert.Equal(t, xdr.TimePoint(tb.MaxTime), tx.envelope.TimeBounds().MaxTime) - - // Transactions with timebounds set and timebounds-only preconditions set - // should result in identical XDR. - cond := NewPreconditions(&tb) - tp.Timebounds = Timebounds{} - tp.AdditionalPreconditions = cond - tx2, err := NewTransaction(tp) - assert.NoError(t, err) - assert.Equal(t, tb, tx.preconditions.Timebounds()) - - b1, err := tx.ToXDR().MarshalBinary() - assert.NoError(t, err) - b2, err := tx2.ToXDR().MarshalBinary() - assert.NoError(t, err) - assert.EqualValues(t, b1, b2) - - // Transactions built with both (and differing) ways to set a timebound - // precondition should fail... - tp.AdditionalPreconditions = cond - tp.Timebounds = NewTimebounds(1, 2) - _, err = NewTransaction(tp) - assert.EqualError(t, err, "invalid timebounds: timebounds set twice") - - // ...but identical values should pass. - tp.Timebounds = *cond.timebounds - _, err = NewTransaction(tp) - assert.NoError(t, err) } func TestV2Preconditions(t *testing.T) { kp0 := newKeypair0() - tb := NewTimeout(300) - cond := NewPreconditions(&tb) + cond := NewPreconditions(NewTimeout(300)) cond.Ledgerbounds = &Ledgerbounds{0, 1} cond.MinSequenceNumber = nil cond.MinSequenceNumberAge = xdr.Duration(10) cond.MinSequenceNumberLedgerGap = 2 - assert.True(t, cond.HasV2Conditions()) + assert.True(t, cond.hasV2Conditions()) tp := TransactionParams{ SourceAccount: &SimpleAccount{AccountID: kp0.Address(), Sequence: 1}, Operations: []Operation{&BumpSequence{BumpTo: 0}}, BaseFee: MinBaseFee, - AdditionalPreconditions: cond, + Preconditions: cond, } tx, err := NewTransaction(tp) @@ -115,7 +86,7 @@ func TestIncrementSequenceNum(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&inflation}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) assert.NoError(t, err) @@ -127,7 +98,7 @@ func TestIncrementSequenceNum(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&inflation}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) assert.NoError(t, err) @@ -139,7 +110,7 @@ func TestIncrementSequenceNum(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&inflation}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) assert.NoError(t, err) @@ -151,7 +122,7 @@ func TestIncrementSequenceNum(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&inflation}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) assert.NoError(t, err) @@ -167,7 +138,7 @@ func TestFeeNoOperations(t *testing.T) { SourceAccount: &sourceAccount, Operations: []Operation{}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) assert.EqualError(t, err, "transaction has no operations") @@ -185,7 +156,7 @@ func TestInflation(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&inflation}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, network.TestNetworkPassphrase, kp0, @@ -211,7 +182,7 @@ func TestCreateAccount(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&createAccount}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, network.TestNetworkPassphrase, kp0, @@ -238,7 +209,7 @@ func TestPayment(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&payment}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, network.TestNetworkPassphrase, kp0, @@ -274,7 +245,7 @@ func TestPaymentMuxedAccounts(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&payment}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, network.TestNetworkPassphrase, kp0, @@ -300,7 +271,7 @@ func TestPaymentFailsIfNoAssetSpecified(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&payment}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) expectedErrMsg := "validation failed for *txnbuild.Payment operation: Field: Asset, Error: asset is undefined" @@ -321,7 +292,7 @@ func TestBumpSequence(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&bumpSequence}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, network.TestNetworkPassphrase, kp1, @@ -346,7 +317,7 @@ func TestAccountMerge(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&accountMerge}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, network.TestNetworkPassphrase, kp0, @@ -372,7 +343,7 @@ func TestManageData(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&manageData}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, network.TestNetworkPassphrase, kp0, @@ -397,7 +368,7 @@ func TestManageDataRemoveDataEntry(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&manageData}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, network.TestNetworkPassphrase, kp0, @@ -423,7 +394,7 @@ func TestSetOptionsInflationDestination(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&setOptions}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, network.TestNetworkPassphrase, kp0, @@ -448,7 +419,7 @@ func TestSetOptionsSetFlags(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&setOptions}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, network.TestNetworkPassphrase, kp0, @@ -473,7 +444,7 @@ func TestSetOptionsClearFlags(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&setOptions}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, network.TestNetworkPassphrase, kp0, @@ -498,7 +469,7 @@ func TestSetOptionsMasterWeight(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&setOptions}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, network.TestNetworkPassphrase, kp0, @@ -525,7 +496,7 @@ func TestSetOptionsThresholds(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&setOptions}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, network.TestNetworkPassphrase, kp0, @@ -550,7 +521,7 @@ func TestSetOptionsHomeDomain(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&setOptions}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, network.TestNetworkPassphrase, kp0, @@ -575,7 +546,7 @@ func TestSetOptionsHomeDomainTooLong(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&setOptions}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) @@ -597,7 +568,7 @@ func TestSetOptionsSigner(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&setOptions}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, network.TestNetworkPassphrase, kp0, @@ -623,7 +594,7 @@ func TestMultipleOperations(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&inflation, &bumpSequence}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, network.TestNetworkPassphrase, kp1, @@ -650,7 +621,7 @@ func TestChangeTrust(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&changeTrust}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, network.TestNetworkPassphrase, kp0, @@ -676,7 +647,7 @@ func TestChangeTrustNativeAssetNotAllowed(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&changeTrust}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) @@ -698,7 +669,7 @@ func TestChangeTrustDeleteTrustline(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&removeTrust}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, network.TestNetworkPassphrase, kp0, @@ -727,7 +698,7 @@ func TestAllowTrust(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&allowTrust}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, network.TestNetworkPassphrase, kp0, @@ -756,7 +727,7 @@ func TestAllowTrustNoIssuer(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&allowTrust}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, network.TestNetworkPassphrase, kp0, @@ -784,7 +755,7 @@ func TestManageSellOfferNewOffer(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&createOffer}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, network.TestNetworkPassphrase, kp1, @@ -809,7 +780,7 @@ func TestManageSellOfferDeleteOffer(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&deleteOffer}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, network.TestNetworkPassphrase, kp1, @@ -838,7 +809,7 @@ func TestManageSellOfferUpdateOffer(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&updateOffer}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, network.TestNetworkPassphrase, kp1, @@ -867,7 +838,7 @@ func TestCreatePassiveSellOffer(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&createPassiveOffer}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, network.TestNetworkPassphrase, kp1, @@ -899,7 +870,7 @@ func TestPathPayment(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&pathPayment}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, network.TestNetworkPassphrase, kp2, @@ -921,7 +892,7 @@ func TestMemoText(t *testing.T) { Operations: []Operation{&BumpSequence{BumpTo: 1}}, Memo: MemoText("Twas brillig"), BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, network.TestNetworkPassphrase, kp2, @@ -943,7 +914,7 @@ func TestMemoID(t *testing.T) { Operations: []Operation{&BumpSequence{BumpTo: 1}}, Memo: MemoID(314159), BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, network.TestNetworkPassphrase, kp2, @@ -965,7 +936,7 @@ func TestMemoHash(t *testing.T) { Operations: []Operation{&BumpSequence{BumpTo: 1}}, Memo: MemoHash([32]byte{0x01}), BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, network.TestNetworkPassphrase, kp2, @@ -987,7 +958,7 @@ func TestMemoReturn(t *testing.T) { Operations: []Operation{&BumpSequence{BumpTo: 1}}, Memo: MemoReturn([32]byte{0x01}), BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, network.TestNetworkPassphrase, kp2, @@ -1017,7 +988,7 @@ func TestManageBuyOfferNewOffer(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&buyOffer}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, network.TestNetworkPassphrase, kp1, @@ -1046,7 +1017,7 @@ func TestManageBuyOfferDeleteOffer(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&buyOffer}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, network.TestNetworkPassphrase, kp1, @@ -1075,7 +1046,7 @@ func TestManageBuyOfferUpdateOffer(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&buyOffer}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, network.TestNetworkPassphrase, kp1, @@ -1160,7 +1131,7 @@ func TestHashHex(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&createAccount}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) assert.NoError(t, err) @@ -1204,7 +1175,7 @@ func TestTransactionFee(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&createAccount}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) assert.NoError(t, err) @@ -1218,7 +1189,7 @@ func TestTransactionFee(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&createAccount}, BaseFee: 500, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) assert.NoError(t, err) @@ -1252,7 +1223,7 @@ func TestPreAuthTransaction(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&createAccount}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) assert.NoError(t, err) @@ -1290,7 +1261,7 @@ func TestPreAuthTransaction(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&setOptions}, BaseFee: 500, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) assert.NoError(t, err) @@ -1331,7 +1302,7 @@ func TestHashXTransaction(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&setOptions}, BaseFee: 500, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) assert.NoError(t, err) @@ -1361,7 +1332,7 @@ func TestHashXTransaction(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&payment}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) assert.NoError(t, err) @@ -1467,7 +1438,7 @@ func TestBuild(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&createAccount}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) assert.NoError(t, err) @@ -1527,7 +1498,7 @@ func TestFromXDRBuildSignEncode(t *testing.T) { Operations: newTx.Operations(), BaseFee: newTx.BaseFee(), Memo: MemoText("newtx"), - Timebounds: newTx.Timebounds(), + Preconditions: NewPreconditions(newTx.Timebounds()), }, network.TestNetworkPassphrase, kp0, @@ -1553,7 +1524,7 @@ func TestSignWithSecretKey(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&createAccount}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, network.TestNetworkPassphrase, kp0, kp1, @@ -1566,7 +1537,7 @@ func TestSignWithSecretKey(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&createAccount}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) assert.NoError(t, err) @@ -1600,7 +1571,7 @@ func TestAddSignatureDecorated(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&createAccount}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, network.TestNetworkPassphrase, kp0, kp1, @@ -1613,7 +1584,7 @@ func TestAddSignatureDecorated(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&createAccount}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) assert.NoError(t, err) @@ -1701,8 +1672,8 @@ func TestFeeBumpTransaction_AddSignatureDecorated(t *testing.T) { Amount: "10", SourceAccount: kp1.Address(), }}, - BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + BaseFee: MinBaseFee, + Preconditions: NewPreconditions(NewInfiniteTimeout()), }) require.NoError(t, err) tx, err = tx.Sign(network.TestNetworkPassphrase, kp0, kp1) @@ -1752,7 +1723,7 @@ func TestAddSignatureBase64(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&createAccount}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, network.TestNetworkPassphrase, kp0, kp1, @@ -1765,7 +1736,7 @@ func TestAddSignatureBase64(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&createAccount}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) assert.NoError(t, err) @@ -1801,8 +1772,8 @@ func TestTransaction_ClearSignatures(t *testing.T) { Amount: "10", SourceAccount: kp1.Address(), }}, - BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + BaseFee: MinBaseFee, + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) require.NoError(t, err) @@ -1834,8 +1805,8 @@ func TestFeeBumpTransaction_ClearSignatures(t *testing.T) { Amount: "10", SourceAccount: kp1.Address(), }}, - BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + BaseFee: MinBaseFee, + Preconditions: NewPreconditions(NewInfiniteTimeout()), }) require.NoError(t, err) require.Len(t, tx.Signatures(), 0) @@ -1887,7 +1858,7 @@ func TestReadChallengeTx_validSignedByServerAndClient(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(1000), + Preconditions: NewPreconditions(NewTimeout(1000)), }, ) assert.NoError(t, err) @@ -1922,7 +1893,7 @@ func TestReadChallengeTx_validSignedByServer(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(1000), + Preconditions: NewPreconditions(NewTimeout(1000)), }, ) assert.NoError(t, err) @@ -1957,7 +1928,7 @@ func TestReadChallengeTx_invalidNotSignedByServer(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(1000), + Preconditions: NewPreconditions(NewTimeout(1000)), }, ) assert.NoError(t, err) @@ -1990,7 +1961,7 @@ func TestReadChallengeTx_invalidCorrupted(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(1000), + Preconditions: NewPreconditions(NewTimeout(1000)), }, ) assert.NoError(t, err) @@ -2031,7 +2002,7 @@ func TestReadChallengeTx_invalidServerAccountIDMismatch(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(1000), + Preconditions: NewPreconditions(NewTimeout(1000)), }, ) assert.NoError(t, err) @@ -2066,7 +2037,7 @@ func TestReadChallengeTx_invalidSeqNoNotZero(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(1000), + Preconditions: NewPreconditions(NewTimeout(1000)), }, ) assert.NoError(t, err) @@ -2101,7 +2072,7 @@ func TestReadChallengeTx_invalidTimeboundsInfinite(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) assert.NoError(t, err) @@ -2136,7 +2107,7 @@ func TestReadChallengeTx_invalidTimeboundsOutsideRange(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewTimebounds(0, 100), + Preconditions: NewPreconditions(NewTimebounds(0, 100)), }, ) assert.NoError(t, err) @@ -2173,7 +2144,7 @@ func TestReadChallengeTx_validTimeboundsWithGracePeriod(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewTimebounds(unixNow+5*59, unixNow+60*60), + Preconditions: NewPreconditions(NewTimebounds(unixNow+5*59, unixNow+60*60)), }, ) assert.NoError(t, err) @@ -2209,7 +2180,7 @@ func TestReadChallengeTx_invalidTimeboundsWithGracePeriod(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewTimebounds(unixNow+5*61, unixNow+60*60), + Preconditions: NewPreconditions(NewTimebounds(unixNow+5*61, unixNow+60*60)), }, ) assert.NoError(t, err) @@ -2239,7 +2210,7 @@ func TestReadChallengeTx_invalidOperationWrongType(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(300), + Preconditions: NewPreconditions(NewTimeout(300)), }, ) assert.NoError(t, err) @@ -2267,7 +2238,7 @@ func TestReadChallengeTx_invalidOperationNoSourceAccount(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(300), + Preconditions: NewPreconditions(NewTimeout(300)), }, ) assert.NoError(t, err) @@ -2300,7 +2271,7 @@ func TestReadChallengeTx_invalidDataValueWrongEncodedLength(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(300), + Preconditions: NewPreconditions(NewTimeout(300)), }, ) assert.NoError(t, err) @@ -2335,7 +2306,7 @@ func TestReadChallengeTx_invalidDataValueCorruptBase64(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(300), + Preconditions: NewPreconditions(NewTimeout(300)), }, ) assert.NoError(t, err) @@ -2370,7 +2341,7 @@ func TestReadChallengeTx_invalidDataValueWrongByteLength(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(1000), + Preconditions: NewPreconditions(NewTimeout(1000)), }, ) assert.NoError(t, err) @@ -2520,7 +2491,7 @@ func TestReadChallengeTx_doesVerifyHomeDomainFailure(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(1000), + Preconditions: NewPreconditions(NewTimeout(1000)), }, ) assert.NoError(t, err) @@ -2553,7 +2524,7 @@ func TestReadChallengeTx_doesVerifyHomeDomainSuccess(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(1000), + Preconditions: NewPreconditions(NewTimeout(1000)), }, ) assert.NoError(t, err) @@ -2591,7 +2562,7 @@ func TestReadChallengeTx_allowsAdditionalManageDataOpsWithSourceAccountSetToServ IncrementSequenceNum: true, Operations: []Operation{&op1, &op2, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(1000), + Preconditions: NewPreconditions(NewTimeout(1000)), }, ) assert.NoError(t, err) @@ -2631,7 +2602,7 @@ func TestReadChallengeTx_disallowsAdditionalManageDataOpsWithoutSourceAccountSet IncrementSequenceNum: true, Operations: []Operation{&op1, &op2, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(1000), + Preconditions: NewPreconditions(NewTimeout(1000)), }, ) assert.NoError(t, err) @@ -2668,7 +2639,7 @@ func TestReadChallengeTx_disallowsAdditionalOpsOfOtherTypes(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op1, &op2, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(300), + Preconditions: NewPreconditions(NewTimeout(300)), }, ) assert.NoError(t, err) @@ -2703,7 +2674,7 @@ func TestReadChallengeTx_matchesHomeDomain(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op1, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(300), + Preconditions: NewPreconditions(NewTimeout(300)), }, ) assert.NoError(t, err) @@ -2736,7 +2707,7 @@ func TestReadChallengeTx_doesNotMatchHomeDomain(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op1, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(300), + Preconditions: NewPreconditions(NewTimeout(300)), }, ) assert.NoError(t, err) @@ -2764,7 +2735,7 @@ func TestReadChallengeTx_validWhenWebAuthDomainMissing(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op1}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(300), + Preconditions: NewPreconditions(NewTimeout(300)), }, ) assert.NoError(t, err) @@ -2796,7 +2767,7 @@ func TestReadChallengeTx_invalidWebAuthDomainSourceAccount(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op1, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(300), + Preconditions: NewPreconditions(NewTimeout(300)), }, ) assert.NoError(t, err) @@ -2828,7 +2799,7 @@ func TestReadChallengeTx_invalidWebAuthDomain(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op1, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(300), + Preconditions: NewPreconditions(NewTimeout(300)), }, ) assert.NoError(t, err) @@ -2861,7 +2832,7 @@ func TestVerifyChallengeTxThreshold_invalidServer(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(1000), + Preconditions: NewPreconditions(NewTimeout(1000)), }, network.TestNetworkPassphrase, clientKP, @@ -2897,7 +2868,7 @@ func TestVerifyChallengeTxThreshold_validServerAndClientKeyMeetingThreshold(t *t IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(1000), + Preconditions: NewPreconditions(NewTimeout(1000)), }, network.TestNetworkPassphrase, serverKP, clientKP, @@ -2938,7 +2909,7 @@ func TestVerifyChallengeTxThreshold_validServerAndMultipleClientKeyMeetingThresh IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(1000), + Preconditions: NewPreconditions(NewTimeout(1000)), }, network.TestNetworkPassphrase, serverKP, clientKP1, clientKP2, @@ -2993,7 +2964,7 @@ func TestVerifyChallengeTxThreshold_validServerAndMultipleClientKeyMeetingThresh IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(1000), + Preconditions: NewPreconditions(NewTimeout(1000)), }, network.TestNetworkPassphrase, serverKP, clientKP1, clientKP2, @@ -3044,7 +3015,7 @@ func TestVerifyChallengeTxThreshold_validServerAndMultipleClientKeyMeetingThresh IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(1000), + Preconditions: NewPreconditions(NewTimeout(1000)), }, network.TestNetworkPassphrase, serverKP, clientKP1, clientKP2, @@ -3085,7 +3056,7 @@ func TestVerifyChallengeTxThreshold_invalidServerAndMultipleClientKeyNotMeetingT IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(1000), + Preconditions: NewPreconditions(NewTimeout(1000)), }, network.TestNetworkPassphrase, serverKP, clientKP1, clientKP2, @@ -3124,7 +3095,7 @@ func TestVerifyChallengeTxThreshold_invalidClientKeyUnrecognized(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(1000), + Preconditions: NewPreconditions(NewTimeout(1000)), }, network.TestNetworkPassphrase, serverKP, clientKP1, clientKP2, clientKP3, @@ -3160,7 +3131,7 @@ func TestVerifyChallengeTxThreshold_invalidNoSigners(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(1000), + Preconditions: NewPreconditions(NewTimeout(1000)), }, network.TestNetworkPassphrase, serverKP, clientKP1, clientKP2, clientKP3, @@ -3192,7 +3163,7 @@ func TestVerifyChallengeTxThreshold_weightsAddToMoreThan8Bits(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(1000), + Preconditions: NewPreconditions(NewTimeout(1000)), }, network.TestNetworkPassphrase, serverKP, clientKP1, clientKP2, @@ -3234,7 +3205,7 @@ func TestVerifyChallengeTxThreshold_matchesHomeDomain(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op1, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(300), + Preconditions: NewPreconditions(NewTimeout(300)), }, ) assert.NoError(t, err) @@ -3277,7 +3248,7 @@ func TestVerifyChallengeTxThreshold_doesNotMatchHomeDomain(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op1, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(300), + Preconditions: NewPreconditions(NewTimeout(300)), }, ) assert.NoError(t, err) @@ -3315,7 +3286,7 @@ func TestVerifyChallengeTxThreshold_doesVerifyHomeDomainFailure(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(1000), + Preconditions: NewPreconditions(NewTimeout(1000)), }, network.TestNetworkPassphrase, serverKP, clientKP, @@ -3351,7 +3322,7 @@ func TestVerifyChallengeTxThreshold_doesVerifyHomeDomainSuccess(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(1000), + Preconditions: NewPreconditions(NewTimeout(1000)), }, network.TestNetworkPassphrase, serverKP, clientKP, @@ -3397,7 +3368,7 @@ func TestVerifyChallengeTxThreshold_allowsAdditionalManageDataOpsWithSourceAccou IncrementSequenceNum: true, Operations: []Operation{&op1, &op2, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(1000), + Preconditions: NewPreconditions(NewTimeout(1000)), }, network.TestNetworkPassphrase, serverKP, clientKP, @@ -3443,7 +3414,7 @@ func TestVerifyChallengeTxThreshold_disallowsAdditionalManageDataOpsWithoutSourc IncrementSequenceNum: true, Operations: []Operation{&op1, &op2, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(1000), + Preconditions: NewPreconditions(NewTimeout(1000)), }, network.TestNetworkPassphrase, serverKP, clientKP, @@ -3485,7 +3456,7 @@ func TestVerifyChallengeTxThreshold_disallowsAdditionalOpsOfOtherTypes(t *testin IncrementSequenceNum: true, Operations: []Operation{&op1, &op2, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(1000), + Preconditions: NewPreconditions(NewTimeout(1000)), }, network.TestNetworkPassphrase, serverKP, clientKP, @@ -3518,7 +3489,7 @@ func TestVerifyChallengeTxThreshold_validWhenWebAuthDomainMissing(t *testing.T) IncrementSequenceNum: true, Operations: []Operation{&op}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(1000), + Preconditions: NewPreconditions(NewTimeout(1000)), }, network.TestNetworkPassphrase, serverKP, clientKP, @@ -3558,7 +3529,7 @@ func TestVerifyChallengeTxThreshold_invalidWebAuthDomainSourceAccount(t *testing IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(1000), + Preconditions: NewPreconditions(NewTimeout(1000)), }, network.TestNetworkPassphrase, serverKP, clientKP, @@ -3594,7 +3565,7 @@ func TestVerifyChallengeTxThreshold_invalidWebAuthDomain(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(1000), + Preconditions: NewPreconditions(NewTimeout(1000)), }, network.TestNetworkPassphrase, serverKP, clientKP, @@ -3630,7 +3601,7 @@ func TestVerifyChallengeTxSigners_invalidServer(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(1000), + Preconditions: NewPreconditions(NewTimeout(1000)), }, network.TestNetworkPassphrase, clientKP, @@ -3663,7 +3634,7 @@ func TestVerifyChallengeTxSigners_validServerAndClientMasterKey(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(1000), + Preconditions: NewPreconditions(NewTimeout(1000)), }, network.TestNetworkPassphrase, serverKP, clientKP, @@ -3696,7 +3667,7 @@ func TestVerifyChallengeTxSigners_invalidServerAndNoClient(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(1000), + Preconditions: NewPreconditions(NewTimeout(1000)), }, network.TestNetworkPassphrase, serverKP, @@ -3730,7 +3701,7 @@ func TestVerifyChallengeTxSigners_invalidServerAndUnrecognizedClient(t *testing. IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(1000), + Preconditions: NewPreconditions(NewTimeout(1000)), }, network.TestNetworkPassphrase, serverKP, unrecognizedKP, @@ -3764,7 +3735,7 @@ func TestVerifyChallengeTxSigners_validServerAndMultipleClientSigners(t *testing IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(1000), + Preconditions: NewPreconditions(NewTimeout(1000)), }, network.TestNetworkPassphrase, serverKP, clientKP, clientKP2, @@ -3798,7 +3769,7 @@ func TestVerifyChallengeTxSigners_validServerAndMultipleClientSignersReverseOrde IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(1000), + Preconditions: NewPreconditions(NewTimeout(1000)), }, network.TestNetworkPassphrase, serverKP, clientKP2, clientKP, @@ -3832,7 +3803,7 @@ func TestVerifyChallengeTxSigners_validServerAndClientSignersNotMasterKey(t *tes IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(1000), + Preconditions: NewPreconditions(NewTimeout(1000)), }, network.TestNetworkPassphrase, serverKP, clientKP2, @@ -3866,7 +3837,7 @@ func TestVerifyChallengeTxSigners_validServerAndClientSignersIgnoresServerSigner IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(1000), + Preconditions: NewPreconditions(NewTimeout(1000)), }, network.TestNetworkPassphrase, serverKP, clientKP2, @@ -3900,7 +3871,7 @@ func TestVerifyChallengeTxSigners_invalidServerNoClientSignersIgnoresServerSigne IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(1000), + Preconditions: NewPreconditions(NewTimeout(1000)), }, network.TestNetworkPassphrase, serverKP, @@ -3934,7 +3905,7 @@ func TestVerifyChallengeTxSigners_validServerAndClientSignersIgnoresDuplicateSig IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(1000), + Preconditions: NewPreconditions(NewTimeout(1000)), }, network.TestNetworkPassphrase, serverKP, clientKP2, @@ -3971,7 +3942,7 @@ func TestVerifyChallengeTxSigners_validIgnorePreauthTxHashAndXHash(t *testing.T) IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(1000), + Preconditions: NewPreconditions(NewTimeout(1000)), }, network.TestNetworkPassphrase, serverKP, clientKP2, @@ -4005,7 +3976,7 @@ func TestVerifyChallengeTxSigners_invalidServerAndClientSignersIgnoresDuplicateS IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(1000), + Preconditions: NewPreconditions(NewTimeout(1000)), }, network.TestNetworkPassphrase, serverKP, clientKP2, @@ -4039,7 +4010,7 @@ func TestVerifyChallengeTxSigners_invalidServerAndClientSignersFailsDuplicateSig IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(1000), + Preconditions: NewPreconditions(NewTimeout(1000)), }, network.TestNetworkPassphrase, serverKP, clientKP2, clientKP2, @@ -4073,7 +4044,7 @@ func TestVerifyChallengeTxSigners_invalidServerAndClientSignersFailsSignerSeed(t IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(1000), + Preconditions: NewPreconditions(NewTimeout(1000)), }, network.TestNetworkPassphrase, serverKP, clientKP2, @@ -4106,7 +4077,7 @@ func TestVerifyChallengeTxSigners_invalidNoSigners(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(1000), + Preconditions: NewPreconditions(NewTimeout(1000)), }, network.TestNetworkPassphrase, serverKP, clientKP, @@ -4138,7 +4109,7 @@ func TestVerifyChallengeTxSigners_doesVerifyHomeDomainFailure(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(1000), + Preconditions: NewPreconditions(NewTimeout(1000)), }, network.TestNetworkPassphrase, serverKP, clientKP, @@ -4170,7 +4141,7 @@ func TestVerifyChallengeTxSigners_matchesHomeDomain(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op1, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(300), + Preconditions: NewPreconditions(NewTimeout(300)), }, ) assert.NoError(t, err) @@ -4210,7 +4181,7 @@ func TestVerifyChallengeTxSigners_doesNotMatchHomeDomain(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op1, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(300), + Preconditions: NewPreconditions(NewTimeout(300)), }, ) assert.NoError(t, err) @@ -4250,7 +4221,7 @@ func TestVerifyChallengeTxSigners_doesVerifyHomeDomainSuccess(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(1000), + Preconditions: NewPreconditions(NewTimeout(1000)), }, network.TestNetworkPassphrase, serverKP, clientKP, @@ -4287,7 +4258,7 @@ func TestVerifyChallengeTxSigners_allowsAdditionalManageDataOpsWithSourceAccount IncrementSequenceNum: true, Operations: []Operation{&op1, &op2, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(1000), + Preconditions: NewPreconditions(NewTimeout(1000)), }, network.TestNetworkPassphrase, serverKP, clientKP, @@ -4325,7 +4296,7 @@ func TestVerifyChallengeTxSigners_disallowsAdditionalManageDataOpsWithoutSourceA IncrementSequenceNum: true, Operations: []Operation{&op1, &op2, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(1000), + Preconditions: NewPreconditions(NewTimeout(1000)), }, network.TestNetworkPassphrase, serverKP, clientKP, @@ -4362,7 +4333,7 @@ func TestVerifyChallengeTxSigners_disallowsAdditionalOpsOfOtherTypes(t *testing. IncrementSequenceNum: true, Operations: []Operation{&op1, &op2, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(1000), + Preconditions: NewPreconditions(NewTimeout(1000)), }, network.TestNetworkPassphrase, serverKP, clientKP, @@ -4389,7 +4360,7 @@ func TestVerifyChallengeTxSigners_validWhenWebAuthDomainMissing(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(1000), + Preconditions: NewPreconditions(NewTimeout(1000)), }, network.TestNetworkPassphrase, serverKP, clientKP, @@ -4423,7 +4394,7 @@ func TestVerifyChallengeTxSigners_invalidWebAuthDomainSourceAccount(t *testing.T IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(1000), + Preconditions: NewPreconditions(NewTimeout(1000)), }, network.TestNetworkPassphrase, serverKP, clientKP, @@ -4454,7 +4425,7 @@ func TestVerifyChallengeTxSigners_invalidWebAuthDomain(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(1000), + Preconditions: NewPreconditions(NewTimeout(1000)), }, network.TestNetworkPassphrase, serverKP, clientKP, @@ -4480,7 +4451,7 @@ func TestVerifyTxSignatureUnsignedTx(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&createAccount}, BaseFee: MinBaseFee, - Timebounds: NewTimeout(1000), + Preconditions: NewPreconditions(NewTimeout(1000)), }, ) assert.NoError(t, err) @@ -4506,7 +4477,7 @@ func TestVerifyTxSignatureSingle(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&createAccount}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) assert.NoError(t, err) @@ -4532,7 +4503,7 @@ func TestVerifyTxSignatureMultiple(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&createAccount}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) assert.NoError(t, err) @@ -4560,7 +4531,7 @@ func TestVerifyTxSignatureInvalid(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&createAccount}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) assert.NoError(t, err) @@ -4595,7 +4566,7 @@ func TestClaimableBalanceIds(t *testing.T) { SourceAccount: &aMuxedAccount, IncrementSequenceNum: true, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), Operations: []Operation{&claimableBalanceEntry}, }, ) @@ -4630,7 +4601,7 @@ func TestTransaction_marshalUnmarshalText(t *testing.T) { SourceAccount: &SimpleAccount{AccountID: k.Address(), Sequence: 1}, IncrementSequenceNum: false, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), Operations: []Operation{&BumpSequence{BumpTo: 2}}, }, ) @@ -4664,7 +4635,7 @@ func TestFeeBumpTransaction_marshalUnmarshalText(t *testing.T) { SourceAccount: &SimpleAccount{AccountID: k.Address(), Sequence: 1}, IncrementSequenceNum: false, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), Operations: []Operation{&BumpSequence{BumpTo: 2}}, }, ) @@ -4704,7 +4675,7 @@ func TestNewGenericTransactionWithTransaction(t *testing.T) { SourceAccount: &SimpleAccount{AccountID: k.Address(), Sequence: 1}, IncrementSequenceNum: false, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), Operations: []Operation{&BumpSequence{BumpTo: 2}}, }, ) @@ -4723,7 +4694,7 @@ func TestNewGenericTransactionWithFeeBumpTransaction(t *testing.T) { SourceAccount: &SimpleAccount{AccountID: k.Address(), Sequence: 1}, IncrementSequenceNum: false, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), Operations: []Operation{&BumpSequence{BumpTo: 2}}, }, ) @@ -4755,7 +4726,7 @@ func TestGenericTransaction_marshalUnmarshalText(t *testing.T) { SourceAccount: &SimpleAccount{AccountID: k.Address(), Sequence: 1}, IncrementSequenceNum: false, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), Operations: []Operation{&BumpSequence{BumpTo: 2}}, }, ) @@ -4812,7 +4783,7 @@ func TestGenericTransaction_marshalBinary(t *testing.T) { SourceAccount: &SimpleAccount{AccountID: k.Address(), Sequence: 1}, IncrementSequenceNum: false, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), Operations: []Operation{&BumpSequence{BumpTo: 2}}, }, ) @@ -4858,7 +4829,7 @@ func TestGenericTransaction_HashHex(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&createAccount}, BaseFee: MinBaseFee, - Timebounds: NewInfiniteTimeout(), + Preconditions: NewPreconditions(NewInfiniteTimeout()), }, ) assert.NoError(t, err) From cf15638a3a37082474716b077d555d863a7d2d31 Mon Sep 17 00:00:00 2001 From: George Kudrayvtsev Date: Thu, 24 Mar 2022 12:34:57 -0700 Subject: [PATCH 10/19] Add round-trip to ensure decoding from XDR works correctly --- txnbuild/preconditions.go | 47 ++++++++++++++++++++++++++++++++++ txnbuild/preconditions_test.go | 9 +++++++ 2 files changed, 56 insertions(+) diff --git a/txnbuild/preconditions.go b/txnbuild/preconditions.go index 08e0cea2ee..8624b7fa04 100644 --- a/txnbuild/preconditions.go +++ b/txnbuild/preconditions.go @@ -109,6 +109,53 @@ func (cond *Preconditions) BuildXDR() xdr.Preconditions { return xdrCond } +// FromXDR fills in the precondition structure from an xdr.Precondition. +func (cond *Preconditions) FromXDR(precondXdr xdr.Preconditions) { + *cond = Preconditions{} // reset existing values + + switch precondXdr.Type { + case xdr.PreconditionTypePrecondTime: + cond.Timebounds = NewTimebounds( + int64(precondXdr.TimeBounds.MinTime), + int64(precondXdr.TimeBounds.MaxTime), + ) + + case xdr.PreconditionTypePrecondV2: + inner := precondXdr.V2 + + if inner.TimeBounds != nil { + cond.Timebounds = NewTimebounds( + int64(inner.TimeBounds.MinTime), + int64(inner.TimeBounds.MaxTime), + ) + } + + if inner.LedgerBounds != nil { + cond.Ledgerbounds = &Ledgerbounds{ + MinLedger: uint32(inner.LedgerBounds.MinLedger), + MaxLedger: uint32(inner.LedgerBounds.MaxLedger), + } + } + + if inner.MinSeqNum != nil { + minSeqNum := int64(*inner.MinSeqNum) + cond.MinSequenceNumber = &minSeqNum + } + + cond.MinSequenceNumberAge = inner.MinSeqAge + cond.MinSequenceNumberLedgerGap = uint32(inner.MinSeqLedgerGap) + + if len(inner.ExtraSigners) > 0 { + cond.ExtraSigners = make([]xdr.SignerKey, len(inner.ExtraSigners)) + copy(cond.ExtraSigners[:], inner.ExtraSigners) + } + + case xdr.PreconditionTypePrecondNone: + default: + // panic? + } +} + // hasV2Conditions determines whether or not this has conditions on top of // the (required) timebound precondition. func (cond *Preconditions) hasV2Conditions() bool { diff --git a/txnbuild/preconditions_test.go b/txnbuild/preconditions_test.go index f9c8952ed9..46d3bcdb0b 100644 --- a/txnbuild/preconditions_test.go +++ b/txnbuild/preconditions_test.go @@ -121,6 +121,15 @@ func TestPreconditions(t *testing.T) { assert.NoError(t, err) assert.Equal(t, expectedBytes, actualBytes) + + actualXdr := xdr.Preconditions{} + err = actualXdr.UnmarshalBinary(actualBytes) + assert.NoError(t, err) + assert.Equal(t, xdrPrecond, actualXdr) + + roundTripPrecond := Preconditions{} + roundTripPrecond.FromXDR(actualXdr) + assert.Equal(t, precond, roundTripPrecond) }) } } From f6ffe3f6f39a086d4dd0a2a0393bf279405c3c08 Mon Sep 17 00:00:00 2001 From: George Kudrayvtsev Date: Thu, 24 Mar 2022 12:38:48 -0700 Subject: [PATCH 11/19] Simplify validation, more tests --- txnbuild/preconditions.go | 8 ++------ txnbuild/preconditions_test.go | 11 +++++++---- txnbuild/transaction.go | 3 ++- 3 files changed, 11 insertions(+), 11 deletions(-) diff --git a/txnbuild/preconditions.go b/txnbuild/preconditions.go index 8624b7fa04..312a823473 100644 --- a/txnbuild/preconditions.go +++ b/txnbuild/preconditions.go @@ -48,8 +48,8 @@ func (cond *Preconditions) Validate() error { return err } - if ok := cond.ValidateSigners(); !ok { - return errors.New("invalid signers") + if len(cond.ExtraSigners) > 2 { + return errors.New("only 2 extra signers allowed") } if cond.Ledgerbounds != nil { @@ -62,10 +62,6 @@ func (cond *Preconditions) Validate() error { return nil } -func (cond *Preconditions) ValidateSigners() bool { - return len(cond.ExtraSigners) <= 2 -} - // BuildXDR will create a precondition structure that varies depending on // whether or not there are additional preconditions besides timebounds (which // are required). diff --git a/txnbuild/preconditions_test.go b/txnbuild/preconditions_test.go index 46d3bcdb0b..d5cb726c02 100644 --- a/txnbuild/preconditions_test.go +++ b/txnbuild/preconditions_test.go @@ -136,11 +136,14 @@ func TestPreconditions(t *testing.T) { // TestPreconditionsValidation ensures that validation fails when necessary. func TestPreconditionsValidation(t *testing.T) { - pc := NewPreconditionsWithTimebounds(27, 42) - pc.ExtraSigners = Signers - t.Run("too many signers", func(t *testing.T) { - pc.ExtraSigners = Signers + pc := NewPreconditionsWithTimebounds(27, 42) + assert.Error(t, pc.Validate()) + }) + + t.Run("nonsense ledgerbounds", func(t *testing.T) { + pc := NewPreconditionsWithTimebounds(27, 42) + pc.Ledgerbounds = &Ledgerbounds{MinLedger: 42, MaxLedger: 1} assert.Error(t, pc.Validate()) }) } diff --git a/txnbuild/transaction.go b/txnbuild/transaction.go index 5ebd16b16c..1ba1db9410 100644 --- a/txnbuild/transaction.go +++ b/txnbuild/transaction.go @@ -849,7 +849,8 @@ func NewTransaction(params TransactionParams) (*Transaction, error) { // if maxFee is negative then there must have been an int overflow hi, lo := bits.Mul64(uint64(params.BaseFee), uint64(len(params.Operations))) if hi > 0 || lo > math.MaxUint32 { - return nil, errors.Errorf("base fee %d results in an overflow of max fee", params.BaseFee) + return nil, errors.Errorf( + "base fee %d results in an overflow of max fee", params.BaseFee) } tx.maxFee = int64(lo) From 1ff9f67815d53dfbc3c3fa73d9aa3cdd1b74ad48 Mon Sep 17 00:00:00 2001 From: George Kudrayvtsev Date: Thu, 24 Mar 2022 13:03:54 -0700 Subject: [PATCH 12/19] Clean up validation --- txnbuild/ledgerbounds.go | 4 ++++ txnbuild/preconditions.go | 15 +++++---------- txnbuild/preconditions_test.go | 6 +++++- 3 files changed, 14 insertions(+), 11 deletions(-) diff --git a/txnbuild/ledgerbounds.go b/txnbuild/ledgerbounds.go index 673100877d..299711ac95 100644 --- a/txnbuild/ledgerbounds.go +++ b/txnbuild/ledgerbounds.go @@ -11,6 +11,10 @@ type Ledgerbounds struct { } func (lb *Ledgerbounds) Validate() error { + if lb == nil { + return nil + } + if lb.MaxLedger > 0 && lb.MaxLedger < lb.MinLedger { return errors.New("invalid ledgerbound: max ledger < min ledger") } diff --git a/txnbuild/preconditions.go b/txnbuild/preconditions.go index 312a823473..4f61d333fb 100644 --- a/txnbuild/preconditions.go +++ b/txnbuild/preconditions.go @@ -7,9 +7,7 @@ import ( // Preconditions is a container for all transaction preconditions. type Preconditions struct { - // Transaction is only valid during a certain time range. This is private - // because it should mirror the one set via TransactionParams, and this - // association should be done via `NewPreconditions()`. + // Transaction is only valid during a certain time range. Timebounds Timebounds // Transaction is valid for ledger numbers n such that minLedger <= n < // maxLedger (if maxLedger == 0, then only minLedger is checked) @@ -48,15 +46,12 @@ func (cond *Preconditions) Validate() error { return err } - if len(cond.ExtraSigners) > 2 { - return errors.New("only 2 extra signers allowed") + if err = cond.Ledgerbounds.Validate(); err != nil { + return err } - if cond.Ledgerbounds != nil { - err = cond.Ledgerbounds.Validate() - if err != nil { - return err - } + if len(cond.ExtraSigners) > 2 { + return errors.New("only 2 extra signers allowed") } return nil diff --git a/txnbuild/preconditions_test.go b/txnbuild/preconditions_test.go index d5cb726c02..5d88a97ee9 100644 --- a/txnbuild/preconditions_test.go +++ b/txnbuild/preconditions_test.go @@ -137,7 +137,11 @@ func TestPreconditions(t *testing.T) { // TestPreconditionsValidation ensures that validation fails when necessary. func TestPreconditionsValidation(t *testing.T) { t.Run("too many signers", func(t *testing.T) { - pc := NewPreconditionsWithTimebounds(27, 42) + pc := Preconditions{ + Timebounds: NewTimebounds(27, 42), + ExtraSigners: Signers, + } + assert.Error(t, pc.Validate()) }) From 8de0e23c5ff540d45847fafe482975700510926f Mon Sep 17 00:00:00 2001 From: George Kudrayvtsev Date: Thu, 24 Mar 2022 13:04:01 -0700 Subject: [PATCH 13/19] Drop Preconditions constructors --- clients/horizonclient/examples_test.go | 10 +- clients/horizonclient/main_test.go | 16 +- .../account_sign_signing_address_test.go | 30 +- .../webauth/internal/serve/token_test.go | 8 +- services/friendbot/init_friendbot.go | 2 +- services/friendbot/internal/minion.go | 2 +- .../integration/negative_seq_txsub_test.go | 2 +- .../internal/integration/sponsorship_test.go | 2 +- .../internal/test/integration/integration.go | 2 +- .../configureissuer/configureissuer.go | 2 +- .../internal/serve/api_tx_approve_test.go | 8 +- .../internal/serve/friendbot.go | 2 +- .../internal/serve/tx_approve.go | 2 +- .../internal/serve/tx_approve_test.go | 44 +-- txnbuild/account_merge_test.go | 2 +- txnbuild/allow_trust_test.go | 4 +- txnbuild/bump_sequence_test.go | 2 +- txnbuild/change_trust_test.go | 6 +- txnbuild/clawback_test.go | 6 +- txnbuild/cmd/demo/operations/demo.go | 14 +- txnbuild/create_account_test.go | 4 +- txnbuild/create_claimable_balance_test.go | 2 +- txnbuild/create_passive_offer_test.go | 8 +- txnbuild/example_test.go | 56 ++-- txnbuild/fee_bump_test.go | 16 +- txnbuild/manage_buy_offer_test.go | 10 +- txnbuild/manage_data_test.go | 6 +- txnbuild/manage_offer_test.go | 10 +- txnbuild/operation_test.go | 4 +- txnbuild/path_payment_strict_send_test.go | 10 +- txnbuild/path_payment_test.go | 10 +- txnbuild/payment_test.go | 6 +- txnbuild/preconditions.go | 10 - txnbuild/preconditions_test.go | 8 +- txnbuild/signers_test.go | 32 +- txnbuild/transaction.go | 20 +- txnbuild/transaction_fee_test.go | 14 +- txnbuild/transaction_test.go | 280 +++++++++--------- xdr/transaction_envelope.go | 20 ++ 39 files changed, 356 insertions(+), 336 deletions(-) diff --git a/clients/horizonclient/examples_test.go b/clients/horizonclient/examples_test.go index 51387dc648..3494014fab 100644 --- a/clients/horizonclient/examples_test.go +++ b/clients/horizonclient/examples_test.go @@ -1100,7 +1100,7 @@ func ExampleClient_SubmitFeeBumpTransaction() { IncrementSequenceNum: false, Operations: []txnbuild.Operation{&op}, BaseFee: txnbuild.MinBaseFee, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewInfiniteTimeout()), // Use a real timeout in production! + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewInfiniteTimeout()}, // Use a real timeout in production! }, ) if err != nil { @@ -1154,7 +1154,7 @@ func ExampleClient_SubmitFeeBumpTransactionWithOptions() { IncrementSequenceNum: false, Operations: []txnbuild.Operation{&op}, BaseFee: txnbuild.MinBaseFee, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewInfiniteTimeout()), // Use a real timeout in production! + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewInfiniteTimeout()}, // Use a real timeout in production! }, ) if err != nil { @@ -1211,7 +1211,7 @@ func ExampleClient_SubmitTransaction() { IncrementSequenceNum: false, Operations: []txnbuild.Operation{&op}, BaseFee: txnbuild.MinBaseFee, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewInfiniteTimeout()), // Use a real timeout in production! + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewInfiniteTimeout()}, // Use a real timeout in production! }, ) if err != nil { @@ -1253,7 +1253,7 @@ func ExampleClient_SubmitTransactionWithOptions() { IncrementSequenceNum: false, Operations: []txnbuild.Operation{&op}, BaseFee: txnbuild.MinBaseFee, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewInfiniteTimeout()), // Use a real timeout in production! + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewInfiniteTimeout()}, // Use a real timeout in production! }, ) if err != nil { @@ -1295,7 +1295,7 @@ func ExampleClient_SubmitTransactionWithOptions_skip_memo_required_check() { IncrementSequenceNum: false, Operations: []txnbuild.Operation{&op}, BaseFee: txnbuild.MinBaseFee, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewInfiniteTimeout()), // Use a real timeout in production! + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewInfiniteTimeout()}, // Use a real timeout in production! }, ) if err != nil { diff --git a/clients/horizonclient/main_test.go b/clients/horizonclient/main_test.go index 2c686147a7..9dcee565af 100644 --- a/clients/horizonclient/main_test.go +++ b/clients/horizonclient/main_test.go @@ -146,7 +146,7 @@ func TestCheckMemoRequired(t *testing.T) { IncrementSequenceNum: true, Operations: tc.operations, BaseFee: txnbuild.MinBaseFee, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimebounds(0, 10)), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewTimebounds(0, 10)}, }, ) tt.NoError(err) @@ -878,7 +878,7 @@ func TestSubmitTransactionRequest(t *testing.T) { IncrementSequenceNum: true, Operations: []txnbuild.Operation{&payment}, BaseFee: txnbuild.MinBaseFee, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimebounds(0, 10)), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewTimebounds(0, 10)}, }, ) assert.NoError(t, err) @@ -946,7 +946,7 @@ func TestSubmitTransactionRequestMuxedAccounts(t *testing.T) { IncrementSequenceNum: true, Operations: []txnbuild.Operation{&payment}, BaseFee: txnbuild.MinBaseFee, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimebounds(0, 10)), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewTimebounds(0, 10)}, }, ) assert.NoError(t, err) @@ -1006,7 +1006,7 @@ func TestSubmitFeeBumpTransaction(t *testing.T) { IncrementSequenceNum: true, Operations: []txnbuild.Operation{&payment}, BaseFee: txnbuild.MinBaseFee, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimebounds(0, 10)), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewTimebounds(0, 10)}, }, ) assert.NoError(t, err) @@ -1075,7 +1075,7 @@ func TestSubmitTransactionWithOptionsRequest(t *testing.T) { IncrementSequenceNum: true, Operations: []txnbuild.Operation{&payment}, BaseFee: txnbuild.MinBaseFee, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimebounds(0, 10)), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewTimebounds(0, 10)}, }, ) assert.NoError(t, err) @@ -1168,7 +1168,7 @@ func TestSubmitTransactionWithOptionsRequest(t *testing.T) { Operations: []txnbuild.Operation{&payment}, BaseFee: txnbuild.MinBaseFee, Memo: txnbuild.MemoText("HelloWorld"), - Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimebounds(0, 10)), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewTimebounds(0, 10)}, }, ) assert.NoError(t, err) @@ -1202,7 +1202,7 @@ func TestSubmitFeeBumpTransactionWithOptions(t *testing.T) { IncrementSequenceNum: true, Operations: []txnbuild.Operation{&payment}, BaseFee: txnbuild.MinBaseFee, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimebounds(0, 10)), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewTimebounds(0, 10)}, }, ) assert.NoError(t, err) @@ -1293,7 +1293,7 @@ func TestSubmitFeeBumpTransactionWithOptions(t *testing.T) { Operations: []txnbuild.Operation{&payment}, BaseFee: txnbuild.MinBaseFee, Memo: txnbuild.MemoText("HelloWorld"), - Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimebounds(0, 10)), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewTimebounds(0, 10)}, }, ) assert.NoError(t, err) diff --git a/exp/services/recoverysigner/internal/serve/account_sign_signing_address_test.go b/exp/services/recoverysigner/internal/serve/account_sign_signing_address_test.go index 65bd31e84d..c7b3289610 100644 --- a/exp/services/recoverysigner/internal/serve/account_sign_signing_address_test.go +++ b/exp/services/recoverysigner/internal/serve/account_sign_signing_address_test.go @@ -350,7 +350,7 @@ func TestAccountSign_signingAddressAccountAuthenticatedButSigningAddressInvalid( }, }, BaseFee: txnbuild.MinBaseFee, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimebounds(0, 1)), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewTimebounds(0, 1)}, }, ) require.NoError(t, err) @@ -412,7 +412,7 @@ func TestAccountSign_signingAddressAccountAuthenticatedOtherSignerSelected(t *te }, }, BaseFee: txnbuild.MinBaseFee, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimebounds(0, 1)), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewTimebounds(0, 1)}, }, ) require.NoError(t, err) @@ -478,7 +478,7 @@ func TestAccountSign_signingAddressAccountAuthenticatedTxSourceAccountValid(t *t }, }, BaseFee: txnbuild.MinBaseFee, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimebounds(0, 1)), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewTimebounds(0, 1)}, }, ) require.NoError(t, err) @@ -545,7 +545,7 @@ func TestAccountSign_signingAddressAccountAuthenticatedTxAndOpSourceAccountValid }, }, BaseFee: txnbuild.MinBaseFee, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimebounds(0, 1)), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewTimebounds(0, 1)}, }, ) require.NoError(t, err) @@ -611,7 +611,7 @@ func TestAccountSign_signingAddressAccountAuthenticatedTxSourceAccountInvalid(t }, }, BaseFee: txnbuild.MinBaseFee, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimebounds(0, 1)), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewTimebounds(0, 1)}, }, ) require.NoError(t, err) @@ -674,7 +674,7 @@ func TestAccountSign_signingAddressAccountAuthenticatedOpSourceAccountInvalid(t }, }, BaseFee: txnbuild.MinBaseFee, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimebounds(0, 1)), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewTimebounds(0, 1)}, }, ) require.NoError(t, err) @@ -738,7 +738,7 @@ func TestAccountSign_signingAddressAccountAuthenticatedTxAndOpSourceAccountInval }, }, BaseFee: txnbuild.MinBaseFee, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimebounds(0, 1)), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewTimebounds(0, 1)}, }, ) require.NoError(t, err) @@ -807,7 +807,7 @@ func TestAccountSign_signingAddressPhoneNumberOwnerAuthenticated(t *testing.T) { }, }, BaseFee: txnbuild.MinBaseFee, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimebounds(0, 1)), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewTimebounds(0, 1)}, }, ) require.NoError(t, err) @@ -879,7 +879,7 @@ func TestAccountSign_signingAddressPhoneNumberOtherAuthenticated(t *testing.T) { }, }, BaseFee: txnbuild.MinBaseFee, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimebounds(0, 1)), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewTimebounds(0, 1)}, }, ) require.NoError(t, err) @@ -951,7 +951,7 @@ func TestAccountSign_signingAddressEmailOwnerAuthenticated(t *testing.T) { }, }, BaseFee: txnbuild.MinBaseFee, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimebounds(0, 1)), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewTimebounds(0, 1)}, }, ) require.NoError(t, err) @@ -1032,7 +1032,7 @@ func TestAccountSign_signingAddressEmailOwnerAuthenticatedOpSourceAccountIsAllow &txnbuild.EndSponsoringFutureReserves{}, }, BaseFee: txnbuild.MinBaseFee, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimebounds(0, 1)), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewTimebounds(0, 1)}, }, ) require.NoError(t, err) @@ -1109,7 +1109,7 @@ func TestAccountSign_signingAddressEmailOwnerAuthenticatedOpSourceAccountInvalid &txnbuild.EndSponsoringFutureReserves{}, }, BaseFee: txnbuild.MinBaseFee, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimebounds(0, 1)), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewTimebounds(0, 1)}, }, ) require.NoError(t, err) @@ -1176,7 +1176,7 @@ func TestAccountSign_signingAddressEmailOtherAuthenticated(t *testing.T) { }, }, BaseFee: txnbuild.MinBaseFee, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimebounds(0, 1)), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewTimebounds(0, 1)}, }, ) require.NoError(t, err) @@ -1282,7 +1282,7 @@ func TestAccountSign_signingAddressRejectsFeeBumpTx(t *testing.T) { }, }, BaseFee: txnbuild.MinBaseFee, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimebounds(0, 1)), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewTimebounds(0, 1)}, }, ) require.NoError(t, err) @@ -1352,7 +1352,7 @@ func TestAccountSign_signingAddressValidContentTypeForm(t *testing.T) { }, }, BaseFee: txnbuild.MinBaseFee, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimebounds(0, 1)), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewTimebounds(0, 1)}, }, ) require.NoError(t, err) diff --git a/exp/services/webauth/internal/serve/token_test.go b/exp/services/webauth/internal/serve/token_test.go index 2134f14752..367c941b56 100644 --- a/exp/services/webauth/internal/serve/token_test.go +++ b/exp/services/webauth/internal/serve/token_test.go @@ -1136,9 +1136,11 @@ func TestToken_jsonInputNoWebAuthDomainSuccess(t *testing.T) { Value: []byte("ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg"), }, }, - BaseFee: txnbuild.MinBaseFee, - Memo: nil, - Preconditions: txnbuild.NewPreconditionsWithTimebounds(txMinTimebounds, txMaxTimebounds), + BaseFee: txnbuild.MinBaseFee, + Memo: nil, + Preconditions: txnbuild.Preconditions{ + Timebounds: txnbuild.NewTimebounds(txMinTimebounds, txMaxTimebounds), + }, }, ) require.NoError(t, err) diff --git a/services/friendbot/init_friendbot.go b/services/friendbot/init_friendbot.go index 27ee56d6fc..19c45f96b2 100644 --- a/services/friendbot/init_friendbot.go +++ b/services/friendbot/init_friendbot.go @@ -120,7 +120,7 @@ func createMinionAccounts(botAccount internal.Account, botKeypair *keypair.Full, IncrementSequenceNum: true, Operations: ops, BaseFee: txnbuild.MinBaseFee, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimeout(300)), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewTimeout(300)}, }, ) if err != nil { diff --git a/services/friendbot/internal/minion.go b/services/friendbot/internal/minion.go index 707815c1fe..a27e5a3296 100644 --- a/services/friendbot/internal/minion.go +++ b/services/friendbot/internal/minion.go @@ -117,7 +117,7 @@ func (minion *Minion) makeTx(destAddress string) (string, error) { IncrementSequenceNum: true, Operations: []txnbuild.Operation{&createAccountOp}, BaseFee: minion.BaseFee, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewInfiniteTimeout()), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewInfiniteTimeout()}, }, ) if err != nil { diff --git a/services/horizon/internal/integration/negative_seq_txsub_test.go b/services/horizon/internal/integration/negative_seq_txsub_test.go index 63a6c3ec20..572a682e52 100644 --- a/services/horizon/internal/integration/negative_seq_txsub_test.go +++ b/services/horizon/internal/integration/negative_seq_txsub_test.go @@ -55,7 +55,7 @@ func TestNegativeSequenceTxSubmission(t *testing.T) { SourceAccount: account, Operations: []txnbuild.Operation{&op2}, BaseFee: txnbuild.MinBaseFee, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewInfiniteTimeout()), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewInfiniteTimeout()}, IncrementSequenceNum: false, } tx, err := txnbuild.NewTransaction(txParams) diff --git a/services/horizon/internal/integration/sponsorship_test.go b/services/horizon/internal/integration/sponsorship_test.go index c1675a0ead..af2ae7ea10 100644 --- a/services/horizon/internal/integration/sponsorship_test.go +++ b/services/horizon/internal/integration/sponsorship_test.go @@ -311,7 +311,7 @@ func TestSponsorships(t *testing.T) { SourceAccount: newAccount, Operations: []txnbuild.Operation{preAuthOp}, BaseFee: txnbuild.MinBaseFee, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewInfiniteTimeout()), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewInfiniteTimeout()}, IncrementSequenceNum: true, } preaAuthTx, err := txnbuild.NewTransaction(txParams) diff --git a/services/horizon/internal/test/integration/integration.go b/services/horizon/internal/test/integration/integration.go index 60d11dae4f..1a485d2a94 100644 --- a/services/horizon/internal/test/integration/integration.go +++ b/services/horizon/internal/test/integration/integration.go @@ -694,7 +694,7 @@ func (i *Test) CreateSignedTransaction( SourceAccount: source, Operations: ops, BaseFee: txnbuild.MinBaseFee, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewInfiniteTimeout()), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewInfiniteTimeout()}, IncrementSequenceNum: true, } diff --git a/services/regulated-assets-approval-server/internal/configureissuer/configureissuer.go b/services/regulated-assets-approval-server/internal/configureissuer/configureissuer.go index acbe665f1e..ba3cdb8050 100644 --- a/services/regulated-assets-approval-server/internal/configureissuer/configureissuer.go +++ b/services/regulated-assets-approval-server/internal/configureissuer/configureissuer.go @@ -120,7 +120,7 @@ func setup(opts Options, hClient horizonclient.ClientInterface) error { }, }, BaseFee: 300, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimeout(300)), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewTimeout(300)}, }) if err != nil { return errors.Wrap(err, "building transaction") diff --git a/services/regulated-assets-approval-server/internal/serve/api_tx_approve_test.go b/services/regulated-assets-approval-server/internal/serve/api_tx_approve_test.go index 7e4cee2041..47f0af2f13 100644 --- a/services/regulated-assets-approval-server/internal/serve/api_tx_approve_test.go +++ b/services/regulated-assets-approval-server/internal/serve/api_tx_approve_test.go @@ -115,7 +115,7 @@ func TestAPI_txApprove_revised(t *testing.T) { }, }, BaseFee: txnbuild.MinBaseFee, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewInfiniteTimeout()), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewInfiniteTimeout()}, }, ) require.NoError(t, err) @@ -235,7 +235,7 @@ func TestAPI_txAprove_actionRequired(t *testing.T) { }, }, BaseFee: txnbuild.MinBaseFee, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewInfiniteTimeout()), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewInfiniteTimeout()}, }, ) require.NoError(t, err) @@ -328,7 +328,7 @@ func TestAPI_txAprove_actionRequiredFlow(t *testing.T) { }, }, BaseFee: txnbuild.MinBaseFee, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewInfiniteTimeout()), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewInfiniteTimeout()}, }, ) require.NoError(t, err) @@ -539,7 +539,7 @@ func TestAPI_txApprove_success(t *testing.T) { }, }, BaseFee: 300, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimeout(300)), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewTimeout(300)}, }) require.NoError(t, err) txe, err := tx.Base64() diff --git a/services/regulated-assets-approval-server/internal/serve/friendbot.go b/services/regulated-assets-approval-server/internal/serve/friendbot.go index 8f3ccdfeb0..9adc1b56c2 100644 --- a/services/regulated-assets-approval-server/internal/serve/friendbot.go +++ b/services/regulated-assets-approval-server/internal/serve/friendbot.go @@ -158,7 +158,7 @@ func (h friendbotHandler) topUpAccountWithRegulatedAsset(ctx context.Context, in }, }, BaseFee: 300, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimeout(300)), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewTimeout(300)}, }) if err != nil { err = errors.Wrap(err, "building transaction") diff --git a/services/regulated-assets-approval-server/internal/serve/tx_approve.go b/services/regulated-assets-approval-server/internal/serve/tx_approve.go index 121e008a84..ff1f9dee00 100644 --- a/services/regulated-assets-approval-server/internal/serve/tx_approve.go +++ b/services/regulated-assets-approval-server/internal/serve/tx_approve.go @@ -231,7 +231,7 @@ func (h txApproveHandler) txApprove(ctx context.Context, in txApproveRequest) (r IncrementSequenceNum: true, Operations: revisedOperations, BaseFee: 300, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimeout(300)), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewTimeout(300)}, }) if err != nil { return nil, errors.Wrap(err, "building transaction") diff --git a/services/regulated-assets-approval-server/internal/serve/tx_approve_test.go b/services/regulated-assets-approval-server/internal/serve/tx_approve_test.go index 53b4dd57e1..fcdb548f45 100644 --- a/services/regulated-assets-approval-server/internal/serve/tx_approve_test.go +++ b/services/regulated-assets-approval-server/internal/serve/tx_approve_test.go @@ -143,7 +143,7 @@ func TestTxApproveHandler_validateInput(t *testing.T) { Sequence: "1", }, IncrementSequenceNum: true, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewInfiniteTimeout()), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewInfiniteTimeout()}, BaseFee: 300, Operations: []txnbuild.Operation{ &txnbuild.Payment{ @@ -169,7 +169,7 @@ func TestTxApproveHandler_validateInput(t *testing.T) { Sequence: "1", }, IncrementSequenceNum: true, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewInfiniteTimeout()), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewInfiniteTimeout()}, BaseFee: 300, Operations: []txnbuild.Operation{ &txnbuild.BumpSequence{}, @@ -197,7 +197,7 @@ func TestTxApproveHandler_validateInput(t *testing.T) { Sequence: "1", }, IncrementSequenceNum: true, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewInfiniteTimeout()), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewInfiniteTimeout()}, BaseFee: 300, Operations: []txnbuild.Operation{ &txnbuild.Payment{ @@ -372,7 +372,7 @@ func TestTxApproveHandler_txApprove_rejected(t *testing.T) { }, }, BaseFee: txnbuild.MinBaseFee, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewInfiniteTimeout()), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewInfiniteTimeout()}, }, ) require.NoError(t, err) @@ -395,7 +395,7 @@ func TestTxApproveHandler_txApprove_rejected(t *testing.T) { &txnbuild.BumpSequence{}, }, BaseFee: txnbuild.MinBaseFee, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewInfiniteTimeout()), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewInfiniteTimeout()}, }, ) require.NoError(t, err) @@ -425,7 +425,7 @@ func TestTxApproveHandler_txApprove_rejected(t *testing.T) { }, }, BaseFee: txnbuild.MinBaseFee, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewInfiniteTimeout()), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewInfiniteTimeout()}, }, ) require.NoError(t, err) @@ -455,7 +455,7 @@ func TestTxApproveHandler_txApprove_rejected(t *testing.T) { }, }, BaseFee: txnbuild.MinBaseFee, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewInfiniteTimeout()), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewInfiniteTimeout()}, }, ) require.NoError(t, err) @@ -482,7 +482,7 @@ func TestTxApproveHandler_txApprove_rejected(t *testing.T) { }, }, BaseFee: txnbuild.MinBaseFee, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewInfiniteTimeout()), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewInfiniteTimeout()}, }, ) require.NoError(t, err) @@ -569,7 +569,7 @@ func TestTxApproveHandler_txApprove_success(t *testing.T) { }, }, BaseFee: txnbuild.MinBaseFee, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewInfiniteTimeout()), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewInfiniteTimeout()}, }, ) require.NoError(t, err) @@ -631,7 +631,7 @@ func TestTxApproveHandler_txApprove_actionRequired(t *testing.T) { }, }, BaseFee: txnbuild.MinBaseFee, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewInfiniteTimeout()), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewInfiniteTimeout()}, }, ) require.NoError(t, err) @@ -707,7 +707,7 @@ func TestTxApproveHandler_txApprove_revised(t *testing.T) { }, }, BaseFee: txnbuild.MinBaseFee, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewInfiniteTimeout()), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewInfiniteTimeout()}, }, ) require.NoError(t, err) @@ -785,7 +785,7 @@ func TestValidateTransactionOperationsForSuccess(t *testing.T) { }, }, BaseFee: 300, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimeout(300)), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewTimeout(300)}, }) require.NoError(t, err) @@ -809,7 +809,7 @@ func TestValidateTransactionOperationsForSuccess(t *testing.T) { &txnbuild.BumpSequence{}, }, BaseFee: 300, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimeout(300)), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewTimeout(300)}, }) require.NoError(t, err) @@ -838,7 +838,7 @@ func TestValidateTransactionOperationsForSuccess(t *testing.T) { &txnbuild.BumpSequence{}, }, BaseFee: 300, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimeout(300)), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewTimeout(300)}, }) require.NoError(t, err) @@ -887,7 +887,7 @@ func TestValidateTransactionOperationsForSuccess(t *testing.T) { }, }, BaseFee: 300, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimeout(300)), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewTimeout(300)}, }) require.NoError(t, err) @@ -936,7 +936,7 @@ func TestValidateTransactionOperationsForSuccess(t *testing.T) { }, }, BaseFee: 300, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimeout(300)), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewTimeout(300)}, }) require.NoError(t, err) @@ -1002,7 +1002,7 @@ func TestTxApproveHandler_handleSuccessResponseIfNeeded_revisable(t *testing.T) }, }, BaseFee: 300, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimeout(300)), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewTimeout(300)}, }) require.NoError(t, err) @@ -1066,7 +1066,7 @@ func TestTxApproveHandler_handleSuccessResponseIfNeeded_rejected(t *testing.T) { &txnbuild.BumpSequence{}, }, BaseFee: 300, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimeout(300)), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewTimeout(300)}, }) require.NoError(t, err) @@ -1114,7 +1114,7 @@ func TestTxApproveHandler_handleSuccessResponseIfNeeded_rejected(t *testing.T) { }, }, BaseFee: 300, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimeout(300)), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewTimeout(300)}, }) require.NoError(t, err) @@ -1163,7 +1163,7 @@ func TestTxApproveHandler_handleSuccessResponseIfNeeded_rejected(t *testing.T) { IncrementSequenceNum: true, Operations: compliantOps, BaseFee: 300, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimeout(300)), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewTimeout(300)}, }) require.NoError(t, err) @@ -1247,7 +1247,7 @@ func TestTxApproveHandler_handleSuccessResponseIfNeeded_actionRequired(t *testin }, }, BaseFee: 300, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimeout(300)), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewTimeout(300)}, }) require.NoError(t, err) @@ -1386,7 +1386,7 @@ func TestTxApproveHandler_handleSuccessResponseIfNeeded_success(t *testing.T) { }, }, BaseFee: 300, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimeout(300)), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewTimeout(300)}, }) require.NoError(t, err) diff --git a/txnbuild/account_merge_test.go b/txnbuild/account_merge_test.go index 7c75928726..7ee237acf4 100644 --- a/txnbuild/account_merge_test.go +++ b/txnbuild/account_merge_test.go @@ -18,7 +18,7 @@ func TestAccountMergeValidate(t *testing.T) { TransactionParams{ SourceAccount: &sourceAccount, Operations: []Operation{&accountMerge}, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, BaseFee: MinBaseFee, }, ) diff --git a/txnbuild/allow_trust_test.go b/txnbuild/allow_trust_test.go index 77901557b1..7bb0f68979 100644 --- a/txnbuild/allow_trust_test.go +++ b/txnbuild/allow_trust_test.go @@ -22,7 +22,7 @@ func TestAllowTrustValidateAsset(t *testing.T) { TransactionParams{ SourceAccount: &sourceAccount, Operations: []Operation{&allowTrust}, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, BaseFee: MinBaseFee, }, ) @@ -48,7 +48,7 @@ func TestAllowTrustValidateTrustor(t *testing.T) { TransactionParams{ SourceAccount: &sourceAccount, Operations: []Operation{&allowTrust}, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, BaseFee: MinBaseFee, }, ) diff --git a/txnbuild/bump_sequence_test.go b/txnbuild/bump_sequence_test.go index 24dfa85f59..844a7200fc 100644 --- a/txnbuild/bump_sequence_test.go +++ b/txnbuild/bump_sequence_test.go @@ -18,7 +18,7 @@ func TestBumpSequenceValidate(t *testing.T) { TransactionParams{ SourceAccount: &sourceAccount, Operations: []Operation{&bumpSequence}, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, BaseFee: MinBaseFee, }, ) diff --git a/txnbuild/change_trust_test.go b/txnbuild/change_trust_test.go index 23f4ace36f..8d56b05ede 100644 --- a/txnbuild/change_trust_test.go +++ b/txnbuild/change_trust_test.go @@ -21,7 +21,7 @@ func TestChangeTrustMaxLimit(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&changeTrust}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, network.TestNetworkPassphrase, kp0, @@ -46,7 +46,7 @@ func TestChangeTrustValidateInvalidAsset(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&changeTrust}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) if assert.Error(t, err) { @@ -70,7 +70,7 @@ func TestChangeTrustValidateInvalidLimit(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&changeTrust}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) if assert.Error(t, err) { diff --git a/txnbuild/clawback_test.go b/txnbuild/clawback_test.go index e9c558b9cb..a8e020f1ef 100644 --- a/txnbuild/clawback_test.go +++ b/txnbuild/clawback_test.go @@ -22,7 +22,7 @@ func TestClawbackValidateFrom(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&clawback}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) if assert.Error(t, err) { @@ -47,7 +47,7 @@ func TestClawbackValidateAmount(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&clawback}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) if assert.Error(t, err) { @@ -72,7 +72,7 @@ func TestClawbackValidateAsset(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&clawback}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) if assert.Error(t, err) { diff --git a/txnbuild/cmd/demo/operations/demo.go b/txnbuild/cmd/demo/operations/demo.go index 0450a6b096..2b8fa49462 100644 --- a/txnbuild/cmd/demo/operations/demo.go +++ b/txnbuild/cmd/demo/operations/demo.go @@ -215,7 +215,7 @@ func bumpSequence(source *hProtocol.Account, seqNum int64, signer Account) (stri IncrementSequenceNum: true, Operations: []txnbuild.Operation{&bumpSequenceOp}, BaseFee: txnbuild.MinBaseFee, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimeout(300)), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewTimeout(300)}, }, ) if err != nil { @@ -245,7 +245,7 @@ func createAccount(source *hProtocol.Account, dest string, signer Account) (stri IncrementSequenceNum: true, Operations: []txnbuild.Operation{&createAccountOp}, BaseFee: txnbuild.MinBaseFee, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimeout(300)), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewTimeout(300)}, }, ) if err != nil { @@ -274,7 +274,7 @@ func deleteData(source *hProtocol.Account, dataKey string, signer Account) (stri IncrementSequenceNum: true, Operations: []txnbuild.Operation{&manageDataOp}, BaseFee: txnbuild.MinBaseFee, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimeout(300)), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewTimeout(300)}, }, ) if err != nil { @@ -305,7 +305,7 @@ func payment(source *hProtocol.Account, dest, amount string, asset txnbuild.Asse IncrementSequenceNum: true, Operations: []txnbuild.Operation{&paymentOp}, BaseFee: txnbuild.MinBaseFee, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimeout(300)), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewTimeout(300)}, }, ) if err != nil { @@ -332,7 +332,7 @@ func deleteTrustline(source *hProtocol.Account, asset txnbuild.ChangeTrustAsset, IncrementSequenceNum: true, Operations: []txnbuild.Operation{&deleteTrustline}, BaseFee: txnbuild.MinBaseFee, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimeout(300)), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewTimeout(300)}, }, ) if err != nil { @@ -362,7 +362,7 @@ func deleteOffer(source *hProtocol.Account, offerID int64, signer Account) (stri IncrementSequenceNum: true, Operations: []txnbuild.Operation{&deleteOffer}, BaseFee: txnbuild.MinBaseFee, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimeout(300)), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewTimeout(300)}, }, ) if err != nil { @@ -391,7 +391,7 @@ func mergeAccount(source *hProtocol.Account, destAddress string, signer Account) IncrementSequenceNum: true, Operations: []txnbuild.Operation{&accountMerge}, BaseFee: txnbuild.MinBaseFee, - Preconditions: txnbuild.NewPreconditions(txnbuild.NewTimeout(300)), + Preconditions: txnbuild.Preconditions{Timebounds: txnbuild.NewTimeout(300)}, }, ) if err != nil { diff --git a/txnbuild/create_account_test.go b/txnbuild/create_account_test.go index a35df0426b..a8a9003705 100644 --- a/txnbuild/create_account_test.go +++ b/txnbuild/create_account_test.go @@ -21,7 +21,7 @@ func TestCreateAccountValidateDestination(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&createAccount}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) if assert.Error(t, err) { @@ -45,7 +45,7 @@ func TestCreateAccountValidateAmount(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&createAccount}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) diff --git a/txnbuild/create_claimable_balance_test.go b/txnbuild/create_claimable_balance_test.go index d35377fc34..46e2e94cbf 100644 --- a/txnbuild/create_claimable_balance_test.go +++ b/txnbuild/create_claimable_balance_test.go @@ -78,7 +78,7 @@ func TestClaimableBalanceID(t *testing.T) { SourceAccount: &aAccount, IncrementSequenceNum: true, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, Operations: []Operation{&claimableBalanceEntry}, }, ) diff --git a/txnbuild/create_passive_offer_test.go b/txnbuild/create_passive_offer_test.go index 7d1615d00d..b09b05b74e 100644 --- a/txnbuild/create_passive_offer_test.go +++ b/txnbuild/create_passive_offer_test.go @@ -25,7 +25,7 @@ func TestCreatePassiveSellOfferValidateBuyingAsset(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&createPassiveOffer}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) if assert.Error(t, err) { @@ -52,7 +52,7 @@ func TestCreatePassiveSellOfferValidateSellingAsset(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&createPassiveOffer}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) if assert.Error(t, err) { @@ -79,7 +79,7 @@ func TestCreatePassiveSellOfferValidateAmount(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&createPassiveOffer}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) if assert.Error(t, err) { @@ -106,7 +106,7 @@ func TestCreatePassiveSellOfferValidatePrice(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&createPassiveOffer}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) if assert.Error(t, err) { diff --git a/txnbuild/example_test.go b/txnbuild/example_test.go index 67e49f3af7..614240125c 100644 --- a/txnbuild/example_test.go +++ b/txnbuild/example_test.go @@ -27,7 +27,7 @@ func ExampleInflation() { IncrementSequenceNum: true, Operations: []Operation{&op}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), // Use a real timeout in production! + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, // Use a real timeout in production! }, ) check(err) @@ -60,7 +60,7 @@ func ExampleCreateAccount() { IncrementSequenceNum: true, Operations: []Operation{&op}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), // Use a real timeout in production! + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, // Use a real timeout in production! }, ) check(err) @@ -94,7 +94,7 @@ func ExamplePayment() { IncrementSequenceNum: true, Operations: []Operation{&op}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), // Use a real timeout in production! + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, // Use a real timeout in production! }, ) check(err) @@ -138,7 +138,7 @@ func ExamplePayment_setBaseFee() { IncrementSequenceNum: true, Operations: []Operation{&op1, &op2}, BaseFee: feeStats.MaxFee.P50, - Preconditions: NewPreconditions(NewInfiniteTimeout()), // Use a real timeout in production! + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, // Use a real timeout in production! }, ) check(err) @@ -170,7 +170,7 @@ func ExampleBumpSequence() { IncrementSequenceNum: true, Operations: []Operation{&op}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), // Use a real timeout in production! + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, // Use a real timeout in production! }, ) check(err) @@ -202,7 +202,7 @@ func ExampleAccountMerge() { IncrementSequenceNum: true, Operations: []Operation{&op}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), // Use a real timeout in production! + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, // Use a real timeout in production! }, ) check(err) @@ -235,7 +235,7 @@ func ExampleManageData() { IncrementSequenceNum: true, Operations: []Operation{&op}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), // Use a real timeout in production! + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, // Use a real timeout in production! }, ) check(err) @@ -267,7 +267,7 @@ func ExampleManageData_removeDataEntry() { IncrementSequenceNum: true, Operations: []Operation{&op}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), // Use a real timeout in production! + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, // Use a real timeout in production! }, ) check(err) @@ -307,7 +307,7 @@ func ExampleSetOptions() { IncrementSequenceNum: true, Operations: []Operation{&op}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), // Use a real timeout in production! + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, // Use a real timeout in production! }, ) check(err) @@ -343,7 +343,7 @@ func ExampleChangeTrust() { IncrementSequenceNum: true, Operations: []Operation{&op}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), // Use a real timeout in production! + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, // Use a real timeout in production! }, ) check(err) @@ -373,7 +373,7 @@ func ExampleChangeTrust_removeTrustline() { IncrementSequenceNum: true, Operations: []Operation{&op}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), // Use a real timeout in production! + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, // Use a real timeout in production! }, ) check(err) @@ -407,7 +407,7 @@ func ExampleAllowTrust() { IncrementSequenceNum: true, Operations: []Operation{&op}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), // Use a real timeout in production! + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, // Use a real timeout in production! }, ) check(err) @@ -441,7 +441,7 @@ func ExampleManageSellOffer() { IncrementSequenceNum: true, Operations: []Operation{&op}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), // Use a real timeout in production! + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, // Use a real timeout in production! }, ) check(err) @@ -473,7 +473,7 @@ func ExampleManageSellOffer_deleteOffer() { IncrementSequenceNum: true, Operations: []Operation{&op}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), // Use a real timeout in production! + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, // Use a real timeout in production! }, ) check(err) @@ -508,7 +508,7 @@ func ExampleManageSellOffer_updateOffer() { IncrementSequenceNum: true, Operations: []Operation{&op}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), // Use a real timeout in production! + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, // Use a real timeout in production! }, ) check(err) @@ -543,7 +543,7 @@ func ExampleCreatePassiveSellOffer() { IncrementSequenceNum: true, Operations: []Operation{&op}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), // Use a real timeout in production! + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, // Use a real timeout in production! }, ) check(err) @@ -581,7 +581,7 @@ func ExamplePathPayment() { IncrementSequenceNum: true, Operations: []Operation{&op}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), // Use a real timeout in production! + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, // Use a real timeout in production! }, ) check(err) @@ -619,7 +619,7 @@ func ExamplePathPaymentStrictReceive() { IncrementSequenceNum: true, Operations: []Operation{&op}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), // Use a real timeout in production! + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, // Use a real timeout in production! }, ) check(err) @@ -657,7 +657,7 @@ func ExamplePathPaymentStrictSend() { IncrementSequenceNum: true, Operations: []Operation{&op}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), // Use a real timeout in production! + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, // Use a real timeout in production! }, ) check(err) @@ -693,7 +693,7 @@ func ExampleManageBuyOffer() { IncrementSequenceNum: true, Operations: []Operation{&buyOffer}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), // Use a real timeout in production! + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, // Use a real timeout in production! }, ) check(err) @@ -726,7 +726,7 @@ func ExampleFeeBumpTransaction() { IncrementSequenceNum: true, Operations: []Operation{&op}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), // Use a real timeout in production! + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, // Use a real timeout in production! }, ) check(err) @@ -800,7 +800,7 @@ func ExampleCreateClaimableBalance() { SourceAccount: &aAccount, IncrementSequenceNum: true, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, Operations: []Operation{&claimableBalanceEntry}, }, ) @@ -828,7 +828,7 @@ func ExampleClaimClaimableBalance() { SourceAccount: &aAccount, // or Account B, depending on the condition! IncrementSequenceNum: true, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, Operations: []Operation{&claimBalance}, }, network.TestNetworkPassphrase, @@ -894,7 +894,7 @@ func ExampleBeginSponsoringFutureReserves() { TransactionParams{ SourceAccount: &test.Aaccount, Operations: sponsorTrustline, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, BaseFee: MinBaseFee, IncrementSequenceNum: true, }, @@ -935,7 +935,7 @@ func ExampleBeginSponsoringFutureReserves_transfer() { TransactionParams{ SourceAccount: &test.S1account, Operations: transferOps, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, BaseFee: MinBaseFee, IncrementSequenceNum: true, }, @@ -982,7 +982,7 @@ func ExampleRevokeSponsorship() { TransactionParams{ SourceAccount: &test.S2account, Operations: revokeOps, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, BaseFee: MinBaseFee, IncrementSequenceNum: true, }, @@ -1051,7 +1051,7 @@ func ExampleLiquidityPoolDeposit() { TransactionParams{ SourceAccount: &test.AAccount, Operations: depositOps, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, BaseFee: MinBaseFee, IncrementSequenceNum: true, }, @@ -1086,7 +1086,7 @@ func ExampleLiquidityPoolWithdraw() { TransactionParams{ SourceAccount: &test.AAccount, Operations: withdrawOps, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, BaseFee: MinBaseFee, IncrementSequenceNum: true, }, diff --git a/txnbuild/fee_bump_test.go b/txnbuild/fee_bump_test.go index c0e4027959..d9b2d64f4c 100644 --- a/txnbuild/fee_bump_test.go +++ b/txnbuild/fee_bump_test.go @@ -25,7 +25,7 @@ func TestFeeBumpInvalidFeeSource(t *testing.T) { SourceAccount: &sourceAccount, Operations: []Operation{&Inflation{}}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) assert.NoError(t, err) @@ -51,7 +51,7 @@ func TestFeeBumpUpgradesV0Transaction(t *testing.T) { Operations: []Operation{&Inflation{}}, BaseFee: 2 * MinBaseFee, Memo: MemoText("test-memo"), - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) assert.NoError(t, err) @@ -105,7 +105,7 @@ func TestFeeBumpInvalidInnerTransactionType(t *testing.T) { Operations: []Operation{&Inflation{}}, BaseFee: 2 * MinBaseFee, Memo: MemoText("test-memo"), - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) assert.NoError(t, err) @@ -143,7 +143,7 @@ func TestFeeBumpAllowsFeeAccountToEqualInnerSourceAccount(t *testing.T) { SourceAccount: &sourceAccount, Operations: []Operation{&Inflation{}}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) assert.NoError(t, err) @@ -202,7 +202,7 @@ func TestFeeBumpSignWithKeyString(t *testing.T) { SourceAccount: &sourceAccount, Operations: []Operation{&Inflation{}}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) assert.NoError(t, err) @@ -257,7 +257,7 @@ func TestFeeBumpSignHashX(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&payment}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) assert.NoError(t, err) @@ -300,7 +300,7 @@ func TestFeeBumpAddSignatureBase64(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&createAccount}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) assert.NoError(t, err) @@ -363,7 +363,7 @@ func TestFeeBumpMuxedAccounts(t *testing.T) { SourceAccount: &sourceAccount, Operations: []Operation{&Inflation{}}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) assert.NoError(t, err) diff --git a/txnbuild/manage_buy_offer_test.go b/txnbuild/manage_buy_offer_test.go index 45a6d89b22..d244dfde4d 100644 --- a/txnbuild/manage_buy_offer_test.go +++ b/txnbuild/manage_buy_offer_test.go @@ -28,7 +28,7 @@ func TestManageBuyOfferValidateSellingAsset(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&buyOffer}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) if assert.Error(t, err) { @@ -56,7 +56,7 @@ func TestManageBuyOfferValidateBuyingAsset(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&buyOffer}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) if assert.Error(t, err) { @@ -84,7 +84,7 @@ func TestManageBuyOfferValidateAmount(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&buyOffer}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) if assert.Error(t, err) { @@ -112,7 +112,7 @@ func TestManageBuyOfferValidatePrice(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&buyOffer}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) if assert.Error(t, err) { @@ -140,7 +140,7 @@ func TestManageBuyOfferValidateOfferID(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&buyOffer}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) if assert.Error(t, err) { diff --git a/txnbuild/manage_data_test.go b/txnbuild/manage_data_test.go index 33a096fbf8..f4b4b0049c 100644 --- a/txnbuild/manage_data_test.go +++ b/txnbuild/manage_data_test.go @@ -22,7 +22,7 @@ func TestManageDataValidateName(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&manageData}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) if assert.Error(t, err) { @@ -46,7 +46,7 @@ func TestManageDataValidateValue(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&manageData}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) if assert.Error(t, err) { @@ -88,7 +88,7 @@ func TestManageDataRoundTrip(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&manageData}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) assert.NoError(t, err) diff --git a/txnbuild/manage_offer_test.go b/txnbuild/manage_offer_test.go index cd4b5c95e8..2c77eaa193 100644 --- a/txnbuild/manage_offer_test.go +++ b/txnbuild/manage_offer_test.go @@ -26,7 +26,7 @@ func TestManageSellOfferValidateSellingAsset(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&createOffer}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) if assert.Error(t, err) { @@ -52,7 +52,7 @@ func TestManageSellOfferValidateBuyingAsset(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&createOffer}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) if assert.Error(t, err) { @@ -78,7 +78,7 @@ func TestManageSellOfferValidateAmount(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&createOffer}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) if assert.Error(t, err) { @@ -104,7 +104,7 @@ func TestManageSellOfferValidatePrice(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&createOffer}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) if assert.Error(t, err) { @@ -132,7 +132,7 @@ func TestManageSellOfferValidateOfferID(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&mso}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) if assert.Error(t, err) { diff --git a/txnbuild/operation_test.go b/txnbuild/operation_test.go index 48698a6634..3922817a85 100644 --- a/txnbuild/operation_test.go +++ b/txnbuild/operation_test.go @@ -56,7 +56,7 @@ func TestZeroBalanceAccount(t *testing.T) { Operations: ops, IncrementSequenceNum: true, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) @@ -466,7 +466,7 @@ func testOperationsMarshallingRoundtrip(t *testing.T, operations []Operation, wi TransactionParams{ SourceAccount: &sourceAccount, Operations: operations, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, BaseFee: MinBaseFee, }, ) diff --git a/txnbuild/path_payment_strict_send_test.go b/txnbuild/path_payment_strict_send_test.go index 9c9695f147..c06dc2f129 100644 --- a/txnbuild/path_payment_strict_send_test.go +++ b/txnbuild/path_payment_strict_send_test.go @@ -27,7 +27,7 @@ func TestPathPaymentStrictSendValidateSendAsset(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&pathPayment}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) if assert.Error(t, err) { @@ -57,7 +57,7 @@ func TestPathPaymentStrictSendValidateDestAsset(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&pathPayment}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) if assert.Error(t, err) { @@ -87,7 +87,7 @@ func TestPathPaymentStrictSendValidateDestination(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&pathPayment}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) if assert.Error(t, err) { @@ -117,7 +117,7 @@ func TestPathPaymentStrictSendValidateSendMax(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&pathPayment}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) @@ -148,7 +148,7 @@ func TestPathPaymentStrictSendValidateDestAmount(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&pathPayment}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) if assert.Error(t, err) { diff --git a/txnbuild/path_payment_test.go b/txnbuild/path_payment_test.go index d290d28ded..0bc7155892 100644 --- a/txnbuild/path_payment_test.go +++ b/txnbuild/path_payment_test.go @@ -27,7 +27,7 @@ func TestPathPaymentValidateSendAsset(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&pathPayment}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) @@ -58,7 +58,7 @@ func TestPathPaymentValidateDestAsset(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&pathPayment}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) if assert.Error(t, err) { @@ -88,7 +88,7 @@ func TestPathPaymentValidateDestination(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&pathPayment}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) if assert.Error(t, err) { @@ -118,7 +118,7 @@ func TestPathPaymentValidateSendMax(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&pathPayment}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) if assert.Error(t, err) { @@ -148,7 +148,7 @@ func TestPathPaymentValidateDestAmount(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&pathPayment}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) if assert.Error(t, err) { diff --git a/txnbuild/payment_test.go b/txnbuild/payment_test.go index 95a796e201..95eb6ad792 100644 --- a/txnbuild/payment_test.go +++ b/txnbuild/payment_test.go @@ -22,7 +22,7 @@ func TestPaymentValidateDestination(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&payment}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) if assert.Error(t, err) { @@ -47,7 +47,7 @@ func TestPaymentValidateAmount(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&payment}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) if assert.Error(t, err) { @@ -72,7 +72,7 @@ func TestPaymentValidateAsset(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&payment}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) if assert.Error(t, err) { diff --git a/txnbuild/preconditions.go b/txnbuild/preconditions.go index 4f61d333fb..9eebe1a1f3 100644 --- a/txnbuild/preconditions.go +++ b/txnbuild/preconditions.go @@ -28,16 +28,6 @@ type Preconditions struct { ExtraSigners []xdr.SignerKey } -// NewPreconditions creates a set of preconditions with timebounds enabled -func NewPreconditions(timebounds Timebounds) Preconditions { - cond := Preconditions{Timebounds: timebounds} - return cond -} - -func NewPreconditionsWithTimebounds(minTime, maxTime int64) Preconditions { - return NewPreconditions(NewTimebounds(minTime, maxTime)) -} - // Validate ensures that all enabled preconditions are valid. func (cond *Preconditions) Validate() error { var err error diff --git a/txnbuild/preconditions_test.go b/txnbuild/preconditions_test.go index 5d88a97ee9..df381a9526 100644 --- a/txnbuild/preconditions_test.go +++ b/txnbuild/preconditions_test.go @@ -16,7 +16,7 @@ var Signers = []xdr.SignerKey{ // TestClassifyingPreconditions ensures that Preconditions will correctly // differentiate V1 (timebounds-only) or V2 (all other) preconditions correctly. func TestClassifyingPreconditions(t *testing.T) { - tbpc := NewPreconditionsWithTimebounds(1, 2) + tbpc := Preconditions{Timebounds: NewTimebounds(1, 2)} assert.False(t, (&Preconditions{}).hasV2Conditions()) assert.False(t, tbpc.hasV2Conditions()) @@ -78,7 +78,7 @@ func TestPreconditions(t *testing.T) { MinTime: xdr.TimePoint(1), MaxTime: xdr.TimePoint(2), }, - }, NewPreconditionsWithTimebounds(1, 2) + }, Preconditions{Timebounds: NewTimebounds(1, 2)} }, }, { @@ -146,7 +146,7 @@ func TestPreconditionsValidation(t *testing.T) { }) t.Run("nonsense ledgerbounds", func(t *testing.T) { - pc := NewPreconditionsWithTimebounds(27, 42) + pc := Preconditions{Timebounds: NewTimebounds(27, 42)} pc.Ledgerbounds = &Ledgerbounds{MinLedger: 42, MaxLedger: 1} assert.Error(t, pc.Validate()) }) @@ -171,7 +171,7 @@ func cloneXdrPreconditions(pc xdr.Preconditions) xdr.Preconditions { } func clonePreconditions(precond Preconditions) Preconditions { - cond := NewPreconditions(precond.Timebounds) + cond := Preconditions{Timebounds: precond.Timebounds} if precond.Ledgerbounds != nil { cond.Ledgerbounds = &Ledgerbounds{ MinLedger: precond.Ledgerbounds.MinLedger, diff --git a/txnbuild/signers_test.go b/txnbuild/signers_test.go index 97567f77c5..35f1d28667 100644 --- a/txnbuild/signers_test.go +++ b/txnbuild/signers_test.go @@ -29,7 +29,7 @@ func TestAccountMergeMultSigners(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&accountMerge}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, network.TestNetworkPassphrase, kp0, kp1, @@ -60,7 +60,7 @@ func TestAllowTrustMultSigners(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&allowTrust}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, network.TestNetworkPassphrase, kp0, kp1, @@ -88,7 +88,7 @@ func TestBumpSequenceMultSigners(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&bumpSequence}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, network.TestNetworkPassphrase, kp0, kp1, @@ -117,7 +117,7 @@ func TestChangeTrustMultSigners(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&changeTrust}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, network.TestNetworkPassphrase, kp0, kp1, @@ -146,7 +146,7 @@ func TestCreateAccountMultSigners(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&createAccount}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, network.TestNetworkPassphrase, kp0, kp1, @@ -177,7 +177,7 @@ func TestCreatePassiveSellOfferMultSigners(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&createPassiveOffer}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, network.TestNetworkPassphrase, kp0, kp1, @@ -204,7 +204,7 @@ func TestInflationMultSigners(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&inflation}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, network.TestNetworkPassphrase, kp0, kp1, @@ -233,7 +233,7 @@ func TestManageDataMultSigners(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&manageData}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, network.TestNetworkPassphrase, kp0, kp1, @@ -262,7 +262,7 @@ func TestManageOfferCreateMultSigners(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&createOffer}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, network.TestNetworkPassphrase, kp0, kp1, @@ -289,7 +289,7 @@ func TestManageOfferDeleteMultSigners(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&deleteOffer}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, network.TestNetworkPassphrase, kp0, kp1, @@ -319,7 +319,7 @@ func TestManageOfferUpdateMultSigners(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&updateOffer}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, network.TestNetworkPassphrase, kp0, kp1, @@ -353,7 +353,7 @@ func TestPathPaymentMultSigners(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&pathPayment}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, network.TestNetworkPassphrase, kp0, kp1, @@ -384,7 +384,7 @@ func TestPaymentMultSigners(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&payment}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, network.TestNetworkPassphrase, kp0, kp1, @@ -412,7 +412,7 @@ func TestSetOptionsMultSigners(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&setOptions}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, network.TestNetworkPassphrase, kp0, kp1, @@ -462,7 +462,7 @@ func TestSigningImmutability(t *testing.T) { SourceAccount: &sourceAccount, Operations: []Operation{&Inflation{}}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, } root, err := NewTransaction(params) assert.NoError(t, err) @@ -513,7 +513,7 @@ func TestFeeBumpSigningImmutability(t *testing.T) { SourceAccount: &sourceAccount, Operations: []Operation{&Inflation{}}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, } inner, err := NewTransaction(innerParams) assert.NoError(t, err) diff --git a/txnbuild/transaction.go b/txnbuild/transaction.go index 1ba1db9410..327ba89205 100644 --- a/txnbuild/transaction.go +++ b/txnbuild/transaction.go @@ -772,9 +772,15 @@ func transactionFromParsedXDR(xdrEnv xdr.TransactionEnvelope) (*GenericTransacti memo: nil, } + // precond := xdrEnv.Preconditions() + // if precond.TimeBounds + if timeBounds := xdrEnv.TimeBounds(); timeBounds != nil { - newTx.simple.preconditions = NewPreconditionsWithTimebounds( - int64(timeBounds.MinTime), int64(timeBounds.MaxTime)) + newTx.simple.preconditions = Preconditions{ + Timebounds: NewTimebounds( + int64(timeBounds.MinTime), + int64(timeBounds.MaxTime)), + } } newTx.simple.memo, err = memoFromXDR(xdrEnv.Memo()) @@ -913,7 +919,7 @@ func convertToV1(tx *Transaction) (*Transaction, error) { Operations: tx.Operations(), BaseFee: tx.BaseFee(), Memo: tx.Memo(), - Preconditions: NewPreconditions(tx.Timebounds()), + Preconditions: Preconditions{Timebounds: tx.Timebounds()}, }) if err != nil { return tx, err @@ -1049,9 +1055,11 @@ func BuildChallengeTx(serverSignerSecret, clientAccountID, webAuthDomain, homeDo Value: []byte(webAuthDomain), }, }, - BaseFee: MinBaseFee, - Memo: nil, - Preconditions: NewPreconditions(NewTimebounds(currentTime.Unix(), maxTime.Unix())), + BaseFee: MinBaseFee, + Memo: nil, + Preconditions: Preconditions{ + Timebounds: NewTimebounds(currentTime.Unix(), maxTime.Unix()), + }, }, ) if err != nil { diff --git a/txnbuild/transaction_fee_test.go b/txnbuild/transaction_fee_test.go index eecda0bfc8..b1d1114b3c 100644 --- a/txnbuild/transaction_fee_test.go +++ b/txnbuild/transaction_fee_test.go @@ -16,7 +16,7 @@ func TestBaseFeeCanBeZeroOrPositive(t *testing.T) { SourceAccount: &SimpleAccount{keypair.MustRandom().Address(), 1}, Operations: []Operation{&Inflation{}}, BaseFee: bf, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) assert.NoError(t, err) @@ -30,7 +30,7 @@ func TestBaseFeeErrorWhenNegative(t *testing.T) { SourceAccount: &SimpleAccount{keypair.MustRandom().Address(), 1}, Operations: []Operation{&Inflation{}}, BaseFee: -1, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) assert.EqualError(t, err, "base fee cannot be negative") @@ -45,7 +45,7 @@ func TestFeeBumpMinBaseFee(t *testing.T) { SourceAccount: &sourceAccount, Operations: []Operation{&Inflation{}}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) assert.NoError(t, err) @@ -70,7 +70,7 @@ func TestFeeOverflow(t *testing.T) { SourceAccount: &sourceAccount, Operations: []Operation{&Inflation{}, &Inflation{}}, BaseFee: math.MaxUint32 / 2, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) assert.NoError(t, err) @@ -80,7 +80,7 @@ func TestFeeOverflow(t *testing.T) { SourceAccount: &sourceAccount, Operations: []Operation{&Inflation{}, &Inflation{}, &Inflation{}}, BaseFee: math.MaxUint32 / 2, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) assert.EqualError(t, err, "base fee 2147483647 results in an overflow of max fee") @@ -95,7 +95,7 @@ func TestFeeBumpOverflow(t *testing.T) { SourceAccount: &sourceAccount, Operations: []Operation{&Inflation{}}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) assert.NoError(t, err) @@ -128,7 +128,7 @@ func TestFeeBumpFeeGreaterThanOrEqualInner(t *testing.T) { SourceAccount: &sourceAccount, Operations: []Operation{&Inflation{}}, BaseFee: 2 * MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) assert.NoError(t, err) diff --git a/txnbuild/transaction_test.go b/txnbuild/transaction_test.go index c5b9a8f2b0..540baed089 100644 --- a/txnbuild/transaction_test.go +++ b/txnbuild/transaction_test.go @@ -50,7 +50,7 @@ func TestTimebounds(t *testing.T) { func TestV2Preconditions(t *testing.T) { kp0 := newKeypair0() - cond := NewPreconditions(NewTimeout(300)) + cond := Preconditions{Timebounds: NewTimeout(300)} cond.Ledgerbounds = &Ledgerbounds{0, 1} cond.MinSequenceNumber = nil cond.MinSequenceNumberAge = xdr.Duration(10) @@ -86,7 +86,7 @@ func TestIncrementSequenceNum(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&inflation}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) assert.NoError(t, err) @@ -98,7 +98,7 @@ func TestIncrementSequenceNum(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&inflation}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) assert.NoError(t, err) @@ -110,7 +110,7 @@ func TestIncrementSequenceNum(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&inflation}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) assert.NoError(t, err) @@ -122,7 +122,7 @@ func TestIncrementSequenceNum(t *testing.T) { IncrementSequenceNum: false, Operations: []Operation{&inflation}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) assert.NoError(t, err) @@ -138,7 +138,7 @@ func TestFeeNoOperations(t *testing.T) { SourceAccount: &sourceAccount, Operations: []Operation{}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) assert.EqualError(t, err, "transaction has no operations") @@ -156,7 +156,7 @@ func TestInflation(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&inflation}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, network.TestNetworkPassphrase, kp0, @@ -182,7 +182,7 @@ func TestCreateAccount(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&createAccount}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, network.TestNetworkPassphrase, kp0, @@ -209,7 +209,7 @@ func TestPayment(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&payment}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, network.TestNetworkPassphrase, kp0, @@ -245,7 +245,7 @@ func TestPaymentMuxedAccounts(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&payment}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, network.TestNetworkPassphrase, kp0, @@ -271,7 +271,7 @@ func TestPaymentFailsIfNoAssetSpecified(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&payment}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) expectedErrMsg := "validation failed for *txnbuild.Payment operation: Field: Asset, Error: asset is undefined" @@ -292,7 +292,7 @@ func TestBumpSequence(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&bumpSequence}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, network.TestNetworkPassphrase, kp1, @@ -317,7 +317,7 @@ func TestAccountMerge(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&accountMerge}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, network.TestNetworkPassphrase, kp0, @@ -343,7 +343,7 @@ func TestManageData(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&manageData}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, network.TestNetworkPassphrase, kp0, @@ -368,7 +368,7 @@ func TestManageDataRemoveDataEntry(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&manageData}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, network.TestNetworkPassphrase, kp0, @@ -394,7 +394,7 @@ func TestSetOptionsInflationDestination(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&setOptions}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, network.TestNetworkPassphrase, kp0, @@ -419,7 +419,7 @@ func TestSetOptionsSetFlags(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&setOptions}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, network.TestNetworkPassphrase, kp0, @@ -444,7 +444,7 @@ func TestSetOptionsClearFlags(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&setOptions}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, network.TestNetworkPassphrase, kp0, @@ -469,7 +469,7 @@ func TestSetOptionsMasterWeight(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&setOptions}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, network.TestNetworkPassphrase, kp0, @@ -496,7 +496,7 @@ func TestSetOptionsThresholds(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&setOptions}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, network.TestNetworkPassphrase, kp0, @@ -521,7 +521,7 @@ func TestSetOptionsHomeDomain(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&setOptions}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, network.TestNetworkPassphrase, kp0, @@ -546,7 +546,7 @@ func TestSetOptionsHomeDomainTooLong(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&setOptions}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) @@ -568,7 +568,7 @@ func TestSetOptionsSigner(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&setOptions}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, network.TestNetworkPassphrase, kp0, @@ -594,7 +594,7 @@ func TestMultipleOperations(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&inflation, &bumpSequence}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, network.TestNetworkPassphrase, kp1, @@ -621,7 +621,7 @@ func TestChangeTrust(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&changeTrust}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, network.TestNetworkPassphrase, kp0, @@ -647,7 +647,7 @@ func TestChangeTrustNativeAssetNotAllowed(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&changeTrust}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) @@ -669,7 +669,7 @@ func TestChangeTrustDeleteTrustline(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&removeTrust}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, network.TestNetworkPassphrase, kp0, @@ -698,7 +698,7 @@ func TestAllowTrust(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&allowTrust}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, network.TestNetworkPassphrase, kp0, @@ -727,7 +727,7 @@ func TestAllowTrustNoIssuer(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&allowTrust}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, network.TestNetworkPassphrase, kp0, @@ -755,7 +755,7 @@ func TestManageSellOfferNewOffer(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&createOffer}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, network.TestNetworkPassphrase, kp1, @@ -780,7 +780,7 @@ func TestManageSellOfferDeleteOffer(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&deleteOffer}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, network.TestNetworkPassphrase, kp1, @@ -809,7 +809,7 @@ func TestManageSellOfferUpdateOffer(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&updateOffer}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, network.TestNetworkPassphrase, kp1, @@ -838,7 +838,7 @@ func TestCreatePassiveSellOffer(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&createPassiveOffer}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, network.TestNetworkPassphrase, kp1, @@ -870,7 +870,7 @@ func TestPathPayment(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&pathPayment}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, network.TestNetworkPassphrase, kp2, @@ -892,7 +892,7 @@ func TestMemoText(t *testing.T) { Operations: []Operation{&BumpSequence{BumpTo: 1}}, Memo: MemoText("Twas brillig"), BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, network.TestNetworkPassphrase, kp2, @@ -914,7 +914,7 @@ func TestMemoID(t *testing.T) { Operations: []Operation{&BumpSequence{BumpTo: 1}}, Memo: MemoID(314159), BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, network.TestNetworkPassphrase, kp2, @@ -936,7 +936,7 @@ func TestMemoHash(t *testing.T) { Operations: []Operation{&BumpSequence{BumpTo: 1}}, Memo: MemoHash([32]byte{0x01}), BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, network.TestNetworkPassphrase, kp2, @@ -958,7 +958,7 @@ func TestMemoReturn(t *testing.T) { Operations: []Operation{&BumpSequence{BumpTo: 1}}, Memo: MemoReturn([32]byte{0x01}), BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, network.TestNetworkPassphrase, kp2, @@ -988,7 +988,7 @@ func TestManageBuyOfferNewOffer(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&buyOffer}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, network.TestNetworkPassphrase, kp1, @@ -1017,7 +1017,7 @@ func TestManageBuyOfferDeleteOffer(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&buyOffer}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, network.TestNetworkPassphrase, kp1, @@ -1046,7 +1046,7 @@ func TestManageBuyOfferUpdateOffer(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&buyOffer}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, network.TestNetworkPassphrase, kp1, @@ -1131,7 +1131,7 @@ func TestHashHex(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&createAccount}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) assert.NoError(t, err) @@ -1175,7 +1175,7 @@ func TestTransactionFee(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&createAccount}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) assert.NoError(t, err) @@ -1189,7 +1189,7 @@ func TestTransactionFee(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&createAccount}, BaseFee: 500, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) assert.NoError(t, err) @@ -1223,7 +1223,7 @@ func TestPreAuthTransaction(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&createAccount}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) assert.NoError(t, err) @@ -1261,7 +1261,7 @@ func TestPreAuthTransaction(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&setOptions}, BaseFee: 500, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) assert.NoError(t, err) @@ -1302,7 +1302,7 @@ func TestHashXTransaction(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&setOptions}, BaseFee: 500, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) assert.NoError(t, err) @@ -1332,7 +1332,7 @@ func TestHashXTransaction(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&payment}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) assert.NoError(t, err) @@ -1438,7 +1438,7 @@ func TestBuild(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&createAccount}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) assert.NoError(t, err) @@ -1498,7 +1498,7 @@ func TestFromXDRBuildSignEncode(t *testing.T) { Operations: newTx.Operations(), BaseFee: newTx.BaseFee(), Memo: MemoText("newtx"), - Preconditions: NewPreconditions(newTx.Timebounds()), + Preconditions: Preconditions{Timebounds: newTx.Timebounds()}, }, network.TestNetworkPassphrase, kp0, @@ -1524,7 +1524,7 @@ func TestSignWithSecretKey(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&createAccount}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, network.TestNetworkPassphrase, kp0, kp1, @@ -1537,7 +1537,7 @@ func TestSignWithSecretKey(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&createAccount}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) assert.NoError(t, err) @@ -1571,7 +1571,7 @@ func TestAddSignatureDecorated(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&createAccount}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, network.TestNetworkPassphrase, kp0, kp1, @@ -1584,7 +1584,7 @@ func TestAddSignatureDecorated(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&createAccount}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) assert.NoError(t, err) @@ -1673,7 +1673,7 @@ func TestFeeBumpTransaction_AddSignatureDecorated(t *testing.T) { SourceAccount: kp1.Address(), }}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }) require.NoError(t, err) tx, err = tx.Sign(network.TestNetworkPassphrase, kp0, kp1) @@ -1723,7 +1723,7 @@ func TestAddSignatureBase64(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&createAccount}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, network.TestNetworkPassphrase, kp0, kp1, @@ -1736,7 +1736,7 @@ func TestAddSignatureBase64(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&createAccount}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) assert.NoError(t, err) @@ -1773,7 +1773,7 @@ func TestTransaction_ClearSignatures(t *testing.T) { SourceAccount: kp1.Address(), }}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) require.NoError(t, err) @@ -1806,7 +1806,7 @@ func TestFeeBumpTransaction_ClearSignatures(t *testing.T) { SourceAccount: kp1.Address(), }}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }) require.NoError(t, err) require.Len(t, tx.Signatures(), 0) @@ -1858,7 +1858,7 @@ func TestReadChallengeTx_validSignedByServerAndClient(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(1000)), + Preconditions: Preconditions{Timebounds: NewTimeout(1000)}, }, ) assert.NoError(t, err) @@ -1893,7 +1893,7 @@ func TestReadChallengeTx_validSignedByServer(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(1000)), + Preconditions: Preconditions{Timebounds: NewTimeout(1000)}, }, ) assert.NoError(t, err) @@ -1928,7 +1928,7 @@ func TestReadChallengeTx_invalidNotSignedByServer(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(1000)), + Preconditions: Preconditions{Timebounds: NewTimeout(1000)}, }, ) assert.NoError(t, err) @@ -1961,7 +1961,7 @@ func TestReadChallengeTx_invalidCorrupted(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(1000)), + Preconditions: Preconditions{Timebounds: NewTimeout(1000)}, }, ) assert.NoError(t, err) @@ -2002,7 +2002,7 @@ func TestReadChallengeTx_invalidServerAccountIDMismatch(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(1000)), + Preconditions: Preconditions{Timebounds: NewTimeout(1000)}, }, ) assert.NoError(t, err) @@ -2037,7 +2037,7 @@ func TestReadChallengeTx_invalidSeqNoNotZero(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(1000)), + Preconditions: Preconditions{Timebounds: NewTimeout(1000)}, }, ) assert.NoError(t, err) @@ -2072,7 +2072,7 @@ func TestReadChallengeTx_invalidTimeboundsInfinite(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) assert.NoError(t, err) @@ -2107,7 +2107,7 @@ func TestReadChallengeTx_invalidTimeboundsOutsideRange(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimebounds(0, 100)), + Preconditions: Preconditions{Timebounds: NewTimebounds(0, 100)}, }, ) assert.NoError(t, err) @@ -2144,7 +2144,7 @@ func TestReadChallengeTx_validTimeboundsWithGracePeriod(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimebounds(unixNow+5*59, unixNow+60*60)), + Preconditions: Preconditions{Timebounds: NewTimebounds(unixNow+5*59, unixNow+60*60)}, }, ) assert.NoError(t, err) @@ -2180,7 +2180,7 @@ func TestReadChallengeTx_invalidTimeboundsWithGracePeriod(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimebounds(unixNow+5*61, unixNow+60*60)), + Preconditions: Preconditions{Timebounds: NewTimebounds(unixNow+5*61, unixNow+60*60)}, }, ) assert.NoError(t, err) @@ -2210,7 +2210,7 @@ func TestReadChallengeTx_invalidOperationWrongType(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(300)), + Preconditions: Preconditions{Timebounds: NewTimeout(300)}, }, ) assert.NoError(t, err) @@ -2238,7 +2238,7 @@ func TestReadChallengeTx_invalidOperationNoSourceAccount(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(300)), + Preconditions: Preconditions{Timebounds: NewTimeout(300)}, }, ) assert.NoError(t, err) @@ -2271,7 +2271,7 @@ func TestReadChallengeTx_invalidDataValueWrongEncodedLength(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(300)), + Preconditions: Preconditions{Timebounds: NewTimeout(300)}, }, ) assert.NoError(t, err) @@ -2306,7 +2306,7 @@ func TestReadChallengeTx_invalidDataValueCorruptBase64(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(300)), + Preconditions: Preconditions{Timebounds: NewTimeout(300)}, }, ) assert.NoError(t, err) @@ -2341,7 +2341,7 @@ func TestReadChallengeTx_invalidDataValueWrongByteLength(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(1000)), + Preconditions: Preconditions{Timebounds: NewTimeout(1000)}, }, ) assert.NoError(t, err) @@ -2491,7 +2491,7 @@ func TestReadChallengeTx_doesVerifyHomeDomainFailure(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(1000)), + Preconditions: Preconditions{Timebounds: NewTimeout(1000)}, }, ) assert.NoError(t, err) @@ -2524,7 +2524,7 @@ func TestReadChallengeTx_doesVerifyHomeDomainSuccess(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(1000)), + Preconditions: Preconditions{Timebounds: NewTimeout(1000)}, }, ) assert.NoError(t, err) @@ -2562,7 +2562,7 @@ func TestReadChallengeTx_allowsAdditionalManageDataOpsWithSourceAccountSetToServ IncrementSequenceNum: true, Operations: []Operation{&op1, &op2, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(1000)), + Preconditions: Preconditions{Timebounds: NewTimeout(1000)}, }, ) assert.NoError(t, err) @@ -2602,7 +2602,7 @@ func TestReadChallengeTx_disallowsAdditionalManageDataOpsWithoutSourceAccountSet IncrementSequenceNum: true, Operations: []Operation{&op1, &op2, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(1000)), + Preconditions: Preconditions{Timebounds: NewTimeout(1000)}, }, ) assert.NoError(t, err) @@ -2639,7 +2639,7 @@ func TestReadChallengeTx_disallowsAdditionalOpsOfOtherTypes(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op1, &op2, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(300)), + Preconditions: Preconditions{Timebounds: NewTimeout(300)}, }, ) assert.NoError(t, err) @@ -2674,7 +2674,7 @@ func TestReadChallengeTx_matchesHomeDomain(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op1, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(300)), + Preconditions: Preconditions{Timebounds: NewTimeout(300)}, }, ) assert.NoError(t, err) @@ -2707,7 +2707,7 @@ func TestReadChallengeTx_doesNotMatchHomeDomain(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op1, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(300)), + Preconditions: Preconditions{Timebounds: NewTimeout(300)}, }, ) assert.NoError(t, err) @@ -2735,7 +2735,7 @@ func TestReadChallengeTx_validWhenWebAuthDomainMissing(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op1}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(300)), + Preconditions: Preconditions{Timebounds: NewTimeout(300)}, }, ) assert.NoError(t, err) @@ -2767,7 +2767,7 @@ func TestReadChallengeTx_invalidWebAuthDomainSourceAccount(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op1, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(300)), + Preconditions: Preconditions{Timebounds: NewTimeout(300)}, }, ) assert.NoError(t, err) @@ -2799,7 +2799,7 @@ func TestReadChallengeTx_invalidWebAuthDomain(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op1, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(300)), + Preconditions: Preconditions{Timebounds: NewTimeout(300)}, }, ) assert.NoError(t, err) @@ -2832,7 +2832,7 @@ func TestVerifyChallengeTxThreshold_invalidServer(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(1000)), + Preconditions: Preconditions{Timebounds: NewTimeout(1000)}, }, network.TestNetworkPassphrase, clientKP, @@ -2868,7 +2868,7 @@ func TestVerifyChallengeTxThreshold_validServerAndClientKeyMeetingThreshold(t *t IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(1000)), + Preconditions: Preconditions{Timebounds: NewTimeout(1000)}, }, network.TestNetworkPassphrase, serverKP, clientKP, @@ -2909,7 +2909,7 @@ func TestVerifyChallengeTxThreshold_validServerAndMultipleClientKeyMeetingThresh IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(1000)), + Preconditions: Preconditions{Timebounds: NewTimeout(1000)}, }, network.TestNetworkPassphrase, serverKP, clientKP1, clientKP2, @@ -2964,7 +2964,7 @@ func TestVerifyChallengeTxThreshold_validServerAndMultipleClientKeyMeetingThresh IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(1000)), + Preconditions: Preconditions{Timebounds: NewTimeout(1000)}, }, network.TestNetworkPassphrase, serverKP, clientKP1, clientKP2, @@ -3015,7 +3015,7 @@ func TestVerifyChallengeTxThreshold_validServerAndMultipleClientKeyMeetingThresh IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(1000)), + Preconditions: Preconditions{Timebounds: NewTimeout(1000)}, }, network.TestNetworkPassphrase, serverKP, clientKP1, clientKP2, @@ -3056,7 +3056,7 @@ func TestVerifyChallengeTxThreshold_invalidServerAndMultipleClientKeyNotMeetingT IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(1000)), + Preconditions: Preconditions{Timebounds: NewTimeout(1000)}, }, network.TestNetworkPassphrase, serverKP, clientKP1, clientKP2, @@ -3095,7 +3095,7 @@ func TestVerifyChallengeTxThreshold_invalidClientKeyUnrecognized(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(1000)), + Preconditions: Preconditions{Timebounds: NewTimeout(1000)}, }, network.TestNetworkPassphrase, serverKP, clientKP1, clientKP2, clientKP3, @@ -3131,7 +3131,7 @@ func TestVerifyChallengeTxThreshold_invalidNoSigners(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(1000)), + Preconditions: Preconditions{Timebounds: NewTimeout(1000)}, }, network.TestNetworkPassphrase, serverKP, clientKP1, clientKP2, clientKP3, @@ -3163,7 +3163,7 @@ func TestVerifyChallengeTxThreshold_weightsAddToMoreThan8Bits(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(1000)), + Preconditions: Preconditions{Timebounds: NewTimeout(1000)}, }, network.TestNetworkPassphrase, serverKP, clientKP1, clientKP2, @@ -3205,7 +3205,7 @@ func TestVerifyChallengeTxThreshold_matchesHomeDomain(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op1, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(300)), + Preconditions: Preconditions{Timebounds: NewTimeout(300)}, }, ) assert.NoError(t, err) @@ -3248,7 +3248,7 @@ func TestVerifyChallengeTxThreshold_doesNotMatchHomeDomain(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op1, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(300)), + Preconditions: Preconditions{Timebounds: NewTimeout(300)}, }, ) assert.NoError(t, err) @@ -3286,7 +3286,7 @@ func TestVerifyChallengeTxThreshold_doesVerifyHomeDomainFailure(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(1000)), + Preconditions: Preconditions{Timebounds: NewTimeout(1000)}, }, network.TestNetworkPassphrase, serverKP, clientKP, @@ -3322,7 +3322,7 @@ func TestVerifyChallengeTxThreshold_doesVerifyHomeDomainSuccess(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(1000)), + Preconditions: Preconditions{Timebounds: NewTimeout(1000)}, }, network.TestNetworkPassphrase, serverKP, clientKP, @@ -3368,7 +3368,7 @@ func TestVerifyChallengeTxThreshold_allowsAdditionalManageDataOpsWithSourceAccou IncrementSequenceNum: true, Operations: []Operation{&op1, &op2, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(1000)), + Preconditions: Preconditions{Timebounds: NewTimeout(1000)}, }, network.TestNetworkPassphrase, serverKP, clientKP, @@ -3414,7 +3414,7 @@ func TestVerifyChallengeTxThreshold_disallowsAdditionalManageDataOpsWithoutSourc IncrementSequenceNum: true, Operations: []Operation{&op1, &op2, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(1000)), + Preconditions: Preconditions{Timebounds: NewTimeout(1000)}, }, network.TestNetworkPassphrase, serverKP, clientKP, @@ -3456,7 +3456,7 @@ func TestVerifyChallengeTxThreshold_disallowsAdditionalOpsOfOtherTypes(t *testin IncrementSequenceNum: true, Operations: []Operation{&op1, &op2, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(1000)), + Preconditions: Preconditions{Timebounds: NewTimeout(1000)}, }, network.TestNetworkPassphrase, serverKP, clientKP, @@ -3489,7 +3489,7 @@ func TestVerifyChallengeTxThreshold_validWhenWebAuthDomainMissing(t *testing.T) IncrementSequenceNum: true, Operations: []Operation{&op}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(1000)), + Preconditions: Preconditions{Timebounds: NewTimeout(1000)}, }, network.TestNetworkPassphrase, serverKP, clientKP, @@ -3529,7 +3529,7 @@ func TestVerifyChallengeTxThreshold_invalidWebAuthDomainSourceAccount(t *testing IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(1000)), + Preconditions: Preconditions{Timebounds: NewTimeout(1000)}, }, network.TestNetworkPassphrase, serverKP, clientKP, @@ -3565,7 +3565,7 @@ func TestVerifyChallengeTxThreshold_invalidWebAuthDomain(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(1000)), + Preconditions: Preconditions{Timebounds: NewTimeout(1000)}, }, network.TestNetworkPassphrase, serverKP, clientKP, @@ -3601,7 +3601,7 @@ func TestVerifyChallengeTxSigners_invalidServer(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(1000)), + Preconditions: Preconditions{Timebounds: NewTimeout(1000)}, }, network.TestNetworkPassphrase, clientKP, @@ -3634,7 +3634,7 @@ func TestVerifyChallengeTxSigners_validServerAndClientMasterKey(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(1000)), + Preconditions: Preconditions{Timebounds: NewTimeout(1000)}, }, network.TestNetworkPassphrase, serverKP, clientKP, @@ -3667,7 +3667,7 @@ func TestVerifyChallengeTxSigners_invalidServerAndNoClient(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(1000)), + Preconditions: Preconditions{Timebounds: NewTimeout(1000)}, }, network.TestNetworkPassphrase, serverKP, @@ -3701,7 +3701,7 @@ func TestVerifyChallengeTxSigners_invalidServerAndUnrecognizedClient(t *testing. IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(1000)), + Preconditions: Preconditions{Timebounds: NewTimeout(1000)}, }, network.TestNetworkPassphrase, serverKP, unrecognizedKP, @@ -3735,7 +3735,7 @@ func TestVerifyChallengeTxSigners_validServerAndMultipleClientSigners(t *testing IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(1000)), + Preconditions: Preconditions{Timebounds: NewTimeout(1000)}, }, network.TestNetworkPassphrase, serverKP, clientKP, clientKP2, @@ -3769,7 +3769,7 @@ func TestVerifyChallengeTxSigners_validServerAndMultipleClientSignersReverseOrde IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(1000)), + Preconditions: Preconditions{Timebounds: NewTimeout(1000)}, }, network.TestNetworkPassphrase, serverKP, clientKP2, clientKP, @@ -3803,7 +3803,7 @@ func TestVerifyChallengeTxSigners_validServerAndClientSignersNotMasterKey(t *tes IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(1000)), + Preconditions: Preconditions{Timebounds: NewTimeout(1000)}, }, network.TestNetworkPassphrase, serverKP, clientKP2, @@ -3837,7 +3837,7 @@ func TestVerifyChallengeTxSigners_validServerAndClientSignersIgnoresServerSigner IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(1000)), + Preconditions: Preconditions{Timebounds: NewTimeout(1000)}, }, network.TestNetworkPassphrase, serverKP, clientKP2, @@ -3871,7 +3871,7 @@ func TestVerifyChallengeTxSigners_invalidServerNoClientSignersIgnoresServerSigne IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(1000)), + Preconditions: Preconditions{Timebounds: NewTimeout(1000)}, }, network.TestNetworkPassphrase, serverKP, @@ -3905,7 +3905,7 @@ func TestVerifyChallengeTxSigners_validServerAndClientSignersIgnoresDuplicateSig IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(1000)), + Preconditions: Preconditions{Timebounds: NewTimeout(1000)}, }, network.TestNetworkPassphrase, serverKP, clientKP2, @@ -3942,7 +3942,7 @@ func TestVerifyChallengeTxSigners_validIgnorePreauthTxHashAndXHash(t *testing.T) IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(1000)), + Preconditions: Preconditions{Timebounds: NewTimeout(1000)}, }, network.TestNetworkPassphrase, serverKP, clientKP2, @@ -3976,7 +3976,7 @@ func TestVerifyChallengeTxSigners_invalidServerAndClientSignersIgnoresDuplicateS IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(1000)), + Preconditions: Preconditions{Timebounds: NewTimeout(1000)}, }, network.TestNetworkPassphrase, serverKP, clientKP2, @@ -4010,7 +4010,7 @@ func TestVerifyChallengeTxSigners_invalidServerAndClientSignersFailsDuplicateSig IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(1000)), + Preconditions: Preconditions{Timebounds: NewTimeout(1000)}, }, network.TestNetworkPassphrase, serverKP, clientKP2, clientKP2, @@ -4044,7 +4044,7 @@ func TestVerifyChallengeTxSigners_invalidServerAndClientSignersFailsSignerSeed(t IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(1000)), + Preconditions: Preconditions{Timebounds: NewTimeout(1000)}, }, network.TestNetworkPassphrase, serverKP, clientKP2, @@ -4077,7 +4077,7 @@ func TestVerifyChallengeTxSigners_invalidNoSigners(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(1000)), + Preconditions: Preconditions{Timebounds: NewTimeout(1000)}, }, network.TestNetworkPassphrase, serverKP, clientKP, @@ -4109,7 +4109,7 @@ func TestVerifyChallengeTxSigners_doesVerifyHomeDomainFailure(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(1000)), + Preconditions: Preconditions{Timebounds: NewTimeout(1000)}, }, network.TestNetworkPassphrase, serverKP, clientKP, @@ -4141,7 +4141,7 @@ func TestVerifyChallengeTxSigners_matchesHomeDomain(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op1, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(300)), + Preconditions: Preconditions{Timebounds: NewTimeout(300)}, }, ) assert.NoError(t, err) @@ -4181,7 +4181,7 @@ func TestVerifyChallengeTxSigners_doesNotMatchHomeDomain(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op1, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(300)), + Preconditions: Preconditions{Timebounds: NewTimeout(300)}, }, ) assert.NoError(t, err) @@ -4221,7 +4221,7 @@ func TestVerifyChallengeTxSigners_doesVerifyHomeDomainSuccess(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(1000)), + Preconditions: Preconditions{Timebounds: NewTimeout(1000)}, }, network.TestNetworkPassphrase, serverKP, clientKP, @@ -4258,7 +4258,7 @@ func TestVerifyChallengeTxSigners_allowsAdditionalManageDataOpsWithSourceAccount IncrementSequenceNum: true, Operations: []Operation{&op1, &op2, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(1000)), + Preconditions: Preconditions{Timebounds: NewTimeout(1000)}, }, network.TestNetworkPassphrase, serverKP, clientKP, @@ -4296,7 +4296,7 @@ func TestVerifyChallengeTxSigners_disallowsAdditionalManageDataOpsWithoutSourceA IncrementSequenceNum: true, Operations: []Operation{&op1, &op2, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(1000)), + Preconditions: Preconditions{Timebounds: NewTimeout(1000)}, }, network.TestNetworkPassphrase, serverKP, clientKP, @@ -4333,7 +4333,7 @@ func TestVerifyChallengeTxSigners_disallowsAdditionalOpsOfOtherTypes(t *testing. IncrementSequenceNum: true, Operations: []Operation{&op1, &op2, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(1000)), + Preconditions: Preconditions{Timebounds: NewTimeout(1000)}, }, network.TestNetworkPassphrase, serverKP, clientKP, @@ -4360,7 +4360,7 @@ func TestVerifyChallengeTxSigners_validWhenWebAuthDomainMissing(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(1000)), + Preconditions: Preconditions{Timebounds: NewTimeout(1000)}, }, network.TestNetworkPassphrase, serverKP, clientKP, @@ -4394,7 +4394,7 @@ func TestVerifyChallengeTxSigners_invalidWebAuthDomainSourceAccount(t *testing.T IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(1000)), + Preconditions: Preconditions{Timebounds: NewTimeout(1000)}, }, network.TestNetworkPassphrase, serverKP, clientKP, @@ -4425,7 +4425,7 @@ func TestVerifyChallengeTxSigners_invalidWebAuthDomain(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&op, &webAuthDomainOp}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(1000)), + Preconditions: Preconditions{Timebounds: NewTimeout(1000)}, }, network.TestNetworkPassphrase, serverKP, clientKP, @@ -4451,7 +4451,7 @@ func TestVerifyTxSignatureUnsignedTx(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&createAccount}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewTimeout(1000)), + Preconditions: Preconditions{Timebounds: NewTimeout(1000)}, }, ) assert.NoError(t, err) @@ -4477,7 +4477,7 @@ func TestVerifyTxSignatureSingle(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&createAccount}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) assert.NoError(t, err) @@ -4503,7 +4503,7 @@ func TestVerifyTxSignatureMultiple(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&createAccount}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) assert.NoError(t, err) @@ -4531,7 +4531,7 @@ func TestVerifyTxSignatureInvalid(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&createAccount}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) assert.NoError(t, err) @@ -4566,7 +4566,7 @@ func TestClaimableBalanceIds(t *testing.T) { SourceAccount: &aMuxedAccount, IncrementSequenceNum: true, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, Operations: []Operation{&claimableBalanceEntry}, }, ) @@ -4601,7 +4601,7 @@ func TestTransaction_marshalUnmarshalText(t *testing.T) { SourceAccount: &SimpleAccount{AccountID: k.Address(), Sequence: 1}, IncrementSequenceNum: false, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, Operations: []Operation{&BumpSequence{BumpTo: 2}}, }, ) @@ -4635,7 +4635,7 @@ func TestFeeBumpTransaction_marshalUnmarshalText(t *testing.T) { SourceAccount: &SimpleAccount{AccountID: k.Address(), Sequence: 1}, IncrementSequenceNum: false, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, Operations: []Operation{&BumpSequence{BumpTo: 2}}, }, ) @@ -4675,7 +4675,7 @@ func TestNewGenericTransactionWithTransaction(t *testing.T) { SourceAccount: &SimpleAccount{AccountID: k.Address(), Sequence: 1}, IncrementSequenceNum: false, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, Operations: []Operation{&BumpSequence{BumpTo: 2}}, }, ) @@ -4694,7 +4694,7 @@ func TestNewGenericTransactionWithFeeBumpTransaction(t *testing.T) { SourceAccount: &SimpleAccount{AccountID: k.Address(), Sequence: 1}, IncrementSequenceNum: false, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, Operations: []Operation{&BumpSequence{BumpTo: 2}}, }, ) @@ -4726,7 +4726,7 @@ func TestGenericTransaction_marshalUnmarshalText(t *testing.T) { SourceAccount: &SimpleAccount{AccountID: k.Address(), Sequence: 1}, IncrementSequenceNum: false, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, Operations: []Operation{&BumpSequence{BumpTo: 2}}, }, ) @@ -4783,7 +4783,7 @@ func TestGenericTransaction_marshalBinary(t *testing.T) { SourceAccount: &SimpleAccount{AccountID: k.Address(), Sequence: 1}, IncrementSequenceNum: false, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, Operations: []Operation{&BumpSequence{BumpTo: 2}}, }, ) @@ -4829,7 +4829,7 @@ func TestGenericTransaction_HashHex(t *testing.T) { IncrementSequenceNum: true, Operations: []Operation{&createAccount}, BaseFee: MinBaseFee, - Preconditions: NewPreconditions(NewInfiniteTimeout()), + Preconditions: Preconditions{Timebounds: NewInfiniteTimeout()}, }, ) assert.NoError(t, err) diff --git a/xdr/transaction_envelope.go b/xdr/transaction_envelope.go index e9a4ce0a89..b6a5479787 100644 --- a/xdr/transaction_envelope.go +++ b/xdr/transaction_envelope.go @@ -103,6 +103,26 @@ func (e TransactionEnvelope) TimeBounds() *TimeBounds { } } +// Preconditions returns the preconditions on the transaction. If the +// transaction is a V0 envelope (aka before preconditions existed, this crafts a +// timebound precondition). If the transaction is a fee bump, it returns the +// preconditions of the *inner* transaction. +func (e TransactionEnvelope) Preconditions() Preconditions { + switch e.Type { + case EnvelopeTypeEnvelopeTypeTxFeeBump: + return e.FeeBump.Tx.InnerTx.V1.Tx.Cond + case EnvelopeTypeEnvelopeTypeTx: + return e.V1.Tx.Cond + case EnvelopeTypeEnvelopeTypeTxV0: + return Preconditions{ + Type: PreconditionTypePrecondTime, + TimeBounds: e.V0.Tx.TimeBounds, + } + default: + panic("unsupported transaction type: " + e.Type.String()) + } +} + // Operations returns the operations set in the transaction envelope // Note for fee bump transactions, Operations() returns the operations // of the inner transaction From 84d44db066503e930eb52fdb9192a81981c3a9b7 Mon Sep 17 00:00:00 2001 From: George Kudrayvtsev Date: Thu, 24 Mar 2022 13:34:20 -0700 Subject: [PATCH 14/19] Properly unpack preconditions from transaction xdr --- txnbuild/preconditions.go | 9 ++++----- txnbuild/preconditions_test.go | 10 ++++++---- txnbuild/transaction.go | 12 +----------- txnbuild/transaction_test.go | 23 +++++++++++++++++------ xdr/transaction_envelope.go | 12 +++++------- 5 files changed, 33 insertions(+), 33 deletions(-) diff --git a/txnbuild/preconditions.go b/txnbuild/preconditions.go index 9eebe1a1f3..c88adc1f1f 100644 --- a/txnbuild/preconditions.go +++ b/txnbuild/preconditions.go @@ -97,12 +97,12 @@ func (cond *Preconditions) FromXDR(precondXdr xdr.Preconditions) { switch precondXdr.Type { case xdr.PreconditionTypePrecondTime: cond.Timebounds = NewTimebounds( - int64(precondXdr.TimeBounds.MinTime), - int64(precondXdr.TimeBounds.MaxTime), + int64(precondXdr.MustTimeBounds().MinTime), + int64(precondXdr.MustTimeBounds().MaxTime), ) case xdr.PreconditionTypePrecondV2: - inner := precondXdr.V2 + inner := precondXdr.MustV2() if inner.TimeBounds != nil { cond.Timebounds = NewTimebounds( @@ -132,8 +132,7 @@ func (cond *Preconditions) FromXDR(precondXdr xdr.Preconditions) { } case xdr.PreconditionTypePrecondNone: - default: - // panic? + default: // panic? } } diff --git a/txnbuild/preconditions_test.go b/txnbuild/preconditions_test.go index df381a9526..2932a52dc3 100644 --- a/txnbuild/preconditions_test.go +++ b/txnbuild/preconditions_test.go @@ -120,15 +120,17 @@ func TestPreconditions(t *testing.T) { actualBytes, err := precond.BuildXDR().MarshalBinary() assert.NoError(t, err) + // building the struct should result in identical XDR! assert.Equal(t, expectedBytes, actualBytes) - actualXdr := xdr.Preconditions{} - err = actualXdr.UnmarshalBinary(actualBytes) + // unpacking the XDR should result in identical structs! + roundTripXdr := xdr.Preconditions{} + err = roundTripXdr.UnmarshalBinary(actualBytes) assert.NoError(t, err) - assert.Equal(t, xdrPrecond, actualXdr) + assert.Equal(t, xdrPrecond, roundTripXdr) roundTripPrecond := Preconditions{} - roundTripPrecond.FromXDR(actualXdr) + roundTripPrecond.FromXDR(roundTripXdr) assert.Equal(t, precond, roundTripPrecond) }) } diff --git a/txnbuild/transaction.go b/txnbuild/transaction.go index 327ba89205..45bb31d968 100644 --- a/txnbuild/transaction.go +++ b/txnbuild/transaction.go @@ -772,17 +772,7 @@ func transactionFromParsedXDR(xdrEnv xdr.TransactionEnvelope) (*GenericTransacti memo: nil, } - // precond := xdrEnv.Preconditions() - // if precond.TimeBounds - - if timeBounds := xdrEnv.TimeBounds(); timeBounds != nil { - newTx.simple.preconditions = Preconditions{ - Timebounds: NewTimebounds( - int64(timeBounds.MinTime), - int64(timeBounds.MaxTime)), - } - } - + newTx.simple.preconditions.FromXDR(xdrEnv.Preconditions()) newTx.simple.memo, err = memoFromXDR(xdrEnv.Memo()) if err != nil { return nil, errors.Wrap(err, "unable to parse memo") diff --git a/txnbuild/transaction_test.go b/txnbuild/transaction_test.go index 540baed089..b5173245a8 100644 --- a/txnbuild/transaction_test.go +++ b/txnbuild/transaction_test.go @@ -50,24 +50,35 @@ func TestTimebounds(t *testing.T) { func TestV2Preconditions(t *testing.T) { kp0 := newKeypair0() - cond := Preconditions{Timebounds: NewTimeout(300)} - cond.Ledgerbounds = &Ledgerbounds{0, 1} - cond.MinSequenceNumber = nil - cond.MinSequenceNumberAge = xdr.Duration(10) - cond.MinSequenceNumberLedgerGap = 2 + cond := Preconditions{ + Timebounds: NewTimeout(300), + Ledgerbounds: &Ledgerbounds{0, 1}, + MinSequenceNumber: nil, + MinSequenceNumberAge: xdr.Duration(10), + MinSequenceNumberLedgerGap: 2, + } assert.True(t, cond.hasV2Conditions()) tp := TransactionParams{ SourceAccount: &SimpleAccount{AccountID: kp0.Address(), Sequence: 1}, Operations: []Operation{&BumpSequence{BumpTo: 0}}, BaseFee: MinBaseFee, - Preconditions: cond, } tx, err := NewTransaction(tp) assert.NoError(t, err) assert.Equal(t, cond, tx.preconditions) + + b64, err := tx.Base64() + assert.NoError(t, err) + + unpackedTx, err := TransactionFromXDR(b64) + assert.NoError(t, err) + if !assert.NotNil(t, unpackedTx.simple) { + t.FailNow() + } + assert.Equal(t, cond, unpackedTx.simple.preconditions) } func TestMissingSourceAccount(t *testing.T) { diff --git a/xdr/transaction_envelope.go b/xdr/transaction_envelope.go index b6a5479787..4f9b126996 100644 --- a/xdr/transaction_envelope.go +++ b/xdr/transaction_envelope.go @@ -104,9 +104,10 @@ func (e TransactionEnvelope) TimeBounds() *TimeBounds { } // Preconditions returns the preconditions on the transaction. If the -// transaction is a V0 envelope (aka before preconditions existed, this crafts a -// timebound precondition). If the transaction is a fee bump, it returns the -// preconditions of the *inner* transaction. +// transaction is a V0 envelope (aka before preconditions existed), this returns +// a new precondition (timebound if present, empty otherwise). If the +// transaction is a fee bump, it returns the preconditions of the *inner* +// transaction. func (e TransactionEnvelope) Preconditions() Preconditions { switch e.Type { case EnvelopeTypeEnvelopeTypeTxFeeBump: @@ -114,10 +115,7 @@ func (e TransactionEnvelope) Preconditions() Preconditions { case EnvelopeTypeEnvelopeTypeTx: return e.V1.Tx.Cond case EnvelopeTypeEnvelopeTypeTxV0: - return Preconditions{ - Type: PreconditionTypePrecondTime, - TimeBounds: e.V0.Tx.TimeBounds, - } + return NewPreconditionsWithTimeBounds(e.TimeBounds()) default: panic("unsupported transaction type: " + e.Type.String()) } From a0306fcec635e0fac0f800033fefedc8c2f8926f Mon Sep 17 00:00:00 2001 From: George Kudrayvtsev Date: Thu, 24 Mar 2022 14:05:20 -0700 Subject: [PATCH 15/19] Adds changelog entry --- txnbuild/CHANGELOG.md | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/txnbuild/CHANGELOG.md b/txnbuild/CHANGELOG.md index 8f5f88a083..a55f72e1b6 100644 --- a/txnbuild/CHANGELOG.md +++ b/txnbuild/CHANGELOG.md @@ -4,6 +4,22 @@ All notable changes to this project will be documented in this file. This project adheres to [Semantic Versioning](http://semver.org/). +## Unreleased + +### Breaking changes + +* Adds support for Protocol 19 transaction preconditions ([CAP-21](https://stellar.org/protocol/cap-21)). There are many new ways for a transaction to be (in)valid (see the new `Preconditions` structure), and the corresponding breaking change is in how transactions are built: + +```diff + tx, err := NewTransaction(TransactionParams{ + SourceAccount: someAccount, + // ... other parameters ... +- Timebounds: NewTimeout(5), ++ Preconditions: Preconditions{Timebounds: NewTimeout(5)}, + }) +``` + + ## [9.0.0](https://github.com/stellar/go/releases/tag/horizonclient-v9.0.0) - 2022-01-10 * Enable Muxed Accounts ([SEP-23](https://github.com/stellar/stellar-protocol/blob/master/ecosystem/sep-0023.md)) by default ([#4169](https://github.com/stellar/go/pull/4169)): From 757aa14c80f04c38f4e99e88bc93cdafcf4ab6e6 Mon Sep 17 00:00:00 2001 From: George Kudrayvtsev Date: Thu, 24 Mar 2022 14:43:41 -0700 Subject: [PATCH 16/19] Code cleanup, use fixtures over cloning :+1: --- txnbuild/preconditions.go | 8 +- txnbuild/preconditions_test.go | 184 ++++++++++++++------------------- 2 files changed, 80 insertions(+), 112 deletions(-) diff --git a/txnbuild/preconditions.go b/txnbuild/preconditions.go index c88adc1f1f..354ef90144 100644 --- a/txnbuild/preconditions.go +++ b/txnbuild/preconditions.go @@ -63,7 +63,7 @@ func (cond *Preconditions) BuildXDR() xdr.Preconditions { TimeBounds: &xdrTimeBounds, MinSeqAge: cond.MinSequenceNumberAge, MinSeqLedgerGap: xdr.Uint32(cond.MinSequenceNumberLedgerGap), - ExtraSigners: cond.ExtraSigners, + ExtraSigners: cond.ExtraSigners, // should we copy? } // micro-optimization: if the ledgerbounds will always succeed, omit them @@ -125,11 +125,7 @@ func (cond *Preconditions) FromXDR(precondXdr xdr.Preconditions) { cond.MinSequenceNumberAge = inner.MinSeqAge cond.MinSequenceNumberLedgerGap = uint32(inner.MinSeqLedgerGap) - - if len(inner.ExtraSigners) > 0 { - cond.ExtraSigners = make([]xdr.SignerKey, len(inner.ExtraSigners)) - copy(cond.ExtraSigners[:], inner.ExtraSigners) - } + cond.ExtraSigners = append(cond.ExtraSigners, inner.ExtraSigners...) case xdr.PreconditionTypePrecondNone: default: // panic? diff --git a/txnbuild/preconditions_test.go b/txnbuild/preconditions_test.go index 2932a52dc3..1158cf4569 100644 --- a/txnbuild/preconditions_test.go +++ b/txnbuild/preconditions_test.go @@ -7,15 +7,15 @@ import ( "github.com/stretchr/testify/assert" ) -var Signers = []xdr.SignerKey{ +var signers = []xdr.SignerKey{ xdr.MustSigner("GAOQJGUAB7NI7K7I62ORBXMN3J4SSWQUQ7FOEPSDJ322W2HMCNWPHXFB"), xdr.MustSigner("GA7QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJVSGZ"), xdr.MustSigner("PA7QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJUAAAAAQACAQDAQCQMBYIBEFAWDANBYHRAEISCMKBKFQXDAMRUGY4DUPB6IBZGM"), } -// TestClassifyingPreconditions ensures that Preconditions will correctly +// TestPreconditionClassification ensures that Preconditions will correctly // differentiate V1 (timebounds-only) or V2 (all other) preconditions correctly. -func TestClassifyingPreconditions(t *testing.T) { +func TestPreconditionClassification(t *testing.T) { tbpc := Preconditions{Timebounds: NewTimebounds(1, 2)} assert.False(t, (&Preconditions{}).hasV2Conditions()) assert.False(t, tbpc.hasV2Conditions()) @@ -24,49 +24,37 @@ func TestClassifyingPreconditions(t *testing.T) { assert.True(t, tbpc.hasV2Conditions()) } -// TestPreconditions ensures correct XDR is generated for a (non-exhaustive) -// handful of precondition combinations. -func TestPreconditions(t *testing.T) { - seqNum := int64(14) - xdrSeqNum := xdr.SequenceNumber(seqNum) - xdrCond := xdr.Preconditions{ - Type: xdr.PreconditionTypePrecondV2, - V2: &xdr.PreconditionsV2{ - TimeBounds: &xdr.TimeBounds{ - MinTime: xdr.TimePoint(27), - MaxTime: xdr.TimePoint(42), - }, - LedgerBounds: &xdr.LedgerBounds{ - MinLedger: xdr.Uint32(27), - MaxLedger: xdr.Uint32(42), - }, - MinSeqNum: &xdrSeqNum, - MinSeqAge: xdr.Duration(27), - MinSeqLedgerGap: xdr.Uint32(42), - ExtraSigners: Signers[:1], - }, - } - pc := Preconditions{ - Timebounds: NewTimebounds(27, 42), - Ledgerbounds: &Ledgerbounds{27, 42}, - MinSequenceNumber: &seqNum, - MinSequenceNumberAge: xdr.Duration(27), - MinSequenceNumberLedgerGap: 42, - ExtraSigners: Signers[:1], - } +// TestPreconditionValidation ensures that validation fails when necessary. +func TestPreconditionValidation(t *testing.T) { + t.Run("too many signers", func(t *testing.T) { + pc := Preconditions{ + Timebounds: NewTimebounds(27, 42), + ExtraSigners: signers, + } - // Note the pre-test invariant: xdrCond and pc match in structure. Each - // subtest clones these two structures, makes modifications, then ensures - // building the Preconditions version matches the XDR version. + assert.Error(t, pc.Validate()) + }) - preconditionModifiers := []struct { + t.Run("nonsense ledgerbounds", func(t *testing.T) { + pc := Preconditions{Timebounds: NewTimebounds(27, 42)} + pc.Ledgerbounds = &Ledgerbounds{MinLedger: 42, MaxLedger: 1} + assert.Error(t, pc.Validate()) + }) +} + +// TestPreconditionEncoding ensures correct XDR is generated for a +// (non-exhaustive) handful of precondition combinations. It generates XDR and +// txnbuild structures that match semantically, then makes sure they translate +// between each other (encode/decode round trips, etc.). +func TestPreconditionEncoding(t *testing.T) { + modifiers := []struct { Name string Modifier func() (xdr.Preconditions, Preconditions) }{ { "unchanged", func() (xdr.Preconditions, Preconditions) { - return xdrCond, pc + return createPreconditionFixtures() }, }, { @@ -84,39 +72,48 @@ func TestPreconditions(t *testing.T) { { "unbounded ledgerbounds", func() (xdr.Preconditions, Preconditions) { - newCond, newPc := clone(xdrCond, pc) - newCond.V2.LedgerBounds.MaxLedger = 0 - newPc.Ledgerbounds.MaxLedger = 0 - return newCond, newPc + xdrPc, pc := createPreconditionFixtures() + xdrPc.V2.LedgerBounds.MaxLedger = 0 + pc.Ledgerbounds.MaxLedger = 0 + return xdrPc, pc }, }, { "nil ledgerbounds", func() (xdr.Preconditions, Preconditions) { - newCond, newPc := clone(xdrCond, pc) - newCond.V2.LedgerBounds = nil - newPc.Ledgerbounds = nil - return newCond, newPc + xdrPc, pc := createPreconditionFixtures() + xdrPc.V2.LedgerBounds = nil + pc.Ledgerbounds = nil + return xdrPc, pc }, }, { "nil minSeq", func() (xdr.Preconditions, Preconditions) { - newCond, newPc := clone(xdrCond, pc) - newCond.V2.MinSeqNum = nil - newPc.MinSequenceNumber = nil - return newCond, newPc + xdrPc, pc := createPreconditionFixtures() + xdrPc.V2.MinSeqNum = nil + pc.MinSequenceNumber = nil + return xdrPc, pc + }, + }, + { + "no signers", + func() (xdr.Preconditions, Preconditions) { + xdrPc, pc := createPreconditionFixtures() + xdrPc.V2.ExtraSigners = nil + pc.ExtraSigners = nil + return xdrPc, pc }, }, } - for _, testCase := range preconditionModifiers { + for _, testCase := range modifiers { t.Run(testCase.Name, func(t *testing.T) { xdrPrecond, precond := testCase.Modifier() + assert.NoError(t, precond.Validate()) expectedBytes, err := xdrPrecond.MarshalBinary() assert.NoError(t, err) - actualBytes, err := precond.BuildXDR().MarshalBinary() assert.NoError(t, err) @@ -136,61 +133,36 @@ func TestPreconditions(t *testing.T) { } } -// TestPreconditionsValidation ensures that validation fails when necessary. -func TestPreconditionsValidation(t *testing.T) { - t.Run("too many signers", func(t *testing.T) { - pc := Preconditions{ - Timebounds: NewTimebounds(27, 42), - ExtraSigners: Signers, - } - - assert.Error(t, pc.Validate()) - }) - - t.Run("nonsense ledgerbounds", func(t *testing.T) { - pc := Preconditions{Timebounds: NewTimebounds(27, 42)} - pc.Ledgerbounds = &Ledgerbounds{MinLedger: 42, MaxLedger: 1} - assert.Error(t, pc.Validate()) - }) -} - -func clone(pcXdr xdr.Preconditions, pc Preconditions) (xdr.Preconditions, Preconditions) { - return cloneXdrPreconditions(pcXdr), clonePreconditions(pc) -} - -func cloneXdrPreconditions(pc xdr.Preconditions) xdr.Preconditions { - binary, err := pc.MarshalBinary() - if err != nil { - panic(err) - } - - clone := xdr.Preconditions{} - if err = clone.UnmarshalBinary(binary); err != nil { - panic(err) - } - - return clone -} - -func clonePreconditions(precond Preconditions) Preconditions { - cond := Preconditions{Timebounds: precond.Timebounds} - if precond.Ledgerbounds != nil { - cond.Ledgerbounds = &Ledgerbounds{ - MinLedger: precond.Ledgerbounds.MinLedger, - MaxLedger: precond.Ledgerbounds.MaxLedger, - } - } - - if precond.MinSequenceNumber != nil { - cond.MinSequenceNumber = precond.MinSequenceNumber +// createPreconditionFixtures returns some initial, sensible XDR and txnbuild +// precondition structures with all fields set and matching semantics. +func createPreconditionFixtures() (xdr.Preconditions, Preconditions) { + seqNum := int64(42) + xdrSeqNum := xdr.SequenceNumber(seqNum) + xdrCond := xdr.Preconditions{ + Type: xdr.PreconditionTypePrecondV2, + V2: &xdr.PreconditionsV2{ + TimeBounds: &xdr.TimeBounds{ + MinTime: xdr.TimePoint(27), + MaxTime: xdr.TimePoint(42), + }, + LedgerBounds: &xdr.LedgerBounds{ + MinLedger: xdr.Uint32(27), + MaxLedger: xdr.Uint32(42), + }, + MinSeqNum: &xdrSeqNum, + MinSeqAge: xdr.Duration(27), + MinSeqLedgerGap: xdr.Uint32(42), + ExtraSigners: []xdr.SignerKey{signers[0]}, + }, } - - cond.MinSequenceNumberAge = precond.MinSequenceNumberAge - cond.MinSequenceNumberLedgerGap = precond.MinSequenceNumberLedgerGap - - if len(precond.ExtraSigners) > 0 { - cond.ExtraSigners = append(cond.ExtraSigners, precond.ExtraSigners...) + pc := Preconditions{ + Timebounds: NewTimebounds(27, 42), + Ledgerbounds: &Ledgerbounds{27, 42}, + MinSequenceNumber: &seqNum, + MinSequenceNumberAge: xdr.Duration(27), + MinSequenceNumberLedgerGap: 42, + ExtraSigners: []xdr.SignerKey{signers[0]}, } - return cond + return xdrCond, pc } From 31aeb48dd2518c7ba9f17081b522611252aef7d5 Mon Sep 17 00:00:00 2001 From: George Kudrayvtsev Date: Thu, 24 Mar 2022 15:40:45 -0700 Subject: [PATCH 17/19] Rename Timebounds -> TimeBounds but keep type alias --- clients/horizonclient/client.go | 4 ++-- clients/horizonclient/main_test.go | 2 +- txnbuild/CHANGELOG.md | 6 +++++- txnbuild/preconditions.go | 2 +- txnbuild/timebounds.go | 32 ++++++++++++++++-------------- txnbuild/timebounds_test.go | 2 +- txnbuild/transaction.go | 2 +- 7 files changed, 28 insertions(+), 22 deletions(-) diff --git a/clients/horizonclient/client.go b/clients/horizonclient/client.go index 105c37fc7f..c35f3267ca 100644 --- a/clients/horizonclient/client.go +++ b/clients/horizonclient/client.go @@ -653,10 +653,10 @@ func (c *Client) StreamOrderBooks(ctx context.Context, request OrderBookRequest, // It defaults to localtime when the server time is not available. // Note that this will generate your timebounds when you init the transaction, not when you build or submit // the transaction! So give yourself enough time to get the transaction built and signed before submitting. -func (c *Client) FetchTimebounds(seconds int64) (txnbuild.Timebounds, error) { +func (c *Client) FetchTimebounds(seconds int64) (txnbuild.TimeBounds, error) { serverURL, err := url.Parse(c.HorizonURL) if err != nil { - return txnbuild.Timebounds{}, errors.Wrap(err, "unable to parse horizon url") + return txnbuild.TimeBounds{}, errors.Wrap(err, "unable to parse horizon url") } currentTime := currentServerTime(serverURL.Hostname(), c.clock.Now().UTC().Unix()) if currentTime != 0 { diff --git a/clients/horizonclient/main_test.go b/clients/horizonclient/main_test.go index 9dcee565af..b1119def12 100644 --- a/clients/horizonclient/main_test.go +++ b/clients/horizonclient/main_test.go @@ -1483,7 +1483,7 @@ func TestFetchTimebounds(t *testing.T) { ServerTimeMap["localhost"] = newRecord st, err = client.FetchTimebounds(100) assert.NoError(t, err) - assert.IsType(t, st, txnbuild.Timebounds{}) + assert.IsType(t, st, txnbuild.TimeBounds{}) assert.Equal(t, st.MinTime, int64(0)) // time should be 200, serverTime + 100seconds assert.Equal(t, st.MaxTime, int64(200)) diff --git a/txnbuild/CHANGELOG.md b/txnbuild/CHANGELOG.md index a55f72e1b6..40435f9594 100644 --- a/txnbuild/CHANGELOG.md +++ b/txnbuild/CHANGELOG.md @@ -15,10 +15,14 @@ file. This project adheres to [Semantic Versioning](http://semver.org/). SourceAccount: someAccount, // ... other parameters ... - Timebounds: NewTimeout(5), -+ Preconditions: Preconditions{Timebounds: NewTimeout(5)}, ++ Preconditions: Preconditions{TimeBounds: NewTimeout(5)}, }) ``` +* `Timebounds` has been renamed to `TimeBounds`, though a type alias remains. + +* A `*TimeBounds` structure is no longer considered valid (via `Validate()`) if it's `nil`. This further reinforces the fact that transactions need timebounds. + ## [9.0.0](https://github.com/stellar/go/releases/tag/horizonclient-v9.0.0) - 2022-01-10 diff --git a/txnbuild/preconditions.go b/txnbuild/preconditions.go index 354ef90144..8d11fc905d 100644 --- a/txnbuild/preconditions.go +++ b/txnbuild/preconditions.go @@ -8,7 +8,7 @@ import ( // Preconditions is a container for all transaction preconditions. type Preconditions struct { // Transaction is only valid during a certain time range. - Timebounds Timebounds + Timebounds TimeBounds // Transaction is valid for ledger numbers n such that minLedger <= n < // maxLedger (if maxLedger == 0, then only minLedger is checked) Ledgerbounds *Ledgerbounds diff --git a/txnbuild/timebounds.go b/txnbuild/timebounds.go index ce4fc9397f..2f6d0b31f5 100644 --- a/txnbuild/timebounds.go +++ b/txnbuild/timebounds.go @@ -9,7 +9,7 @@ import ( // what you want. const TimeoutInfinite = int64(0) -// Timebounds represents the time window during which a Stellar transaction is considered valid. +// TimeBounds represents the time window during which a Stellar transaction is considered valid. // // MinTime and MaxTime represent Stellar timebounds - a window of time over which the Transaction will be // considered valid. In general, almost all Transactions benefit from setting an upper timebound, because once submitted, @@ -17,17 +17,19 @@ const TimeoutInfinite = int64(0) // With an upper timebound, the submitter has a guaranteed time at which the Transaction is known to have either // succeeded or failed, and can then take appropriate action (e.g. to resubmit or mark as resolved). // -// Create a Timebounds struct using one of NewTimebounds(), NewTimeout(), or NewInfiniteTimeout(). -type Timebounds struct { +// Create a TimeBounds struct using one of NewTimebounds(), NewTimeout(), or NewInfiniteTimeout(). +type TimeBounds struct { MinTime int64 MaxTime int64 wasBuilt bool } -// Validate for Timebounds sanity-checks the configured Timebound limits, and confirms the object was built +// type Timebounds = TimeBounds + +// Validate for TimeBounds sanity-checks the configured Timebound limits, and confirms the object was built // using a factory method. This is done to ensure that default Timebound structs (which have no limits) are not // valid - you must explicitly specifiy the Timebound you require. -func (tb *Timebounds) Validate() error { +func (tb *TimeBounds) Validate() error { if tb == nil || !tb.wasBuilt { return errors.New("timebounds must be constructed using NewTimebounds(), NewTimeout(), or NewInfiniteTimeout()") } @@ -48,24 +50,24 @@ func (tb *Timebounds) Validate() error { return nil } -// NewTimebounds is a factory method that constructs a Timebounds object from a min and max time. -// A Transaction cannot be built unless a Timebounds object is provided through a factory method. -func NewTimebounds(minTime, maxTime int64) Timebounds { - return Timebounds{minTime, maxTime, true} +// NewTimebounds is a factory method that constructs a TimeBounds object from a min and max time. +// A Transaction cannot be built unless a TimeBounds object is provided through a factory method. +func NewTimebounds(minTime, maxTime int64) TimeBounds { + return TimeBounds{minTime, maxTime, true} } // NewTimeout is a factory method that sets the MaxTime to be the duration in seconds in the // future specified by 'timeout'. -// A Transaction cannot be built unless a Timebounds object is provided through a factory method. +// A Transaction cannot be built unless a TimeBounds object is provided through a factory method. // This method uses the provided system time - make sure it is accurate. -func NewTimeout(timeout int64) Timebounds { - return Timebounds{0, time.Now().UTC().Unix() + timeout, true} +func NewTimeout(timeout int64) TimeBounds { + return TimeBounds{0, time.Now().UTC().Unix() + timeout, true} } // NewInfiniteTimeout is a factory method that sets the MaxTime to a value representing an indefinite // upper time bound. This is rarely needed, but is helpful for certain smart contracts, and for -// deterministic testing. A Transaction cannot be built unless a Timebounds object is provided through +// deterministic testing. A Transaction cannot be built unless a TimeBounds object is provided through // a factory method. -func NewInfiniteTimeout() Timebounds { - return Timebounds{0, TimeoutInfinite, true} +func NewInfiniteTimeout() TimeBounds { + return TimeBounds{0, TimeoutInfinite, true} } diff --git a/txnbuild/timebounds_test.go b/txnbuild/timebounds_test.go index b852242e66..96a6517531 100644 --- a/txnbuild/timebounds_test.go +++ b/txnbuild/timebounds_test.go @@ -8,7 +8,7 @@ import ( ) func TestTimeboundsRequireConstructor(t *testing.T) { - tb := Timebounds{MinTime: -1, MaxTime: 300} + tb := TimeBounds{MinTime: -1, MaxTime: 300} err := tb.Validate() expectedErrMsg := "timebounds must be constructed using NewTimebounds(), NewTimeout(), or NewInfiniteTimeout()" diff --git a/txnbuild/transaction.go b/txnbuild/transaction.go index 45bb31d968..8c861bd430 100644 --- a/txnbuild/transaction.go +++ b/txnbuild/transaction.go @@ -241,7 +241,7 @@ func (t *Transaction) Memo() Memo { } // Timebounds returns the Timebounds configured for this transaction. -func (t *Transaction) Timebounds() Timebounds { +func (t *Transaction) Timebounds() TimeBounds { return t.preconditions.Timebounds } From bd421aa04251cb179678b130d7408c70ab961a03 Mon Sep 17 00:00:00 2001 From: George Kudrayvtsev Date: Thu, 24 Mar 2022 15:42:21 -0700 Subject: [PATCH 18/19] Rename Ledgerbounds -> LedgerBounds --- txnbuild/ledgerbounds.go | 6 +++--- txnbuild/preconditions.go | 4 ++-- txnbuild/preconditions_test.go | 4 ++-- txnbuild/transaction_test.go | 2 +- 4 files changed, 8 insertions(+), 8 deletions(-) diff --git a/txnbuild/ledgerbounds.go b/txnbuild/ledgerbounds.go index 299711ac95..49c4a1501a 100644 --- a/txnbuild/ledgerbounds.go +++ b/txnbuild/ledgerbounds.go @@ -2,15 +2,15 @@ package txnbuild import "github.com/stellar/go/support/errors" -// Ledgerbounds represent a transaction precondition that controls the ledger +// LedgerBounds represent a transaction precondition that controls the ledger // range for which a transaction is valid. Setting MaxLedger = 0 indicates there // is no maximum ledger. -type Ledgerbounds struct { +type LedgerBounds struct { MinLedger uint32 MaxLedger uint32 } -func (lb *Ledgerbounds) Validate() error { +func (lb *LedgerBounds) Validate() error { if lb == nil { return nil } diff --git a/txnbuild/preconditions.go b/txnbuild/preconditions.go index 8d11fc905d..1251785d3a 100644 --- a/txnbuild/preconditions.go +++ b/txnbuild/preconditions.go @@ -11,7 +11,7 @@ type Preconditions struct { Timebounds TimeBounds // Transaction is valid for ledger numbers n such that minLedger <= n < // maxLedger (if maxLedger == 0, then only minLedger is checked) - Ledgerbounds *Ledgerbounds + Ledgerbounds *LedgerBounds // If nil, the transaction is only valid when sourceAccount's sequence // number "N" is seqNum - 1. Otherwise, valid when N satisfies minSeqNum <= // N < tx.seqNum. @@ -112,7 +112,7 @@ func (cond *Preconditions) FromXDR(precondXdr xdr.Preconditions) { } if inner.LedgerBounds != nil { - cond.Ledgerbounds = &Ledgerbounds{ + cond.Ledgerbounds = &LedgerBounds{ MinLedger: uint32(inner.LedgerBounds.MinLedger), MaxLedger: uint32(inner.LedgerBounds.MaxLedger), } diff --git a/txnbuild/preconditions_test.go b/txnbuild/preconditions_test.go index 1158cf4569..9757f1317f 100644 --- a/txnbuild/preconditions_test.go +++ b/txnbuild/preconditions_test.go @@ -37,7 +37,7 @@ func TestPreconditionValidation(t *testing.T) { t.Run("nonsense ledgerbounds", func(t *testing.T) { pc := Preconditions{Timebounds: NewTimebounds(27, 42)} - pc.Ledgerbounds = &Ledgerbounds{MinLedger: 42, MaxLedger: 1} + pc.Ledgerbounds = &LedgerBounds{MinLedger: 42, MaxLedger: 1} assert.Error(t, pc.Validate()) }) } @@ -157,7 +157,7 @@ func createPreconditionFixtures() (xdr.Preconditions, Preconditions) { } pc := Preconditions{ Timebounds: NewTimebounds(27, 42), - Ledgerbounds: &Ledgerbounds{27, 42}, + Ledgerbounds: &LedgerBounds{27, 42}, MinSequenceNumber: &seqNum, MinSequenceNumberAge: xdr.Duration(27), MinSequenceNumberLedgerGap: 42, diff --git a/txnbuild/transaction_test.go b/txnbuild/transaction_test.go index b5173245a8..70f5d366a7 100644 --- a/txnbuild/transaction_test.go +++ b/txnbuild/transaction_test.go @@ -52,7 +52,7 @@ func TestV2Preconditions(t *testing.T) { cond := Preconditions{ Timebounds: NewTimeout(300), - Ledgerbounds: &Ledgerbounds{0, 1}, + Ledgerbounds: &LedgerBounds{0, 1}, MinSequenceNumber: nil, MinSequenceNumberAge: xdr.Duration(10), MinSequenceNumberLedgerGap: 2, From 32e78f17f3554195a8a3b51faca95822c42d0322 Mon Sep 17 00:00:00 2001 From: George Date: Thu, 24 Mar 2022 16:51:53 -0700 Subject: [PATCH 19/19] Uncomment type alias...? Co-authored-by: Leigh McCulloch <351529+leighmcculloch@users.noreply.github.com> --- txnbuild/timebounds.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/txnbuild/timebounds.go b/txnbuild/timebounds.go index 2f6d0b31f5..1019497c2e 100644 --- a/txnbuild/timebounds.go +++ b/txnbuild/timebounds.go @@ -24,7 +24,7 @@ type TimeBounds struct { wasBuilt bool } -// type Timebounds = TimeBounds +type Timebounds = TimeBounds // Validate for TimeBounds sanity-checks the configured Timebound limits, and confirms the object was built // using a factory method. This is done to ensure that default Timebound structs (which have no limits) are not