stellar-sdk 0.8.0 → 0.9.0.pre2

data/spec/lib/stellar/client_spec.rb

@@ -1,430 +0,0 @@
-require "spec_helper"
-
-describe Stellar::Client do
-
-  subject(:client) { Stellar::Client.default_testnet }
-
-  describe "headers" do
-    let(:headers) { client.horizon.headers }
-
-    it "has 'Accept'" do
-      expect(headers["Accept"]).
-        to eq "application/hal+json,application/problem+json,application/json"
-    end
-
-    it "has 'X-Client-Name'" do
-      expect(headers["X-Client-Name"]).to eq "ruby-stellar-sdk"
-    end
-
-    it "has 'X-Client-Version'" do
-      expect(headers["X-Client-Version"]).to eq Stellar::VERSION
-    end
-  end
-
-  describe "#default_testnet" do
-    it 'instantiates a client pointing to horizon testnet' do
-      client = described_class.default_testnet
-      expect(client.horizon._url).to eq(described_class::HORIZON_TESTNET_URL)
-    end
-  end
-
-  describe "#default" do
-    it 'instantiates a client pointing to horizon mainnet' do
-      client = described_class.default
-      expect(client.horizon._url).to eq(described_class::HORIZON_MAINNET_URL)
-    end
-  end
-
-  describe "#localhost" do
-    it 'instantiates a client pointing to localhost horizon' do
-      client = described_class.localhost
-      expect(client.horizon._url).to eq(described_class::HORIZON_LOCALHOST_URL)
-    end
-  end
-
-  describe "#initialize" do
-    let(:custom_horizon_url) { 'https://horizon.domain.com' }
-    it 'instantiates a client accepting custom options' do
-      client = described_class.new(horizon: custom_horizon_url)
-      expect(client.horizon._url).to eq(custom_horizon_url)
-    end
-  end
-
-  describe "#friendbot" do
-    let(:client) { Stellar::Client.default_testnet }
-    let(:account) { Stellar::Account.random }
-
-    it("requests for XLM from a friendbot", {
-      vcr: {record: :once, match_requests_on: [:method]}
-    }) do
-      response = client.friendbot(account)
-
-      expect(response).to be_success
-
-      destination_info = client.account_info(account)
-      balances = destination_info.balances
-      expect(balances).to_not be_empty
-      native_asset_balance_info = balances.find do |b|
-        b["asset_type"] == "native"
-      end
-      expect(native_asset_balance_info["balance"].to_f).to be > 0
-    end
-  end
-
-  describe "#create_account" do
-    let(:source) { Stellar::Account.from_seed(CONFIG[:source_seed]) }
-    let(:destination) { Stellar::Account.random }
-
-    it "creates the account", vcr: {record: :once, match_requests_on: [:method]} do
-      client.create_account(
-        funder: source,
-        account: destination,
-        starting_balance: 100,
-      )
-
-      destination_info = client.account_info(destination)
-      balances = destination_info.balances
-      expect(balances).to_not be_empty
-      native_asset_balance_info = balances.find do |b|
-        b["asset_type"] == "native"
-      end
-      expect(native_asset_balance_info["balance"].to_f).to eq 100.0
-    end
-  end
-
-  describe "#account_info" do
-    let(:account) { Stellar::Account.from_seed(CONFIG[:source_seed]) }
-    let(:client) { Stellar::Client.default_testnet }
-
-    it "returns the current details for the account", vcr: { record: :once, match_requests_on: [:method]} do
-      response = client.account_info(account)
-
-      expect(response.id).to eq CONFIG[:source_address]
-      expect(response.paging_token).to be_empty
-      expect(response.sequence).to eq "346973227974715"
-      expect(response.subentry_count).to eq 0
-      expect(response.thresholds).to include("low_threshold" => 0, "med_threshold" => 0, "high_threshold" => 0)
-      expect(response.flags).to include("auth_required" => false, "auth_revocable" => false)
-      expect(response.balances).to include("balance" => "3494.9997500", "asset_type" => "native")
-      expect(response.signers).to include(
-        "public_key" => CONFIG[:source_address],
-        "weight" => 1,
-        "type" => "ed25519_public_key",
-        "key" => CONFIG[:source_address]
-      )
-      expect(response.data).to be_empty
-    end
-  end
-
-  describe "#account_merge" do
-    let(:funder) { Stellar::Account.from_seed(CONFIG[:source_seed]) }
-    let(:client) { Stellar::Client.default_testnet }
-    let(:source) { Stellar::Account.random }
-    let(:destination) { Stellar::Account.random }
-
-    it "merges source account into destination", vcr: { record: :once, match_requests_on: [:method]} do
-      [source, destination].each do |account|
-        account = client.create_account(
-          funder: funder,
-          account: account,
-          starting_balance: 100,
-        )
-      end
-
-      client.account_merge(
-        account: source,
-        destination: destination
-      )
-
-      destination_info = client.account_info(destination)
-      native_asset_balance_info = destination_info.balances.find do |b|
-        b["asset_type"] == "native"
-      end
-      # balance of merged account is the balance of both accounts minus transaction fee for merge
-      expect(native_asset_balance_info["balance"].to_f).to eq 199.99999
-    end
-  end
-
-  describe "#send_payment" do
-    let(:source) { Stellar::Account.from_seed(CONFIG[:source_seed]) }
-
-    context "native asset" do
-      let(:destination) { Stellar::Account.random }
-
-      it "sends a native payment to the account", vcr: {record: :once, match_requests_on: [:method]} do
-        client.create_account(
-          funder: source,
-          account: destination,
-          starting_balance: 100,
-        )
-
-        amount = Stellar::Amount.new(150)
-
-        client.send_payment(
-          from: source,
-          to: destination,
-          amount: amount,
-        )
-
-        destination_info = client.account_info(destination)
-        balances = destination_info.balances
-        expect(balances).to_not be_empty
-        native_asset_balance_info = balances.find do |b|
-          b["asset_type"] == "native"
-        end
-        expect(native_asset_balance_info["balance"].to_f).to eq 250.0
-      end
-    end
-
-    context "alphanum4 asset" do
-      let(:issuer) { Stellar::Account.from_seed(CONFIG[:source_seed]) }
-      let(:destination) { Stellar::Account.random }
-
-      it("sends a alphanum4 asset to the destination", {
-        vcr: {record: :once, match_requests_on: [:method]},
-      }) do
-        client.create_account(
-          funder: issuer,
-          account: destination,
-          starting_balance: 2,
-        )
-
-        client.change_trust(
-          asset: [:alphanum4, "BTC", issuer.keypair],
-          source: destination,
-        )
-
-        asset = Stellar::Asset.alphanum4("BTC", source.keypair)
-        amount = Stellar::Amount.new(150, asset)
-        client.send_payment(
-          from: source,
-          to: destination,
-          amount: amount,
-        )
-
-        destination_info = client.account_info(destination)
-        btc_balance = destination_info.balances.find do |b|
-          b["asset_code"] == "BTC"
-        end["balance"].to_f
-
-        expect(btc_balance).to eq 150.0
-      end
-    end
-
-    context "alphanum12 asset" do
-      let(:issuer) { Stellar::Account.from_seed(CONFIG[:source_seed]) }
-      let(:destination) { Stellar::Account.random }
-
-      it("sends a alphanum12 asset to the destination", {
-        vcr: {record: :once, match_requests_on: [:method]},
-      }) do
-        client.create_account(
-          funder: issuer,
-          account: destination,
-          starting_balance: 2,
-        )
-
-        client.change_trust(
-          asset: [:alphanum12, "LONGNAME", issuer.keypair],
-          source: destination,
-        )
-
-        asset = Stellar::Asset.alphanum12("LONGNAME", source.keypair)
-        amount = Stellar::Amount.new(150, asset)
-
-        client.send_payment(
-          from: source,
-          to: destination,
-          amount: amount,
-        )
-
-        destination_info = client.account_info(destination)
-        btc_balance = destination_info.balances.find do |b|
-          b["asset_code"] == "LONGNAME"
-        end["balance"].to_f
-
-        expect(btc_balance).to eq 150.0
-      end
-    end
-
-    context "memo" do
-      let(:destination) { Stellar::Account.random }
-
-      it("accepts the memo attribute", {
-        vcr: {record: :once, match_requests_on: [:method]}
-      }) do
-        client.create_account(
-          funder: source,
-          account: destination,
-          starting_balance: 100,
-        )
-
-        amount = Stellar::Amount.new(150)
-
-        client.send_payment(
-          from: source,
-          to: destination,
-          amount: amount,
-          memo: "DESUKA",
-        )
-
-        last_tx = client.account_info(destination).
-          transactions(order: "desc")._get._embedded.records.first
-        expect(last_tx.memo).to eq "DESUKA"
-      end
-    end
-
-    context "using a payment channel" do
-      let(:transaction_source) { Stellar::Account.from_seed(CONFIG[:channel_seed]) }
-      let(:destination) { Stellar::Account.random }
-
-      it("sends a payment account through a channel account", {
-        vcr: {record: :once, match_requests_on: [:method]},
-      }) do
-        client.create_account(
-          funder: source,
-          account: destination,
-          starting_balance: 1,
-        )
-
-        tx = client.send_payment(
-          from: source,
-          to: destination,
-          amount: Stellar::Amount.new(0.55),
-          transaction_source: transaction_source,
-        )
-
-        tx_hash = tx._attributes["hash"]
-
-        tx = client.horizon.transaction(hash: tx_hash)
-        expect(tx.source_account).to eq transaction_source.address
-
-        operation = tx.operations.records.first
-        expect(operation.from).to eq source.address
-
-        destination_info = client.account_info(destination)
-        balances = destination_info.balances
-        expect(balances).to_not be_empty
-        native_asset_balance_info = balances.find do |b|
-          b["asset_type"] == "native"
-        end
-        expect(native_asset_balance_info["balance"].to_f).to eq 1.55
-      end
-
-      it("sends a payment when the channel is the same as `from`", {
-        vcr: {record: :once, match_requests_on: [:method]},
-      }) do
-        client.create_account(
-          funder: source,
-          account: destination,
-          starting_balance: 1,
-        )
-
-        tx = client.send_payment(
-          from: source,
-          to: destination,
-          amount: Stellar::Amount.new(0.55),
-          transaction_source: source,
-        )
-
-        tx_hash = tx._attributes["hash"]
-
-        tx = client.horizon.transaction(hash: tx_hash)
-        expect(tx.source_account).to eq source.address
-
-        operation = tx.operations.records.first
-        expect(operation.from).to eq source.address
-      end
-    end
-  end
-
-  describe "#transactions" do
-    let(:cursor) { '348403452088320' }
-
-    context "account transactions" do
-      let(:account) { Stellar::Account.from_seed(CONFIG[:source_seed]) }
-
-      it "returns a list of transaction for an account", vcr: {record: :once, match_requests_on: [:method]} do
-        response = client.transactions(account: account)
-        expect(response).to be_a(Stellar::TransactionPage)
-      end
-
-      it "accepts a cursor to return less data", vcr: {record: :once, match_requests_on: [:method]} do
-        response = client.transactions(account: account,
-                                       cursor: cursor)
-        expect(response).to be_a(Stellar::TransactionPage)
-      end
-    end
-
-    context "all transactions" do
-      it "returns a list of transactions", vcr: {record: :once, match_requests_on: [:method]} do
-        response = client.transactions
-        expect(response).to be_a(Stellar::TransactionPage)
-      end
-
-      it "accepts a cursor to return less data", vcr: {record: :once, match_requests_on: [:method]} do
-        response = client.transactions(cursor: cursor)
-        expect(response).to be_a(Stellar::TransactionPage)
-      end
-    end
-  end
-
-  describe "#change_trust" do
-    context "given an asset described as an array" do
-      let(:issuer) { Stellar::Account.from_seed(CONFIG[:source_seed]) }
-      let(:truster) { Stellar::Account.random }
-
-      it("creates, updates, or deletes a trustline", {
-        vcr: {record: :once, match_requests_on: [:method]},
-      }) do
-        client.create_account(
-          funder: issuer,
-          account: truster,
-          starting_balance: 2,
-        )
-
-        # Create trustline
-        client.change_trust(
-          asset: [:alphanum4, "BTC", issuer.keypair],
-          source: truster,
-        )
-
-        truster_info = client.account_info(truster)
-        btc_balance = truster_info.balances.find do |b|
-          b["asset_code"] == "BTC" && b["asset_issuer"] == issuer.address
-        end
-
-        expect(btc_balance).to_not be_nil
-
-        # Update trustline
-        client.change_trust(
-          asset: [:alphanum4, "BTC", issuer.keypair],
-          source: truster,
-          limit: 100,
-        )
-
-        truster_info = client.account_info(truster)
-        btc_balance = truster_info.balances.find do |b|
-          b["asset_code"] == "BTC" && b["asset_issuer"] == issuer.address
-        end
-
-        expect(btc_balance["limit"].to_f).to eq 100
-
-        # Delete trustline
-        client.change_trust(
-          asset: [:alphanum4, "BTC", issuer.keypair],
-          source: truster,
-          limit: 0,
-        )
-
-        truster_info = client.account_info(truster)
-        btc_balance = truster_info.balances.find do |b|
-          b["asset_code"] == "BTC" && b["asset_issuer"] == issuer.address
-        end
-
-        expect(btc_balance).to be_nil
-      end
-    end
-  end
-
-end

data/spec/lib/stellar/sep10_spec.rb

@@ -1,1148 +0,0 @@
-require "spec_helper"
-
-describe Stellar::SEP10 do
-
-  subject(:sep10) { Stellar::SEP10 }
-
-  let(:server) { Stellar::KeyPair.random }
-  let(:user) { Stellar::KeyPair.random }
-  let(:anchor) { "SDF" }
-  let(:timeout) { 600 }
-  let(:envelope) { Stellar::TransactionEnvelope.from_xdr(subject, "base64") }
-  let(:transaction) { envelope.tx }  
-
-  subject do
-    sep10.build_challenge_tx(server: server, client: user, anchor_name: anchor, timeout: timeout) 
-  end
-  
-  describe "#build_challenge_tx" do      
-    it "generates a valid SEP10 challenge" do
-      expect(transaction.seq_num).to eql(0)
-      expect(transaction.operations.size).to eql(1);
-      expect(transaction.source_account).to eql(server.public_key);
-
-      time_bounds = transaction.time_bounds
-      expect(time_bounds.max_time - time_bounds.min_time).to eql(600)
-      operation = transaction.operations.first
-
-      expect(operation.body.arm).to eql(:manage_data_op)
-      expect(operation.body.value.data_name).to eql("SDF auth")
-      expect(operation.source_account).to eql(user.public_key)
-      data_value = operation.body.value.data_value
-      expect(data_value.bytes.size).to eql(64)
-      expect(data_value.unpack("m")[0].size).to eql(48)
-    end
-
-    describe "defaults" do
-      subject do
-        sep10.build_challenge_tx(server: server, client: user, anchor_name: anchor) 
-      end
-      
-      it "has a default timeout of 300 seconds (5 minutes)" do
-        time_bounds = transaction.time_bounds
-        expect(time_bounds.max_time - time_bounds.min_time).to eql(300)
-      end
-    end
-  end
-
-  describe "#read_challenge_tx" do
-    subject do
-      challenge = super()
-      envelope = Stellar::TransactionEnvelope.from_xdr(challenge, 'base64')
-      envelope.tx.to_envelope(server, user).to_xdr(:base64)
-    end
-    
-    it "returns the envelope and client public key if the transaction is valid" do
-      expect(sep10.read_challenge_tx(challenge_xdr: subject, server: server)).to eql([envelope, user.address])
-    end
-
-    it "returns the envelope even if transaction signed by server but not client" do
-      envelope = Stellar::TransactionEnvelope.from_xdr(subject, 'base64')
-      expected_envelope = envelope.tx.to_envelope(server)
-      expect(
-        sep10.read_challenge_tx(challenge_xdr: expected_envelope.to_xdr(:base64), server: server)
-      ).to eql(
-        [expected_envelope, user.address]
-      )
-    end
-
-    it "throws an error if there are too many operations on the transaction" do
-      envelope = Stellar::TransactionEnvelope.from_xdr(subject, 'base64')
-      envelope.tx.operations += [Stellar::Operation.bump_sequence({bump_to: 1})]
-      bad_challege = envelope.tx.to_envelope(server, user).to_xdr(:base64)
-      expect {
-        sep10.read_challenge_tx(challenge_xdr: bad_challege, server:server)
-      }.to raise_error(
-        Stellar::InvalidSep10ChallengeError,
-        /The transaction should contain only one operation/
-      )
-    end
-
-    it "throws an error if transaction sequence number is different to zero"  do
-      envelope.tx.seq_num = 1
-
-      expect { 
-        sep10.read_challenge_tx(challenge_xdr: envelope.to_xdr(:base64), server: server)
-      }.to raise_error(Stellar::InvalidSep10ChallengeError, /The transaction sequence number should be zero/)
-    end      
-
-    it "throws an error if transaction source account is different to server account id"  do
-      expect {
-        sep10.read_challenge_tx(challenge_xdr: envelope.to_xdr(:base64), server: Stellar::KeyPair.random)
-      }.to raise_error(Stellar::InvalidSep10ChallengeError, /The transaction source account is not equal to the server's account/)
-    end
-
-    it "throws an error if transaction doesn't contain any operation" do
-      envelope.tx.operations = []
-
-      expect { 
-        sep10.read_challenge_tx(challenge_xdr: envelope.to_xdr(:base64), server: server)
-      }.to raise_error(Stellar::InvalidSep10ChallengeError, /The transaction should contain only one operation/)
-    end
-
-    it "throws an error if operation does not contain the source account" do
-      op = envelope.tx.operations[0]
-      op.source_account = nil
-
-      expect { 
-        sep10.read_challenge_tx(challenge_xdr: envelope.to_xdr(:base64), server: server)
-      }.to raise_error(Stellar::InvalidSep10ChallengeError, /The transaction's operation should contain a source account/)
-    end
-      
-    it "throws an error if operation is not manage data"  do
-      envelope.tx.operations = [ 
-        Stellar::Operation.payment(
-          destination: Stellar::KeyPair.random, 
-          amount: [:native, 20],
-          source_account: Stellar::KeyPair.random
-        )
-      ]
-
-      expect { 
-        sep10.read_challenge_tx(challenge_xdr: envelope.to_xdr(:base64), server: server)
-      }.to raise_error(Stellar::InvalidSep10ChallengeError, /The transaction's operation should be manageData/)
-    end
-
-    it "throws an error if operation value is not a 64 bytes base64 string" do
-      transaction.operations[0].body.value.data_value = SecureRandom.random_bytes(64)
-      expect { 
-        sep10.read_challenge_tx(challenge_xdr: envelope.to_xdr(:base64), server: server)          
-      }.to raise_error(
-        Stellar::InvalidSep10ChallengeError,
-        /The transaction's operation value should be a 64 bytes base64 random string/
-      )
-    end
-
-    it "throws an error if transaction is not signed by the server" do
-      envelope.signatures = envelope.signatures.slice(1, 2)
-      
-      expect { 
-        sep10.read_challenge_tx(challenge_xdr: envelope.to_xdr(:base64), server: server)          
-      }.to raise_error(
-        Stellar::InvalidSep10ChallengeError,
-        /The transaction is not signed by the server/
-      )
-    end
-
-
-    it "throws an error if transaction does not contain valid timeBounds" do
-      envelope.tx.time_bounds = nil
-      challenge = envelope.tx.to_envelope(server, user).to_xdr(:base64)
-
-      expect { 
-        sep10.read_challenge_tx(challenge_xdr: challenge, server: server)          
-      }.to raise_error(
-        Stellar::InvalidSep10ChallengeError,
-        /The transaction has expired/
-      )
-
-      envelope.tx.time_bounds = Stellar::TimeBounds.new(min_time: 0, max_time: 5)
-      challenge = envelope.tx.to_envelope(server, user).to_xdr(:base64)
-
-      expect { 
-        sep10.read_challenge_tx(challenge_xdr: challenge, server: server)          
-      }.to raise_error(
-        Stellar::InvalidSep10ChallengeError,
-        /The transaction has expired/
-      )
-
-      now = Time.now.to_i
-      envelope.tx.time_bounds = Stellar::TimeBounds.new(
-        min_time: now + 100, 
-        max_time: now + 500
-      )
-      challenge = envelope.tx.to_envelope(server, user).to_xdr(:base64)
-
-      expect { 
-        sep10.read_challenge_tx(challenge_xdr: challenge, server: server)          
-      }.to raise_error(
-        Stellar::InvalidSep10ChallengeError,
-        /The transaction has expired/
-      )
-    end
-  end
-
-  describe "#verify_challenge_tx_threshold" do
-    it "raises transaction not signed by server" do
-      server_kp = Stellar::KeyPair.random
-      client_kp_a = Stellar::KeyPair.random
-      client_kp_b = Stellar::KeyPair.random
-      client_kp_c = Stellar::KeyPair.random
-      timeout = 600
-      anchor_name = "SDF"
-
-      challenge = sep10.build_challenge_tx(
-        server: server_kp,
-        client: client_kp_a,
-        anchor_name: anchor_name,
-        timeout: timeout,
-      )
-
-      challenge_envelope = Stellar::TransactionEnvelope.from_xdr(challenge, "base64")
-      challenge_envelope.signatures = [client_kp_a, client_kp_b, client_kp_c].map { 
-        |kp| challenge_envelope.tx.sign_decorated(kp) 
-      }
-
-      signers = Set[
-        {'key' => client_kp_a.address, 'weight': 1},
-        {'key' => client_kp_b.address, 'weight': 1},
-        {'key' => client_kp_c.address, 'weight': 1}
-      ]
-
-      expect {
-        sep10.verify_challenge_tx_threshold(
-          challenge_xdr: challenge_envelope.to_xdr(:base64), 
-          server: server_kp, 
-          signers: signers,
-          threshold: 3
-        )
-      }.to raise_error(
-        Stellar::InvalidSep10ChallengeError,
-        /The transaction is not signed by the server/
-      )
-    end
-
-    it "succeeds with extra signers passed" do
-      server_kp = Stellar::KeyPair.random
-      client_kp_a = Stellar::KeyPair.random
-      client_kp_b = Stellar::KeyPair.random
-      client_kp_c = Stellar::KeyPair.random
-
-      challenge_envelope = Stellar::TransactionEnvelope.from_xdr(
-        sep10.build_challenge_tx(
-          server: server_kp,
-          client: client_kp_a,
-          anchor_name: "SDF",
-          timeout: 600,
-        ), 
-        "base64"
-      )
-      challenge_envelope.signatures += [
-        challenge_envelope.tx.sign_decorated(client_kp_a),
-        challenge_envelope.tx.sign_decorated(client_kp_b)
-      ]
-      challenge = challenge_envelope.to_xdr(:base64)
-
-      expect(
-        sep10.verify_challenge_tx_threshold(
-          challenge_xdr: challenge,
-          server: server_kp,
-          signers: Set[
-            {'key' => client_kp_a.address, 'weight' => 1},
-            {'key' => client_kp_b.address, 'weight' => 1},
-            {'key' => client_kp_c.address, 'weight' => 1}
-          ],
-          threshold: 2
-        )
-      ).to eql(
-        Set[
-          {'key' => client_kp_a.address, 'weight' => 1},
-          {'key' => client_kp_b.address, 'weight' => 1}
-        ]
-      )
-    end
-
-    it "rasies an error for unrecognizied signatures" do
-      server_kp = Stellar::KeyPair.random
-      client_kp_a = Stellar::KeyPair.random
-      client_kp_b = Stellar::KeyPair.random
-      client_kp_c = Stellar::KeyPair.random
-
-      challenge_envelope = Stellar::TransactionEnvelope.from_xdr(
-        sep10.build_challenge_tx(
-          server: server_kp,
-          client: client_kp_a,
-          anchor_name: "SDF",
-          timeout: 600,
-        ), 
-        "base64"
-      )
-      challenge_envelope.signatures += [
-        challenge_envelope.tx.sign_decorated(client_kp_a),
-        challenge_envelope.tx.sign_decorated(client_kp_b),
-        challenge_envelope.tx.sign_decorated(client_kp_c)
-      ]
-      challenge = challenge_envelope.to_xdr(:base64)
-
-      expect {
-        sep10.verify_challenge_tx_threshold(
-          challenge_xdr: challenge,
-          server: server_kp,
-          signers: Set[
-            {'key' => client_kp_a.address, 'weight' => 1},
-            {'key' => client_kp_b.address, 'weight' => 1},
-          ],
-          threshold: 2
-        )
-      }.to raise_error(
-        Stellar::InvalidSep10ChallengeError,
-        /Transaction has unrecognized signatures./
-      )
-    end
-
-    it "verifies proper challenge and threshold" do
-      server_kp = Stellar::KeyPair.random
-      client_kp_a = Stellar::KeyPair.random
-      client_kp_b = Stellar::KeyPair.random
-      client_kp_c = Stellar::KeyPair.random
-      timeout = 600
-      anchor_name = "SDF"
-
-      challenge = sep10.build_challenge_tx(
-        server: server_kp,
-        client: client_kp_a,
-        anchor_name: anchor_name,
-        timeout: timeout,
-      )
-
-      transaction = Stellar::TransactionEnvelope.from_xdr(challenge, "base64")
-      transaction.signatures += [
-        client_kp_a, client_kp_b, client_kp_c
-      ].map { |kp| transaction.tx.sign_decorated(kp) }
-      challenge_tx = transaction.to_xdr(:base64)
-
-      signers = Set[
-        {"key" => client_kp_a.address, "weight" => 1},
-        {"key" => client_kp_b.address, "weight" => 2},
-        {"key" => client_kp_c.address, "weight" => 4},
-      ]
-
-      signers_found = sep10.verify_challenge_tx_threshold(
-        challenge_xdr: challenge_tx,
-        server: server_kp,
-        threshold: 7,
-        signers: signers,
-      )
-      expect(signers_found).to eql(signers)
-    end
-
-    it "raises error when signers don't meet threshold" do
-      server_kp = Stellar::KeyPair.random
-      client_kp_a = Stellar::KeyPair.random
-      client_kp_b = Stellar::KeyPair.random
-      client_kp_c = Stellar::KeyPair.random
-      timeout = 600
-      anchor_name = "SDF"
-
-      challenge = sep10.build_challenge_tx(
-        server: server_kp,
-        client: client_kp_a,
-        anchor_name: anchor_name,
-        timeout: timeout,
-      )
-
-      transaction = Stellar::TransactionEnvelope.from_xdr(challenge, "base64")
-      transaction.signatures.push(transaction.tx.sign_decorated(client_kp_a))
-      challenge_tx = transaction.to_xdr(:base64)
-
-      signers = Set[
-        {"key" => client_kp_a.address, "weight" => 1},
-        {"key" => client_kp_b.address, "weight" => 2},
-        {"key" => client_kp_c.address, "weight" => 4},
-      ]
-
-      expect {
-        sep10.verify_challenge_tx_threshold(
-          challenge_xdr: challenge_tx,
-          server: server_kp,
-          threshold: 7,
-          signers: signers,
-        )
-      }.to raise_error(
-        Stellar::InvalidSep10ChallengeError,
-        "signers with weight %d do not meet threshold %d." % [1, 7]
-      )
-    end
-
-    it "ignores non-G address" do
-      preauth_tx_hash = "TAQCSRX2RIDJNHFIFHWD63X7D7D6TRT5Y2S6E3TEMXTG5W3OECHZ2OG4"
-      x_hash = "XDRPF6NZRR7EEVO7ESIWUDXHAOMM2QSKIQQBJK6I2FB7YKDZES5UCLWD"
-      server_kp = Stellar::KeyPair.random
-      client_kp = Stellar::KeyPair.random
-
-      challenge_envelope = Stellar::TransactionEnvelope.from_xdr(
-        sep10.build_challenge_tx(
-          server: server_kp,
-          client: client_kp,
-          anchor_name: "SDF",
-          timeout: 600,
-        ), 
-        "base64"
-      )
-      challenge_envelope.signatures += [challenge_envelope.tx.sign_decorated(client_kp)]
-      challenge = challenge_envelope.to_xdr(:base64)
-
-      expect(
-        sep10.verify_challenge_tx_threshold(
-          challenge_xdr: challenge,
-          server: server_kp,
-          signers: Set[
-            {'key'=> client_kp.address, 'weight' => 1},
-            {'key'=> preauth_tx_hash, 'weight' => 1},
-            {'key'=> x_hash, 'weight' => 1}
-          ],
-          threshold: 1
-        )
-      ).to eql(
-        Set[
-          {'key' => client_kp.address, 'weight' => 1}
-        ]
-      )
-    end
-
-    it "raises no signers error" do
-      server_kp = Stellar::KeyPair.random
-      client_kp_a = Stellar::KeyPair.random
-      client_kp_b = Stellar::KeyPair.random
-      client_kp_c = Stellar::KeyPair.random
-      timeout = 600
-      anchor_name = "SDF"
-
-      challenge = sep10.build_challenge_tx(
-        server: server_kp,
-        client: client_kp_a,
-        anchor_name: anchor_name,
-        timeout: timeout,
-      )
-
-      challenge_envelope = Stellar::TransactionEnvelope.from_xdr(challenge, "base64")
-      challenge_envelope.signatures += [
-        client_kp_a, client_kp_b, client_kp_c
-      ].map { |kp| challenge_envelope.tx.sign_decorated(kp) }
-
-      expect {
-        sep10.verify_challenge_tx_threshold(
-          challenge_xdr: challenge_envelope.to_xdr(:base64), 
-          server: server_kp, 
-          signers: Set.new,
-          threshold: 2
-        )
-      }.to raise_error(
-        Stellar::InvalidSep10ChallengeError,
-        /No signers provided./
-      )
-    end
-
-    it "raises an error for no signatures" do
-      server_kp = Stellar::KeyPair.random
-      client_kp = Stellar::KeyPair.random
-
-      challenge_envelope = Stellar::TransactionEnvelope.from_xdr(
-        sep10.build_challenge_tx(
-          server: server_kp,
-          client: client_kp,
-          anchor_name: "SDF",
-          timeout: 600,
-        ), 
-        "base64"
-      )
-      challenge_envelope.signatures.clear
-      challenge = challenge_envelope.to_xdr(:base64)
-
-      expect {
-        sep10.verify_challenge_tx_threshold(
-          challenge_xdr: challenge,
-          server: server_kp,
-          signers: Set[
-            {'key' => client_kp.address, 'weight' => 1}
-          ],
-          threshold: 2
-        )
-      }.to raise_error(
-        Stellar::InvalidSep10ChallengeError,
-        /The transaction is not signed by the server/
-      )
-    end
-
-    it "does not pass back duplicate signers or double-count weights" do
-      server_kp = Stellar::KeyPair.random
-      client_kp = Stellar::KeyPair.random
-
-      challenge_envelope = Stellar::TransactionEnvelope.from_xdr(
-        sep10.build_challenge_tx(
-          server: server_kp,
-          client: client_kp,
-          anchor_name: "SDF",
-          timeout: 600,
-        ), 
-        "base64"
-      )
-      challenge_envelope.signatures += [challenge_envelope.tx.sign_decorated(client_kp)]
-      challenge = challenge_envelope.to_xdr(:base64)
-
-      expect(
-        sep10.verify_challenge_tx_threshold(
-          challenge_xdr: challenge,
-          server: server_kp,
-          signers: Set[
-            {'key' => client_kp.address, 'weight' => 1},
-            {'key' => client_kp.address, 'weight' => 2}
-          ],
-          threshold: 1
-        )
-      ).to eql(
-        Set[{'key' => client_kp.address, 'weight' => 1}]
-      )
-
-      expect {
-        sep10.verify_challenge_tx_threshold(
-          challenge_xdr: challenge,
-          server: server_kp,
-          signers: Set[
-            {'key' => client_kp.address, 'weight' => 1},
-            {'key' => client_kp.address, 'weight' => 2}
-          ],
-          threshold: 3
-        )
-      }.to raise_error(
-        Stellar::InvalidSep10ChallengeError,
-        /signers with weight 1 do not meet threshold 3./
-      )
-    end
-
-    it "raises an error for duplicate signatures" do
-      server_kp = Stellar::KeyPair.random
-      client_kp = Stellar::KeyPair.random
-
-      challenge_envelope = Stellar::TransactionEnvelope.from_xdr(
-        sep10.build_challenge_tx(
-          server: server_kp,
-          client: client_kp,
-          anchor_name: "SDF",
-          timeout: 600,
-        ), 
-        "base64"
-      )
-      challenge_envelope.signatures += [
-        challenge_envelope.tx.sign_decorated(client_kp),
-        challenge_envelope.tx.sign_decorated(client_kp)
-      ]
-      challenge = challenge_envelope.to_xdr(:base64)
-
-      expect {
-        sep10.verify_challenge_tx_threshold(
-          challenge_xdr: challenge,
-          server: server_kp,
-          signers: Set[{'key' => client_kp.address, 'weight' => 1}],
-          threshold: 1
-        )
-      }.to raise_error(
-        Stellar::InvalidSep10ChallengeError,
-        /Transaction has unrecognized signatures./
-      )
-    end
-
-    it "raises an error for duplicate signatures and signers" do
-      server_kp = Stellar::KeyPair.random
-      client_kp = Stellar::KeyPair.random
-
-      challenge_envelope = Stellar::TransactionEnvelope.from_xdr(
-        sep10.build_challenge_tx(
-          server: server_kp,
-          client: client_kp,
-          anchor_name: "SDF",
-          timeout: 600,
-        ), 
-        "base64"
-      )
-      challenge_envelope.signatures += [
-        challenge_envelope.tx.sign_decorated(client_kp),
-        challenge_envelope.tx.sign_decorated(client_kp)
-      ]
-      challenge = challenge_envelope.to_xdr(:base64)
-
-      expect {
-        sep10.verify_challenge_tx_threshold(
-          challenge_xdr: challenge,
-          server: server_kp,
-          signers: Set[
-            {'key' => client_kp.address, 'weight' => 1},
-            {'key' => client_kp.address, 'weight' => 2}
-          ],
-          threshold: 1
-        )
-      }.to raise_error(
-        Stellar::InvalidSep10ChallengeError,
-        /Transaction has unrecognized signatures./
-      )
-    end
-  end
-
-  describe "#verify_challenge_tx" do
-    it "verifies proper challenge transaction" do
-      server_kp = Stellar::KeyPair.random
-      client_kp = Stellar::KeyPair.random
-      timeout = 600
-      anchor_name = "SDF"
-
-      challenge = sep10.build_challenge_tx(
-        server: server_kp,
-        client: client_kp,
-        anchor_name: anchor_name,
-        timeout: timeout,
-      )
-
-      envelope = Stellar::TransactionEnvelope.from_xdr(challenge, "base64")
-      envelope.signatures.push(envelope.tx.sign_decorated(client_kp))
-      challenge_tx = envelope.to_xdr(:base64)
-
-      sep10.verify_challenge_tx(
-        challenge_xdr: challenge_tx, 
-        server: server_kp
-      )
-    end
-
-    it "raises not signed by client" do
-      server_kp = Stellar::KeyPair.random
-      client_kp = Stellar::KeyPair.random
-      timeout = 600
-      anchor_name = "SDF"
-
-      challenge = sep10.build_challenge_tx(
-        server: server_kp,
-        client: client_kp,
-        anchor_name: anchor_name,
-        timeout: timeout,
-      )
-
-      expect {
-        sep10.verify_challenge_tx(
-          challenge_xdr: challenge, 
-          server: server_kp
-        )
-      }.to raise_error(
-        Stellar::InvalidSep10ChallengeError,
-        "Transaction not signed by client: %s" % [client_kp.address]
-      )
-    end
-  end
-
-  describe "#verify_challenge_tx_signers" do
-    it "returns expected signatures" do
-      server_kp = Stellar::KeyPair.random
-      client_kp_a = Stellar::KeyPair.random
-      client_kp_b = Stellar::KeyPair.random
-      client_kp_c = Stellar::KeyPair.random
-      timeout = 600
-      anchor_name = "SDF"
-
-      challenge = sep10.build_challenge_tx(
-        server: server_kp,
-        client: client_kp_a,
-        anchor_name: anchor_name,
-        timeout: timeout,
-      )
-
-      challenge_envelope = Stellar::TransactionEnvelope.from_xdr(challenge, "base64")
-      challenge_envelope.signatures += [
-        client_kp_a, client_kp_b, client_kp_c
-      ].map { |kp| challenge_envelope.tx.sign_decorated(kp) }
-
-      signers = Set[
-        client_kp_a.address,
-        client_kp_b.address,
-        client_kp_c.address,
-        Stellar::KeyPair.random.address
-      ]
-      signers_found = sep10.verify_challenge_tx_signers(
-        challenge_xdr: challenge_envelope.to_xdr(:base64), 
-        server: server_kp, 
-        signers: signers
-      )
-      expect(signers_found).to eql(Set[
-        client_kp_a.address,
-        client_kp_b.address,
-        client_kp_c.address,
-      ])
-    end
-
-    it "raises no signers error" do
-      server_kp = Stellar::KeyPair.random
-      client_kp_a = Stellar::KeyPair.random
-      client_kp_b = Stellar::KeyPair.random
-      client_kp_c = Stellar::KeyPair.random
-      timeout = 600
-      anchor_name = "SDF"
-
-      challenge = sep10.build_challenge_tx(
-        server: server_kp,
-        client: client_kp_a,
-        anchor_name: anchor_name,
-        timeout: timeout,
-      )
-
-      challenge_envelope = Stellar::TransactionEnvelope.from_xdr(challenge, "base64")
-      challenge_envelope.signatures += [
-        client_kp_a, client_kp_b, client_kp_c
-      ].map { |kp| challenge_envelope.tx.sign_decorated(kp) }
-
-      expect {
-        sep10.verify_challenge_tx_signers(
-          challenge_xdr: challenge_envelope.to_xdr(:base64), 
-          server: server_kp, 
-          signers: Set.new
-        )
-      }.to raise_error(
-        Stellar::InvalidSep10ChallengeError,
-        /No signers provided./
-      )
-    end
-
-    it "raises transaction not signed by server" do
-      server_kp = Stellar::KeyPair.random
-      client_kp_a = Stellar::KeyPair.random
-      client_kp_b = Stellar::KeyPair.random
-      client_kp_c = Stellar::KeyPair.random
-      timeout = 600
-      anchor_name = "SDF"
-
-      challenge = sep10.build_challenge_tx(
-        server: server_kp,
-        client: client_kp_a,
-        anchor_name: anchor_name,
-        timeout: timeout,
-      )
-
-      challenge_envelope = Stellar::TransactionEnvelope.from_xdr(challenge, "base64")
-      challenge_envelope.signatures = [client_kp_a, client_kp_b, client_kp_c].map { 
-        |kp| challenge_envelope.tx.sign_decorated(kp) 
-      }
-
-      signers = Set[
-        client_kp_a.address,
-        client_kp_b.address,
-        client_kp_c.address
-      ]
-
-      expect {
-        sep10.verify_challenge_tx_signers(
-          challenge_xdr: challenge_envelope.to_xdr(:base64), 
-          server: server_kp, 
-          signers: signers
-        )
-      }.to raise_error(
-        Stellar::InvalidSep10ChallengeError,
-        /The transaction is not signed by the server/
-      )
-    end
-
-    it "raises no client signers found" do
-      server_kp = Stellar::KeyPair.random
-      client_kp_a = Stellar::KeyPair.random
-      client_kp_b = Stellar::KeyPair.random
-      client_kp_c = Stellar::KeyPair.random
-      timeout = 600
-      anchor_name = "SDF"
-
-      challenge = sep10.build_challenge_tx(
-        server: server_kp,
-        client: client_kp_a,
-        anchor_name: anchor_name,
-        timeout: timeout,
-      )
-
-      challenge_envelope = Stellar::TransactionEnvelope.from_xdr(challenge, "base64")
-      challenge_envelope.signatures += [
-        client_kp_a, client_kp_b, client_kp_c
-      ].map { |kp| challenge_envelope.tx.sign_decorated(kp) }
-
-      # Different signers than those on the transaction envelope
-      signers = Set[
-        Stellar::KeyPair.random.address,
-        Stellar::KeyPair.random.address,
-        Stellar::KeyPair.random.address
-      ]
-
-      expect {
-        sep10.verify_challenge_tx_signers(
-          challenge_xdr: challenge_envelope.to_xdr(:base64), 
-          server: server_kp, 
-          signers: signers
-        )
-      }.to raise_error(
-        Stellar::InvalidSep10ChallengeError,
-        /Transaction not signed by any client signer./
-      )
-    end
-
-    it "raises unrecognized signatures" do
-      server_kp = Stellar::KeyPair.random
-      client_kp_a = Stellar::KeyPair.random
-      client_kp_b = Stellar::KeyPair.random
-      client_kp_c = Stellar::KeyPair.random
-      timeout = 600
-      anchor_name = "SDF"
-
-      challenge = sep10.build_challenge_tx(
-        server: server_kp,
-        client: client_kp_a,
-        anchor_name: anchor_name,
-        timeout: timeout,
-      )
-
-      challenge_envelope = Stellar::TransactionEnvelope.from_xdr(challenge, "base64")
-      # Add random signature
-      challenge_envelope.signatures += [
-        client_kp_a, client_kp_b, client_kp_c, Stellar::KeyPair.random
-      ].map { |kp| challenge_envelope.tx.sign_decorated(kp) }
-
-      signers = Set[
-        client_kp_a.address,
-        client_kp_b.address,
-        client_kp_c.address
-      ]
-
-      expect {
-        sep10.verify_challenge_tx_signers(
-          challenge_xdr: challenge_envelope.to_xdr(:base64), 
-          server: server_kp, 
-          signers: signers
-        )
-      }.to raise_error(
-        Stellar::InvalidSep10ChallengeError,
-        /Transaction has unrecognized signatures./
-      )
-    end
-
-    it "raises an error when transaction only has server signature" do
-      server_kp = Stellar::KeyPair.random
-      client_kp = Stellar::KeyPair.random
-
-      challenge = sep10.build_challenge_tx(
-        server: server_kp,
-        client: client_kp,
-        anchor_name: "SDF",
-        timeout: 600,
-      ) 
-
-      expect { 
-        sep10.verify_challenge_tx_signers(
-          challenge_xdr: challenge, 
-          server: server_kp,
-          signers: Set[server_kp.address]
-        )
-      }.to raise_error(
-        Stellar::InvalidSep10ChallengeError,
-        /At least one signer with a G... address must be provied/
-      )
-    end
-
-    it "succeeds even when the server is included in the passed signers" do
-      server_kp = Stellar::KeyPair.random
-      client_kp = Stellar::KeyPair.random
-
-      challenge_envelope = Stellar::TransactionEnvelope.from_xdr(
-        sep10.build_challenge_tx(
-          server: server_kp,
-          client: client_kp,
-          anchor_name: "SDF",
-          timeout: 600,
-        ), 
-        "base64"
-      )
-      challenge_envelope.signatures += [challenge_envelope.tx.sign_decorated(client_kp)]
-      challenge = challenge_envelope.to_xdr(:base64)
-
-      expect(
-        sep10.verify_challenge_tx_signers(
-          challenge_xdr: challenge,
-          server: server_kp,
-          signers: Set[server_kp.address, client_kp.address]
-        )
-      ).to eql(
-        Set[client_kp.address]
-      )
-    end
-
-    it "succeeds with extra signers passed" do
-      server_kp = Stellar::KeyPair.random
-      client_kp_a = Stellar::KeyPair.random
-      client_kp_b = Stellar::KeyPair.random
-      client_kp_c = Stellar::KeyPair.random
-
-      challenge_envelope = Stellar::TransactionEnvelope.from_xdr(
-        sep10.build_challenge_tx(
-          server: server_kp,
-          client: client_kp_a,
-          anchor_name: "SDF",
-          timeout: 600,
-        ), 
-        "base64"
-      )
-      challenge_envelope.signatures += [
-        challenge_envelope.tx.sign_decorated(client_kp_a),
-        challenge_envelope.tx.sign_decorated(client_kp_b)
-      ]
-      challenge = challenge_envelope.to_xdr(:base64)
-
-      expect(
-        sep10.verify_challenge_tx_signers(
-          challenge_xdr: challenge,
-          server: server_kp,
-          signers: Set[
-            client_kp_a.address,
-            client_kp_b.address,
-            client_kp_c.address
-          ]
-        )
-      ).to eql(
-        Set[client_kp_a.address, client_kp_b.address]
-      )
-    end
-
-    it "does not pass back duplicate signers" do
-      server_kp = Stellar::KeyPair.random
-      client_kp = Stellar::KeyPair.random
-
-      challenge_envelope = Stellar::TransactionEnvelope.from_xdr(
-        sep10.build_challenge_tx(
-          server: server_kp,
-          client: client_kp,
-          anchor_name: "SDF",
-          timeout: 600,
-        ), 
-        "base64"
-      )
-      challenge_envelope.signatures += [challenge_envelope.tx.sign_decorated(client_kp)]
-      challenge = challenge_envelope.to_xdr(:base64)
-
-      expect(
-        sep10.verify_challenge_tx_signers(
-          challenge_xdr: challenge,
-          server: server_kp,
-          signers: Set[client_kp.address, client_kp.address]
-        )
-      ).to eql(
-        Set[client_kp.address]
-      )
-    end
-
-    it "raises an error for duplicate signatures" do
-      server_kp = Stellar::KeyPair.random
-      client_kp = Stellar::KeyPair.random
-
-      challenge_envelope = Stellar::TransactionEnvelope.from_xdr(
-        sep10.build_challenge_tx(
-          server: server_kp,
-          client: client_kp,
-          anchor_name: "SDF",
-          timeout: 600,
-        ), 
-        "base64"
-      )
-      challenge_envelope.signatures += [
-        challenge_envelope.tx.sign_decorated(client_kp),
-        challenge_envelope.tx.sign_decorated(client_kp)
-      ]
-      challenge = challenge_envelope.to_xdr(:base64)
-
-      expect {
-        sep10.verify_challenge_tx_signers(
-          challenge_xdr: challenge,
-          server: server_kp,
-          signers: Set[server_kp.address, client_kp.address]
-        )
-      }.to raise_error(
-        Stellar::InvalidSep10ChallengeError,
-        /Transaction has unrecognized signatures./
-      )
-    end
-
-    it "ignores non-G address" do
-      preauth_tx_hash = "TAQCSRX2RIDJNHFIFHWD63X7D7D6TRT5Y2S6E3TEMXTG5W3OECHZ2OG4"
-      x_hash = "XDRPF6NZRR7EEVO7ESIWUDXHAOMM2QSKIQQBJK6I2FB7YKDZES5UCLWD"
-      server_kp = Stellar::KeyPair.random
-      client_kp = Stellar::KeyPair.random
-
-      challenge_envelope = Stellar::TransactionEnvelope.from_xdr(
-        sep10.build_challenge_tx(
-          server: server_kp,
-          client: client_kp,
-          anchor_name: "SDF",
-          timeout: 600,
-        ), 
-        "base64"
-      )
-      challenge_envelope.signatures += [challenge_envelope.tx.sign_decorated(client_kp)]
-      challenge = challenge_envelope.to_xdr(:base64)
-
-      expect(
-        sep10.verify_challenge_tx_signers(
-          challenge_xdr: challenge,
-          server: server_kp,
-          signers: Set[client_kp.address, preauth_tx_hash, x_hash]
-        )
-      ).to eql(
-        Set[client_kp.address]
-      )
-    end
-
-    it "raises an error for no signatures" do
-      server_kp = Stellar::KeyPair.random
-      client_kp = Stellar::KeyPair.random
-
-      challenge_envelope = Stellar::TransactionEnvelope.from_xdr(
-        sep10.build_challenge_tx(
-          server: server_kp,
-          client: client_kp,
-          anchor_name: "SDF",
-          timeout: 600,
-        ), 
-        "base64"
-      )
-      challenge_envelope.signatures.clear
-      challenge = challenge_envelope.to_xdr(:base64)
-
-      expect {
-        sep10.verify_challenge_tx_signers(
-          challenge_xdr: challenge,
-          server: server_kp,
-          signers: Set[client_kp.address]
-        )
-      }.to raise_error(
-        Stellar::InvalidSep10ChallengeError,
-        /The transaction is not signed by the server/
-      )
-    end
-  end
-
-  describe "#verify_tx_signatures" do
-    it "returns expected signatures" do
-      server_kp = Stellar::KeyPair.random
-      client_kp_a = Stellar::KeyPair.random
-      client_kp_b = Stellar::KeyPair.random
-      client_kp_c = Stellar::KeyPair.random
-      timeout = 600
-      anchor_name = "SDF"
-
-      challenge = sep10.build_challenge_tx(
-        server: server_kp,
-        client: client_kp_a,
-        anchor_name: anchor_name,
-        timeout: timeout
-      )
-
-      challenge_envelope = Stellar::TransactionEnvelope.from_xdr(challenge, "base64")
-
-      challenge_envelope.signatures += [
-        client_kp_a, client_kp_b, client_kp_c
-      ].map { |kp| challenge_envelope.tx.sign_decorated(kp) }
-
-      signers = Set[
-        client_kp_a.address,
-        client_kp_b.address,
-        client_kp_c.address,
-        Stellar::KeyPair.random.address
-      ]
-      signers_found = sep10.verify_tx_signatures(
-        tx_envelope: challenge_envelope, signers: signers
-      )
-      expect(signers_found).to eql(Set[
-        client_kp_a.address,
-        client_kp_b.address,
-        client_kp_c.address
-      ])
-    end
-
-    it "raises no signature error" do
-      server_kp = Stellar::KeyPair.random
-      client_kp = Stellar::KeyPair.random
-      value = SecureRandom.base64(48)
-            
-      tx = Stellar::Transaction.manage_data({
-        account: server_kp,
-        sequence:  0,
-        name: "SDF auth", 
-        value: value,
-        source_account: client_kp
-      })
-
-      now = Time.now.to_i
-      tx.time_bounds = Stellar::TimeBounds.new(
-        min_time: now, 
-        max_time: now + timeout
-      )
-
-      signers = Set[client_kp.address]
-      expect{
-        sep10.verify_tx_signatures(
-          tx_envelope: tx.to_envelope(), signers: signers
-        )
-      }.to raise_error(
-        Stellar::InvalidSep10ChallengeError,
-        /Transaction has no signatures./
-      )
-    end
-
-    it "removes duplicate signers" do
-      server_kp = Stellar::KeyPair.random
-      client_kp_a = Stellar::KeyPair.random
-      timeout = 600
-      anchor_name = "SDF"
-
-      challenge = sep10.build_challenge_tx(
-        server: server_kp,
-        client: client_kp_a,
-        anchor_name: anchor_name,
-        timeout: timeout
-      )
-
-      challenge_envelope = Stellar::TransactionEnvelope.from_xdr(challenge, "base64")
-
-      # Sign the transaction with the same keypair twice
-      challenge_envelope.signatures += [
-        client_kp_a, client_kp_a
-      ].map { |kp| challenge_envelope.tx.sign_decorated(kp) }
-
-      signers = Set[
-        client_kp_a.address,
-        client_kp_a.address,
-        Stellar::KeyPair.random.address
-      ]
-      signers_found = sep10.verify_tx_signatures(
-        tx_envelope: challenge_envelope, signers: signers
-      )
-      expect(signers_found).to eql(Set[client_kp_a.address])
-    end
-  end
-
-  describe "#verify_tx_signed_by" do
-    let(:keypair) { Stellar::KeyPair.random }
-    let(:envelope) do
-      Stellar::Transaction.bump_sequence(account: keypair, bump_to: 1000, sequence: 0).to_envelope(keypair)
-    end
-    
-    it "returns true if transaction envelope is signed by keypair" do
-      result = sep10.verify_tx_signed_by(tx_envelope: envelope, keypair: keypair)
-      expect(result).to eql(true)
-    end
-    
-    it "returns false if transaction envelope is not signed by keypair" do
-      result = sep10.verify_tx_signed_by(
-        tx_envelope: envelope, 
-        keypair: Stellar::KeyPair.random
-      )
-      expect(result).to eql(false)
-    end
-  end
-end