stellar-base 0.21.0 → 0.22.0

data/generated/stellar/transaction_meta.rb

@@ -11,6 +11,8 @@ require 'xdr'
 #       OperationMeta operations<>;
 #   case 1:
 #       TransactionMetaV1 v1;
+#   case 2:
+#       TransactionMetaV2 v2;
 #   };
 #
 # ===========================================================================
@@ -20,8 +22,10 @@ module Stellar
 
     switch 0, :operations
     switch 1, :v1
+    switch 2, :v2
 
     attribute :operations, XDR::VarArray[OperationMeta]
     attribute :v1,         TransactionMetaV1
+    attribute :v2,         TransactionMetaV2
   end
 end

data/generated/stellar/transaction_meta_v2.rb

@@ -0,0 +1,24 @@
+# This code was automatically generated using xdrgen
+# DO NOT EDIT or your changes may be overwritten
+
+require 'xdr'
+
+# === xdr source ============================================================
+#
+#   struct TransactionMetaV2
+#   {
+#       LedgerEntryChanges txChangesBefore; // tx level changes before operations
+#                                           // are applied if any
+#       OperationMeta operations<>;         // meta for each operation
+#       LedgerEntryChanges txChangesAfter;  // tx level changes after operations are
+#                                           // applied if any
+#   };
+#
+# ===========================================================================
+module Stellar
+  class TransactionMetaV2 < XDR::Struct
+    attribute :tx_changes_before, LedgerEntryChanges
+    attribute :operations,        XDR::VarArray[OperationMeta]
+    attribute :tx_changes_after,  LedgerEntryChanges
+  end
+end

data/generated/stellar/transaction_result_meta.rb

@@ -0,0 +1,22 @@
+# This code was automatically generated using xdrgen
+# DO NOT EDIT or your changes may be overwritten
+
+require 'xdr'
+
+# === xdr source ============================================================
+#
+#   struct TransactionResultMeta
+#   {
+#       TransactionResultPair result;
+#       LedgerEntryChanges feeProcessing;
+#       TransactionMeta txApplyProcessing;
+#   };
+#
+# ===========================================================================
+module Stellar
+  class TransactionResultMeta < XDR::Struct
+    attribute :result,              TransactionResultPair
+    attribute :fee_processing,      LedgerEntryChanges
+    attribute :tx_apply_processing, TransactionMeta
+  end
+end

data/generated/stellar/upgrade_entry_meta.rb

@@ -0,0 +1,20 @@
+# This code was automatically generated using xdrgen
+# DO NOT EDIT or your changes may be overwritten
+
+require 'xdr'
+
+# === xdr source ============================================================
+#
+#   struct UpgradeEntryMeta
+#   {
+#       LedgerUpgrade upgrade;
+#       LedgerEntryChanges changes;
+#   };
+#
+# ===========================================================================
+module Stellar
+  class UpgradeEntryMeta < XDR::Struct
+    attribute :upgrade, LedgerUpgrade
+    attribute :changes, LedgerEntryChanges
+  end
+end

data/lib/stellar-base.rb

@@ -25,6 +25,7 @@ require_relative './stellar/price'
 require_relative './stellar/signer_key'
 require_relative './stellar/thresholds'
 require_relative './stellar/transaction'
+require_relative './stellar/transaction_builder'
 require_relative './stellar/transaction_envelope'
 require_relative './stellar/util/strkey'
 require_relative './stellar/util/continued_fraction'

data/lib/stellar/base/version.rb

@@ -1,5 +1,5 @@
 module Stellar
   module Base
-    VERSION = "0.21.0"
+    VERSION = "0.22.0"
   end
 end

data/lib/stellar/operation.rb

@@ -43,7 +43,7 @@ module Stellar
     #                              Stellar::PaymentOp body
     def self.payment(attributes={})
       destination = attributes[:destination]
-      asset, amount = extract_amount(attributes[:amount])
+      asset, amount = get_asset_amount(attributes[:amount])
 
       raise ArgumentError unless destination.is_a?(KeyPair)
 
@@ -96,9 +96,11 @@ module Stellar
     #                              
     def self.path_payment_strict_receive(attributes={})
       destination             = attributes[:destination]
-      asset, amount           = extract_amount(attributes[:amount])
-      send_asset, send_max    = extract_amount(attributes[:with])
-      path                    = (attributes[:path] || []).map{|p| Stellar::Asset.send(*p)}
+      asset, amount           = get_asset_amount(attributes[:amount])
+      send_asset, send_max    = get_asset_amount(attributes[:with])
+      path                    = (attributes[:path] || []).map{
+        |p| p.is_a?(Array) ? Stellar::Asset.send(*p) : p
+      }
 
       raise ArgumentError unless destination.is_a?(KeyPair)
 
@@ -132,9 +134,11 @@ module Stellar
     #                              
     def self.path_payment_strict_send(attributes={})
       destination             = attributes[:destination]
-      asset, dest_min         = extract_amount(attributes[:amount])
-      send_asset, send_amount = extract_amount(attributes[:with])
-      path                    = (attributes[:path] || []).map{|p| Stellar::Asset.send(*p)}
+      asset, dest_min         = get_asset_amount(attributes[:amount])
+      send_asset, send_amount = get_asset_amount(attributes[:with])
+      path                    = (attributes[:path] || []).map{
+        |p| p.is_a?(Array) ? Stellar::Asset.send(*p) : p
+      }
 
       raise ArgumentError unless destination.is_a?(KeyPair)
 
@@ -199,11 +203,17 @@ module Stellar
     end
 
     def self.manage_sell_offer(attributes={})
-      buying     = Asset.send(*attributes[:buying])
-      selling    = Asset.send(*attributes[:selling])
-      amount     = interpret_amount(attributes[:amount])
-      offer_id   = attributes[:offer_id] || 0
-      price      = interpret_price(attributes[:price])
+      buying = attributes[:buying]
+      if buying.is_a?(Array)
+        buying = Asset.send(*buying)
+      end
+      selling = attributes[:selling]
+      if selling.is_a?(Array)
+        selling = Asset.send(*selling)
+      end
+      amount = interpret_amount(attributes[:amount])
+      offer_id = attributes[:offer_id] || 0
+      price = interpret_price(attributes[:price])
 
       op = ManageSellOfferOp.new({
         buying:     buying,
@@ -219,11 +229,17 @@ module Stellar
     end
 
     def self.manage_buy_offer(attributes={})
-      buying     = Asset.send(*attributes[:buying])
-      selling    = Asset.send(*attributes[:selling])
-      amount     = interpret_amount(attributes[:amount])
-      offer_id   = attributes[:offer_id] || 0
-      price      = interpret_price(attributes[:price])
+      buying = attributes[:buying]
+      if buying.is_a?(Array)
+        buying = Asset.send(*buying)
+      end
+      selling = attributes[:selling]
+      if selling.is_a?(Array)
+        selling = Asset.send(*selling)
+      end
+      amount = interpret_amount(attributes[:amount])
+      offer_id = attributes[:offer_id] || 0
+      price = interpret_price(attributes[:price])
 
       op = ManageBuyOfferOp.new({
         buying:     buying,
@@ -239,10 +255,16 @@ module Stellar
     end
 
     def self.create_passive_sell_offer(attributes={})
-      buying     = Asset.send(*attributes[:buying])
-      selling    = Asset.send(*attributes[:selling])
-      amount     = interpret_amount(attributes[:amount])
-      price      = interpret_price(attributes[:price])
+      buying = attributes[:buying]
+      if buying.is_a?(Array)
+        buying = Asset.send(*buying)
+      end
+      selling = attributes[:selling]
+      if selling.is_a?(Array)
+        selling = Asset.send(*selling)
+      end
+      amount = interpret_amount(attributes[:amount])
+      price = interpret_price(attributes[:price])
 
       op = CreatePassiveSellOfferOp.new({
         buying:     buying,
@@ -309,9 +331,12 @@ module Stellar
     def self.allow_trust(attributes={})
       op = AllowTrustOp.new()
 
-      trustor   = attributes[:trustor]
+      trustor = attributes[:trustor]
       authorize = attributes[:authorize]
-      asset     = Asset.send(*attributes[:asset])
+      asset = attributes[:asset]
+      if asset.is_a?(Array)
+        asset = Asset.send(*asset)
+      end
 
       raise ArgumentError, "Bad :trustor" unless trustor.is_a?(Stellar::KeyPair)
       raise ArgumentError, "Bad :authorize" unless authorize == !!authorize # check boolean
@@ -407,9 +432,13 @@ module Stellar
     end
 
     private
-    def self.extract_amount(a)
-      amount   = interpret_amount(a.last)
-      asset    = Stellar::Asset.send(*a[0...-1])
+    def self.get_asset_amount(values)
+      amount = interpret_amount(values.last)
+      if values[0].is_a?(Stellar::Asset)
+        asset = values.first
+      else
+        asset = Stellar::Asset.send(*values[0...-1])
+      end
 
       return asset, amount
     end

data/lib/stellar/transaction.rb

@@ -91,6 +91,14 @@ module Stellar
       make :bump_sequence, attributes
     end
 
+    #
+    # DEPRECATED
+    #
+    # All methods calling make() have been deprecated in favor of Stellar::TransactionBuilder.
+    # These functions only create single-operation transactions and essentially duplicate the
+    # methods provided by Stellar::Operation. Stellar::TransactionBuilder enables the construction
+    # of multi-operation transactions and mirrors the functionality provided by the Python and 
+    # JavaScript SDKs.
     #
     # Helper method to create a transaction with a single
     # operation of the provided type.  See class methods
@@ -104,6 +112,9 @@ module Stellar
     #
     # @return [Stellar::Transaction] the resulting transaction
     def self.make(operation_type, attributes={})
+      Stellar::Deprecation.warn(
+        "Transaction.#{operation_type.to_s} is deprecated. Use Stellar::TransactionBuilder instead."
+      )
       for_account(attributes).tap do |result|
         result.operations << Operation.send(operation_type, attributes)
       end

data/lib/stellar/transaction_builder.rb

@@ -0,0 +1,106 @@
+module Stellar
+  class TransactionBuilder
+
+    attr_reader :source_account, :sequence_number, :base_fee, :time_bounds, :time_bounds, :memo, :operations
+
+    def initialize(
+      source_account:, 
+      sequence_number:, 
+      base_fee: 100, 
+      time_bounds: nil, 
+      memo: nil
+    )
+      raise ArgumentError, "Bad :source_account" unless source_account.is_a?(Stellar::KeyPair)
+      raise ArgumentError, "Bad :sequence_number" unless sequence_number.is_a?(Integer) && sequence_number >= 0
+      raise ArgumentError, "Bad :time_bounds" unless time_bounds.is_a?(Stellar::TimeBounds) || time_bounds.nil?
+      raise ArgumentError, "Bad :base_fee" unless base_fee.is_a?(Integer) && base_fee >= 100
+
+      @source_account = source_account
+      @sequence_number = sequence_number
+      @base_fee = base_fee
+      @time_bounds = time_bounds
+      @memo = self.make_memo(memo)
+      @operations = Array.new
+    end
+
+    def build
+      if @time_bounds.nil?
+        raise "TransactionBuilder.time_bounds must be set during initialization or by calling set_timeout"
+      elsif !@time_bounds.min_time.is_a?(Integer) || !@time_bounds.max_time.is_a?(Integer)
+        raise "TimeBounds.min_time and max_time must be Integers"
+      elsif @time_bounds.max_time != 0 && @time_bounds.min_time > @time_bounds.max_time
+        raise "Timebounds.max_time must be greater than min_time"
+      end
+      tx = Stellar::Transaction.new(
+        source_account: @source_account.account_id,
+        fee: @base_fee * @operations.length,
+        seq_num: @sequence_number,
+        time_bounds: @time_bounds,
+        memo: @memo,
+        operations: @operations,
+        ext: Stellar::Transaction::Ext.new(0)
+      )
+      @sequence_number += 1
+      tx
+    end
+
+    def add_operation(operation)
+      raise ArgumentError, "Bad operation" unless operation.is_a? Stellar::Operation
+      @operations.push(operation)
+      self
+    end
+
+    def clear_operations()
+      @operations.clear
+      self
+    end
+
+    def set_sequence_number(seq_num)
+      raise ArgumentError, "Bad sequence number" unless seq_num.is_a?(Integer) && seq_num >= 0
+      @sequence_number = seq_num
+      self
+    end
+
+    def set_timeout(timeout)
+      if !timeout.is_a?(Integer) || timeout < 0
+        raise ArgumentError, "Timeout must be a non-negative integer"
+      end
+
+      if @time_bounds.nil?
+        @time_bounds = Stellar::TimeBounds.new(min_time: 0, max_time: nil)
+      end
+
+      if timeout == 0
+        @time_bounds.max_time = timeout
+      else
+        @time_bounds.max_time = Time.now.to_i + timeout
+      end
+
+      self
+    end
+
+    def set_memo(memo)
+      @memo = make_memo(memo)
+      self
+    end
+
+    def make_memo(memo)
+      case memo
+      when Stellar::Memo ;
+        memo
+      when nil ;
+        Memo.new(:memo_none)
+      when Integer ;
+        Memo.new(:memo_id, memo)
+      when String ;
+        Memo.new(:memo_text, memo)
+      when Array ;
+        t, val = *memo
+        Memo.new(:"memo_#{t}", val)
+      else
+        raise ArgumentError, "Bad :memo"
+      end
+    end
+
+  end
+end

data/ruby-stellar-base.gemspec

@@ -7,7 +7,7 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Scott Fleckenstein"]
   spec.email         = ["scott@stellar.org"]
   spec.summary       = %q{Stellar client library: XDR}
-  spec.homepage      = "https://github.com/bloom-solutions/ruby-stellar-base"
+  spec.homepage      = "https://github.com/stellar/ruby-stellar-base"
   spec.license       = "Apache 2.0"
 
   spec.files         = `git ls-files -z`.split("\x0")

data/spec/lib/stellar/operation_spec.rb

@@ -1,15 +1,12 @@
 require 'spec_helper'
 
 describe Stellar::Operation, ".payment" do
-
-
   it "correctly translates the provided amount to the native representation" do
     op = Stellar::Operation.payment(destination: Stellar::KeyPair.random, amount: [:native, 20])
     expect(op.body.value.amount).to eql(20_0000000)
     op = Stellar::Operation.payment(destination: Stellar::KeyPair.random, amount: [:native, "20"])
     expect(op.body.value.amount).to eql(20_0000000)
   end
-
 end
 
 def pk_to_address(pk)
@@ -22,13 +19,14 @@ describe "path payment operations" do
   let(:send_asset){ Stellar::Asset.alphanum4("USD", send_asset_issuer) }
   let(:dest_asset_issuer){ Stellar::KeyPair.master }
   let(:dest_asset){ Stellar::Asset.alphanum4("EUR", dest_asset_issuer) }
-  let(:amount){ [:alphanum4, dest_asset.code, dest_asset_issuer, 9.2] }
-  let(:with){ [:alphanum4, send_asset.code, send_asset_issuer, 10] }
+  let(:amount){ [Stellar::Asset.alphanum4(dest_asset.code, dest_asset_issuer), 9.2] }
+  let(:with){ [Stellar::Asset.alphanum4(send_asset.code, send_asset_issuer), 10] }
   
   describe Stellar::Operation, ".path_payment" do
     it "works" do
       destination = Stellar::KeyPair.random
-      amount = [:alphanum4, "USD", Stellar::KeyPair.master, 10]    
+      # test both forms of arrays
+      amount = [Stellar::Asset.alphanum4("USD", Stellar::KeyPair.master), 10]    
       with = [:alphanum4, "EUR", Stellar::KeyPair.master, 9.2]
 
       op = Stellar::Operation.path_payment(
@@ -98,7 +96,7 @@ describe Stellar::Operation, ".change_trust" do
   let(:asset) { Stellar::Asset.alphanum4("USD", issuer) }
 
   it "creates a ChangeTrustOp" do
-    op = Stellar::Operation.change_trust(line: [:alphanum4, "USD", issuer])
+    op = Stellar::Operation.change_trust(line: Stellar::Asset.alphanum4("USD", issuer))
     expect(op.body.value).to be_an_instance_of(Stellar::ChangeTrustOp)
     expect(op.body.value.line).to eq(Stellar::Asset.alphanum4("USD", issuer))
     expect(op.body.value.limit).to eq(9223372036854775807)
@@ -119,7 +117,7 @@ describe Stellar::Operation, ".change_trust" do
   end
 
   it "creates a ChangeTrustOp with limit" do
-    op = Stellar::Operation.change_trust(line: [:alphanum4, "USD", issuer], limit: 1234.75)
+    op = Stellar::Operation.change_trust(line: Stellar::Asset.alphanum4("USD", issuer), limit: 1234.75)
     expect(op.body.value).to be_an_instance_of(Stellar::ChangeTrustOp)
     expect(op.body.value.line).to eq(Stellar::Asset.alphanum4("USD", issuer))
     expect(op.body.value.limit).to eq(12347500000)
@@ -127,7 +125,7 @@ describe Stellar::Operation, ".change_trust" do
 
   it "throws ArgumentError for incorrect limit argument" do
     expect {
-      Stellar::Operation.change_trust(line: [:alphanum4, "USD", issuer], limit: true)
+      Stellar::Operation.change_trust(line: Stellar::Asset.alphanum4("USD", issuer), limit: true)
     }.to raise_error(ArgumentError)
   end
 end

data/spec/lib/stellar/transaction_builder_spec.rb

@@ -0,0 +1,263 @@
+require "spec_helper"
+
+describe Stellar::TransactionBuilder do
+  let(:key_pair){ Stellar::KeyPair.random }
+  builder = nil
+  before(:each) do
+    builder = Stellar::TransactionBuilder.new(
+      source_account: key_pair,
+      sequence_number: 1
+    )
+  end
+
+  describe ".initialize" do
+    it "bad source_account" do
+      expect { 
+        Stellar::TransactionBuilder.new(
+          source_account: key_pair.account_id,
+          sequence_number: 1
+        )
+      }.to raise_error(
+        ArgumentError, "Bad :source_account"
+      )
+    end
+    it "bad sequence_number" do
+      expect {
+        Stellar::TransactionBuilder.new(
+          source_account: key_pair,
+          sequence_number: -1
+        )
+      }.to raise_error(
+        ArgumentError, "Bad :sequence_number"
+      )
+    end
+    it "bad timeout" do
+      expect {
+        Stellar::TransactionBuilder.new(
+          source_account: key_pair,
+          sequence_number: 1,
+          time_bounds: 600
+        )
+      }.to raise_error(
+        ArgumentError, "Bad :time_bounds"
+      )
+    end
+    it "bad base_fee" do
+      expect {
+        Stellar::TransactionBuilder.new(
+          source_account: key_pair,
+          sequence_number: 1,
+          base_fee: 0
+        )
+      }.to raise_error(
+        ArgumentError, "Bad :base_fee"
+      )
+    end
+    it "bad memo" do
+      expect {
+        Stellar::TransactionBuilder.new(
+          source_account: key_pair,
+          sequence_number: 1,
+          memo: {"data" => "Testing bad memo"}
+        )
+      }.to raise_error(
+        ArgumentError, "Bad :memo"
+      )
+    end
+    it "success" do
+      builder = Stellar::TransactionBuilder.new(
+        source_account: key_pair,
+        sequence_number: 1,
+        time_bounds: Stellar::TimeBounds.new(min_time: 0, max_time: 600),
+        base_fee: 200,
+        memo: "My test memo"
+      )
+      expect(builder.memo).to eql(Stellar::Memo.new(:memo_text, "My test memo"))
+    end
+  end
+
+  describe ".add_operation" do
+    it "bad operation" do
+      expect { 
+        builder.add_operation(
+          [:bump_sequence, 1]
+        )
+      }.to raise_error(
+        ArgumentError, "Bad operation"
+      )
+    end
+
+    it "returns self" do
+      expect(builder.add_operation(
+          Stellar::Operation.bump_sequence({"bump_to": 1})
+      )).to be_an_instance_of(Stellar::TransactionBuilder)
+    end
+  end
+
+  describe ".clear_operations" do
+    it "can clear operations" do
+      builder = builder.add_operation(
+          Stellar::Operation.bump_sequence({"bump_to": 1})
+      ).clear_operations
+      expect(builder.operations).to eql([])
+    end
+
+    it "returns self" do
+      expect(builder.add_operation(
+          Stellar::Operation.bump_sequence({"bump_to": 1})
+      ).clear_operations).to be_an_instance_of(Stellar::TransactionBuilder)
+    end
+  end
+
+  describe ".set_sequence_number" do
+    it "allows sequence number to be updated" do
+      builder.set_sequence_number(5)
+      expect(builder.sequence_number).to eql(5)
+    end
+
+    it "returns self" do
+      expect(builder.set_sequence_number(3)).to be_an_instance_of(Stellar::TransactionBuilder)
+    end
+
+    it "raises an error for bad sequence number" do
+      expect {
+        builder.set_sequence_number(nil) 
+      }.to raise_error(
+        ArgumentError, "Bad sequence number"
+      )
+    end
+  end
+
+  describe ".set_timeout" do
+    it "raises an error for non-integers" do
+      expect {
+        builder.set_timeout(nil)
+      }.to raise_error(
+        ArgumentError, "Timeout must be a non-negative integer"
+      )
+    end
+
+    it "raises an error for negative timeouts" do
+      expect {
+        builder.set_timeout(-1)
+      }.to raise_error(
+        ArgumentError, "Timeout must be a non-negative integer"
+      )
+    end
+
+    it "returns self" do
+      expect(builder.set_timeout(10)).to be_an_instance_of(Stellar::TransactionBuilder)
+    end
+  end
+
+  describe ".set_memo" do
+    it "raises an error for bad memos" do
+      expect { 
+        builder.set_memo({"data" => "Testing bad memo"})
+      }.to raise_error(
+        ArgumentError, "Bad :memo"
+      )
+    end
+
+    it "works and returns self" do
+      expect(builder.set_memo("Hello").memo).to eql(Stellar::Memo.new(:memo_text, "Hello"))
+    end
+  end
+
+  describe ".build" do
+    it "raises error for time_bounds not set" do
+      expect {
+        tx = builder.add_operation(
+          Stellar::Operation.bump_sequence({"bump_to": 1})
+        ).build()
+      }.to raise_error(
+        RuntimeError, 
+        "TransactionBuilder.time_bounds must be set during initialization or by calling set_timeout"
+      )
+    end
+
+    it "raises an error for non-integer timebounds" do
+      builder = Stellar::TransactionBuilder.new(
+        source_account: key_pair,
+        sequence_number: 1,
+        time_bounds: Stellar::TimeBounds.new(min_time: "not", max_time: "integers")
+      )
+      expect {
+        tx = builder.add_operation(
+          Stellar::Operation.bump_sequence({"bump_to": 1})
+        ).build()
+      }.to raise_error(
+        RuntimeError, "TimeBounds.min_time and max_time must be Integers"
+      )
+    end
+
+    it "raises an error for bad TimeBounds range" do
+      builder = Stellar::TransactionBuilder.new(
+        source_account: key_pair,
+        sequence_number: 1,
+        time_bounds: Stellar::TimeBounds.new(min_time: Time.now.to_i + 10, max_time: Time.now.to_i)
+      )
+      expect {
+        tx = builder.add_operation(
+          Stellar::Operation.bump_sequence({"bump_to": 1})
+        ).build()
+      }.to raise_error(
+        RuntimeError, "Timebounds.max_time must be greater than min_time"
+      )
+    end
+
+    it "allows max_time to be zero" do
+      tx = builder.add_operation(
+          Stellar::Operation.bump_sequence({"bump_to": 1})
+      ).set_timeout(0).build()
+      expect(builder.time_bounds.max_time).to eql(0)
+    end
+
+    it "updates sequence number by 1 per build" do
+      builder.add_operation(
+          Stellar::Operation.bump_sequence({"bump_to": 1})
+      ).set_timeout(0).build()
+      expect(builder.sequence_number).to eql(2)
+    end
+
+    it "creates transaction successfully" do
+      bump_op = Stellar::Operation.bump_sequence({"bump_to": 1})
+      builder.add_operation(
+        Stellar::Operation.bump_sequence({"bump_to": 1})
+      ).set_timeout(600).build()
+      expect(builder.operations).to eql([bump_op])
+    end
+
+    it "allows for multiple transactions to be created" do
+      first_max_time = Time.now.to_i + 1000
+      bump_op = Stellar::Operation.bump_sequence({"bump_to": 1})
+      builder = Stellar::TransactionBuilder.new(
+        source_account: key_pair,
+        sequence_number: 1,
+        time_bounds: Stellar::TimeBounds.new(min_time: 0, max_time: first_max_time)
+      )
+      tx1 = builder.add_operation(
+        Stellar::Operation.bump_sequence({"bump_to": 1})
+      ).build()
+      expect(tx1.seq_num).to eql(1)
+      expect(tx1.operations).to eql([
+        Stellar::Operation.bump_sequence({"bump_to": 1})
+      ])
+      expect(tx1.time_bounds.max_time).to eql(first_max_time)
+      
+      tx2 = builder.clear_operations.add_operation(
+        Stellar::Operation.bump_sequence({"bump_to": 2})
+      ).set_timeout(0).build()
+      expect(tx2.seq_num).to eql(2)
+      expect(tx2.operations).to eql([
+        Stellar::Operation.bump_sequence({"bump_to": 2})
+      ])
+      expect(tx2.time_bounds.max_time).to eql(0)
+
+      expect(builder.sequence_number).to eql(3)
+      expect(builder.operations).to eql([
+        Stellar::Operation.bump_sequence({"bump_to": 2})
+      ])
+    end
+  end
+end