stellar-base 0.22.0 → 0.23.0.pre1

data/spec/lib/stellar/networks_spec.rb

@@ -1,77 +0,0 @@
-require "spec_helper"
-
-describe Stellar, ".default_network=" do
-
-  before(:each){ Stellar.default_network = "foo" }
-  after(:each){ Stellar.default_network = nil }
-
-  it "sets the value returned by current_network " do
-    expect(Stellar.current_network).to eql("foo")
-  end
-
-end
-
-describe Stellar, ".current_network" do
-
-  after(:each){ Stellar.default_network = nil }
-
-  it "returns the public network absent any other configuration" do
-    expect(Stellar.current_network).to eql(Stellar::Networks::TESTNET)
-  end
-
-  it "returns the default network if configured and not within a call to on_network" do
-    Stellar.default_network = "foo"
-    expect(Stellar.current_network).to eql("foo")
-  end
-
-  it "returns the network as specified by on_network, even when a default is set" do
-    Stellar.default_network = "foo"
-
-    Stellar.on_network "bar" do
-      expect(Stellar.current_network).to eql("bar")
-    end
-
-    expect(Stellar.current_network).to eql("foo")
-  end
-end
-
-describe Stellar, ".current_network_id" do
-  it "returns the sha256 of the current_network" do
-    expect(Stellar.current_network_id).to eql(Digest::SHA256.digest(Stellar.current_network))
-  end
-end
-
-describe Stellar, ".on_network" do
-
-  after(:each){ Thread.current["stellar_network_passphrase"] = nil }
-
-
-  it "sets the current_network and a thread local" do
-    Stellar.on_network "bar" do
-      expect(Stellar.current_network).to eql("bar")
-      expect(Thread.current["stellar_network_passphrase"]).to eql("bar")
-    end
-  end
-
-
-  it "nests" do
-    Stellar.on_network "foo" do
-      expect(Stellar.current_network).to eql("foo")
-      Stellar.on_network "bar" do
-        expect(Stellar.current_network).to eql("bar")
-      end
-      expect(Stellar.current_network).to eql("foo")
-    end
-  end
-
-
-  it "resets the network value when an error is raised" do
-    begin
-      Stellar.on_network "foo" do
-        raise "kablow"
-      end
-    rescue
-      expect(Stellar.current_network).to_not eql("foo")
-    end
-  end
-end

data/spec/lib/stellar/operation_spec.rb

@@ -1,131 +0,0 @@
-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)
-  Stellar::Convert.pk_to_address(pk)
-end
-
-describe "path payment operations" do
-  let(:destination){ Stellar::KeyPair.random }
-  let(:send_asset_issuer){ Stellar::KeyPair.master }
-  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){ [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
-      # 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(
-        destination: destination,
-        amount: amount,
-        with: with
-      )
-
-      expect(op.body.arm).to eql(:path_payment_strict_receive_op)
-    end
-  end
-
-  describe Stellar::Operation, ".path_payment_strict_receive" do
-    it "works" do
-      op = Stellar::Operation.path_payment_strict_receive(
-        destination: destination,
-        amount: amount,
-        with: with
-      )
-
-      expect(op.body.arm).to eql(:path_payment_strict_receive_op)
-      expect(op.body.value.destination).to eql(destination.public_key)
-      expect(op.body.value.send_asset).to eql(send_asset)
-      expect(op.body.value.dest_asset).to eql(dest_asset)
-      expect(op.body.value.send_max).to eq(100000000)
-      expect(op.body.value.dest_amount).to eq(92000000)
-    end
-  end
-
-  describe Stellar::Operation, ".path_payment_strict_send" do
-    it "works" do
-      op = Stellar::Operation.path_payment_strict_send(
-        destination: destination,
-        amount: amount,
-        with: with
-      )
-
-      expect(op.body.arm).to eql(:path_payment_strict_send_op)
-      expect(op.body.value.destination).to eql(destination.public_key)
-      expect(op.body.value.send_asset).to eql(send_asset)
-      expect(op.body.value.dest_asset).to eql(dest_asset)
-      expect(op.body.value.send_amount).to eq(100000000)
-      expect(op.body.value.dest_min).to eq(92000000)
-    end
-  end
-end
-
-describe Stellar::Operation, ".manage_data" do
-
-  it "works" do
-    op = Stellar::Operation.manage_data(name: "my name", value: "hello")
-    expect(op.body.manage_data_op!.data_name).to eql("my name")
-    expect(op.body.manage_data_op!.data_value).to eql("hello")
-    expect{ op.to_xdr }.to_not raise_error
-
-    op = Stellar::Operation.manage_data(name: "my name")
-    expect(op.body.manage_data_op!.data_name).to eql("my name")
-    expect(op.body.manage_data_op!.data_value).to be_nil
-    expect{ op.to_xdr }.to_not raise_error
-  end
-
-end
-
-describe Stellar::Operation, ".change_trust" do
-
-  let(:issuer) { Stellar::KeyPair.from_address("GDGU5OAPHNPU5UCLE5RDJHG7PXZFQYWKCFOEXSXNMR6KRQRI5T6XXCD7") }
-  let(:asset) { Stellar::Asset.alphanum4("USD", issuer) }
-
-  it "creates a ChangeTrustOp" do
-    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)
-  end
-
-  it "creates a ChangeTrustOp with an asset" do
-    asset = Stellar::Asset.alphanum4("USD", issuer)
-    op = Stellar::Operation.change_trust(line: asset, 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)
-  end
-
-  it "only allow sound `line` arguments" do
-    expect {
-      Stellar::Operation.change_trust(line: [:harmful_call, "USD", issuer])
-    }.to raise_error(ArgumentError, "must be one of #{Stellar::Asset::TYPES}")
-  end
-
-  it "creates a ChangeTrustOp with limit" do
-    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)
-  end
-
-  it "throws ArgumentError for incorrect limit argument" do
-    expect {
-      Stellar::Operation.change_trust(line: Stellar::Asset.alphanum4("USD", issuer), limit: true)
-    }.to raise_error(ArgumentError)
-  end
-end

data/spec/lib/stellar/path_payment_strict_receive_result_spec.rb

@@ -1,95 +0,0 @@
-require "spec_helper"
-
-describe Stellar::PathPaymentStrictReceiveResult, "#send_amount" do
-
-
-  context "when the result is not successful" do
-    subject{ Stellar::PathPaymentStrictReceiveResult.new(:path_payment_strict_receive_malformed) }
-
-    it "raises an exception if the result is not successful" do
-      expect{ subject.send_amount }.to raise_error(XDR::ArmNotSetError)
-    end
-  end
-
-  context "when the result has no claimed offers" do
-    let(:simple_success){ Stellar::SimplePaymentResult.new(amount: 100) }
-    let(:path_success){ Stellar::PathPaymentStrictReceiveResult::Success.new(last: simple_success) }
-
-    subject{ Stellar::PathPaymentStrictReceiveResult.new(:path_payment_strict_receive_success, path_success) }
-
-    it "returns the amount from the 'last' component" do
-      expect(subject.send_amount).to eql(100)
-    end
-  end
-
-
-  context "with simple 1-hop result" do
-    let(:simple_success){ Stellar::SimplePaymentResult.new(amount: 100) }
-    let(:offers) do
-      [Stellar::ClaimOfferAtom.new(asset_bought: Stellar::Asset.native, amount_bought: 200)]
-    end
-
-    let(:path_success) do
-      Stellar::PathPaymentStrictReceiveResult::Success.new({
-        offers: offers,
-        last:   simple_success,
-      })
-    end
-
-    subject{ Stellar::PathPaymentStrictReceiveResult.new(:path_payment_strict_receive_success, path_success) }
-
-    it "returns the amount from the ClaimOfferAtom" do
-      expect(subject.send_amount).to eql(200)
-    end
-  end
-
-  context "with 1-hop result that claimed multiple offers" do
-    let(:simple_success){ Stellar::SimplePaymentResult.new(amount: 100) }
-    let(:offers) do
-      [
-        Stellar::ClaimOfferAtom.new(asset_bought: Stellar::Asset.native, amount_bought: 200),
-        Stellar::ClaimOfferAtom.new(asset_bought: Stellar::Asset.native, amount_bought: 200),
-      ]
-    end
-
-    let(:path_success) do
-      Stellar::PathPaymentStrictReceiveResult::Success.new({
-        offers: offers,
-        last:   simple_success,
-      })
-    end
-
-    subject{ Stellar::PathPaymentStrictReceiveResult.new(:path_payment_strict_receive_success, path_success) }
-
-    it "returns the summed amount from the ClaimOfferAtoms" do
-      expect(subject.send_amount).to eql(400)
-    end
-  end
-
-
-  context "with multi-hop result that claimed multiple offers" do
-    let(:simple_success){ Stellar::SimplePaymentResult.new(amount: 100) }
-    let(:otherAsset){ Stellar::Asset.alphanum4("USD", Stellar::KeyPair.random) }
-    let(:offers) do
-      [
-        Stellar::ClaimOfferAtom.new(asset_bought: Stellar::Asset.native, amount_bought: 200),
-        Stellar::ClaimOfferAtom.new(asset_bought: Stellar::Asset.native, amount_bought: 200),
-        Stellar::ClaimOfferAtom.new(asset_bought: otherAsset, amount_bought: 200),
-      ]
-    end
-
-    let(:path_success) do
-      Stellar::PathPaymentStrictReceiveResult::Success.new({
-        offers: offers,
-        last:   simple_success,
-      })
-    end
-
-    subject{ Stellar::PathPaymentStrictReceiveResult.new(:path_payment_strict_receive_success, path_success) }
-
-    it "returns the summed amount from the ClaimOfferAtoms" do
-      expect(subject.send_amount).to eql(400)
-    end
-  end
-
-end

data/spec/lib/stellar/price_spec.rb

@@ -1,34 +0,0 @@
-require "spec_helper"
-
-describe Stellar::Price, "#from_f" do
-  subject{ Stellar::Price }
-  let(:seed){ 225571644875421139403973254661022579608 } #generated using Random.new
-  let(:random){ Random.new(seed) } 
-  let(:iterations){ ENV["SMOKE_ITERATIONS"].present? ? ENV["SMOKE_ITERATIONS"].to_i : 2000}
-
-  it "withstands a random smoke test" do
-    iterations.times do |i|
-      expected = random.rand
-      actual_p = subject.from_f(expected)
-      actual = actual_p.to_f
-
-      expect(actual).to be_within(0.000000001).of(actual)
-      expect(actual_p.n).to be <= Stellar::Price::MAX_PRECISION
-      expect(actual_p.d).to be <= Stellar::Price::MAX_PRECISION
-    end
-  end
-
-  it "works with bigdecimal" do
-      whole      = random.rand(1_000_000)
-      fractional = random.rand(10_000_000) # seven significant digits available for fractional
-      
-      expected = BigDecimal("#{whole}.#{fractional}")
-      actual_p = subject.from_f(expected)
-      actual = BigDecimal(actual_p.n) / BigDecimal(actual_p.d)
-
-      expect(actual).to be_within(BigDecimal("0.000000001")).of(actual)
-      expect(actual_p.n).to be <= Stellar::Price::MAX_PRECISION
-      expect(actual_p.d).to be <= Stellar::Price::MAX_PRECISION
-  end
-
-end

data/spec/lib/stellar/signer_key_spec.rb

@@ -1,26 +0,0 @@
-require "spec_helper"
-
-describe Stellar::SignerKey, ".hash_x" do
-
-  subject{ Stellar::SignerKey }
-
-  let(:hash_preimage){ "a" * 32 }
-  let(:hash){ Digest::SHA256.digest(hash_preimage) }
-
-  it "raises an argument error when not provided a 32-byte string" do
-    expect{subject.hash_x("hello world")}.to raise_error(ArgumentError)
-    expect{subject.hash_x("")}.to raise_error(ArgumentError)
-    expect{subject.hash_x("a" * 31)}.to raise_error(ArgumentError)
-    expect{subject.hash_x("a" * 33)}.to raise_error(ArgumentError)
-    expect{subject.hash_x([0] * 32)}.to raise_error(ArgumentError)
-
-  end
-
-  it "creates a HashX signer key" do
-    sk = subject.hash_x(hash_preimage)
-    expect(sk.switch).to eq(Stellar::SignerKeyType.signer_key_type_hash_x)
-    expect(sk.value).to be_an_instance_of(String)
-    expect(sk.value).to eq(hash)
-  end
-
-end

data/spec/lib/stellar/thresholds_spec.rb

@@ -1,62 +0,0 @@
-require 'spec_helper'
-
-describe Stellar::Thresholds, ".parse" do
-  subject{ Stellar::Thresholds }
-  let(:raw)    { "\x01\x02\x03\x04" }
-  let(:result) { subject.parse raw }
-
-  it "sets master_weight as the 1st byte" do
-    expect(result[:master_weight]).to eq(1)
-  end
-
-  it "sets low as the 2nd byte" do
-    expect(result[:low]).to eq(2)
-  end
-
-  it "sets medium as the 3rd byte" do
-    expect(result[:medium]).to eq(3)
-  end
-
-  it "sets high as the 4th byte" do
-    expect(result[:high]).to eq(4)
-  end
-end
-
-describe Stellar::Thresholds, ".make" do
-  subject{ Stellar::Thresholds }
-  let(:good){{master_weight: 1, low: 2, medium: 3, high: 4}}
-
-  it "works" do
-    expect(subject.make(good)).to eq("\x01\x02\x03\x04")
-  end
-
-  it "errors unless all components are provided" do
-    expect{ subject.make(good.except(:master_weight)) }.to raise_error(ArgumentError)
-    expect{ subject.make(good.except(:low)) }.to raise_error(ArgumentError)
-    expect{ subject.make(good.except(:medium)) }.to raise_error(ArgumentError)
-    expect{ subject.make(good.except(:high)) }.to raise_error(ArgumentError)
-  end
-
-  it "errors unless all components are numbers" do
-    expect{ subject.make(good.merge(master_weight: "hello")) }.to raise_error(ArgumentError)
-    expect{ subject.make(good.merge(low: "hello")) }.to raise_error(ArgumentError)
-    expect{ subject.make(good.merge(medium: "hello")) }.to raise_error(ArgumentError)
-    expect{ subject.make(good.merge(high: "hello")) }.to raise_error(ArgumentError)
-  end
-
-  it "errors unless all components are in (0..255)" do
-    expect{ subject.make(good.merge(master_weight: -1)) }.to raise_error(ArgumentError)
-    expect{ subject.make(good.merge(master_weight: 256)) }.to raise_error(ArgumentError)
-    expect{ subject.make(good.merge(low: -1)) }.to raise_error(ArgumentError)
-    expect{ subject.make(good.merge(low: 256)) }.to raise_error(ArgumentError)
-    expect{ subject.make(good.merge(medium: -1)) }.to raise_error(ArgumentError)
-    expect{ subject.make(good.merge(medium: 256)) }.to raise_error(ArgumentError)
-    expect{ subject.make(good.merge(high: -1)) }.to raise_error(ArgumentError)
-    expect{ subject.make(good.merge(high: 256)) }.to raise_error(ArgumentError)
-  end
-
-  it "ignores additional keys" do
-    expect{ subject.make(good.merge(foo: "a string")) }.not_to raise_error
-  end
-
-end

data/spec/lib/stellar/transaction_builder_spec.rb

@@ -1,263 +0,0 @@
-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