bsv-sdk 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ed81ad480647a52136c32f6bd786fd8a0a590aa6d2805fb02151b583c6b8664b
+  data.tar.gz: c6eba8e1020913d59958d68b028b66ef7035d494f3c5d34dbd98c401ab30ec35
+SHA512:
+  metadata.gz: aa4673f314ac7dddcb94d04d8e9c6db75a2c635c298e46d9412ee65babb491fd514f1bc37e94996206a41ad7d35ff1c2f57554913201be67e532700793b187da
+  data.tar.gz: ca38730828db7c78299a8eee34a682c5781f8cdae44186d7762b12030158f0f696d78204819f832e8f2bb8f913298100f9c55fb7a6f1f89cce4453c759d5e2c1

data/CHANGELOG.md

@@ -0,0 +1,58 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.1.0] - 2026-02-14
+
+Initial release of the BSV Ruby SDK.
+
+### Added
+
+#### Primitives
+
+- secp256k1 elliptic curve operations (point arithmetic, scalar multiplication)
+- ECDSA signing and verification with RFC 6979 deterministic nonces
+- Public and private key handling (WIF import/export, compressed/uncompressed formats)
+- Base58Check encoding and decoding
+- Hash functions: SHA-256, RIPEMD-160, Hash160 (SHA-256 + RIPEMD-160), SHA-512, HMAC
+- BIP-32 hierarchical deterministic key derivation (extended keys, hardened/normal child paths)
+- BIP-39 mnemonic phrase generation and seed derivation
+- ECIES encryption and decryption (BIE1 format)
+- Bitcoin Signed Message (BSM) signing and verification
+
+#### Script
+
+- Opcode constants (full set)
+- Script chunk representation and parsing
+- Script serialisation and deserialisation
+- Script templates: P2PKH, P2PK, P2MS (multisig), OP_RETURN data
+- Script type detection (including read-only recognition of P2SH and other legacy types)
+- Script builder API for programmatic construction
+- Script interpreter with stack operations, arithmetic, crypto, flow control, splice, and bitwise ops
+
+#### Transaction
+
+- Transaction construction and serialisation (raw format)
+- BIP-143 sighash computation (all hash types with FORKID)
+- Transaction signing with configurable sighash flags
+- BEEF serialisation (BRC-95/BRC-96)
+- Merkle path representation and verification
+- Fee estimation
+- Script verification during signing
+- Unlocking script templates for common script types
+
+#### Network
+
+- ARC broadcaster for transaction submission
+- WhatsOnChain chain data provider
+- Basic wallet functionality
+
+#### Testing
+
+- Cross-SDK test vectors from Go, TypeScript, and Python reference implementations
+- NIST and RFC hash function test vectors
+- Bitcoin Core script interpreter test suite
+- Protocol conformance specs for opcodes, sighash flags, and transaction templates

data/LICENCE

@@ -0,0 +1,86 @@
+Open BSV License Version 5 – granted by BSV Association, Grafenauweg 6, 6300
+Zug, Switzerland (CHE-427.008.338) ("Licensor"), to you as a user (henceforth
+"You", "User" or "Licensee").
+
+For the purposes of this license, the definitions below have the following
+meanings:
+
+"Bitcoin Protocol" means the protocol implementation, cryptographic rules,
+network protocols, and consensus mechanisms in the Bitcoin White Paper as
+described here https://protocol.bsvblockchain.org.
+
+"Bitcoin White Paper" means the paper entitled 'Bitcoin: A Peer-to-Peer
+Electronic Cash System' published by 'Satoshi Nakamoto' in October 2008.
+
+"BSV Blockchains" means:
+  (a) the Bitcoin blockchain containing block height #556767 with the hash
+      "000000000000000001d956714215d96ffc00e0afda4cd0a96c96f8d802b1662b" and
+      that contains the longest honest persistent chain of blocks which has been
+      produced in a manner which is consistent with the rules set forth in the
+      Network Access Rules; and
+  (b) the test blockchains that contain the longest honest persistent chains of
+      blocks which has been produced in a manner which is consistent with the
+      rules set forth in the Network Access Rules.
+
+"Network Access Rules" or "Rules" means the set of rules regulating the
+relationship between BSV Association and the nodes on BSV based on the Bitcoin
+Protocol rules and those set out in the Bitcoin White Paper, and available here
+https://bsvblockchain.org/network-access-rules.
+
+"Software" means the software the subject of this licence, including any/all
+intellectual property rights therein and associated documentation files.
+
+BSV Association grants permission, free of charge and on a non-exclusive and
+revocable basis, to any person obtaining a copy of the Software to deal in the
+Software without restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
+Software, and to permit persons to whom the Software is furnished to do so,
+subject to and conditioned upon the following conditions:
+
+1 - The text "© BSV Association," and this license shall be included in all
+copies or substantial portions of the Software.
+2 - The Software, and any software that is derived from the Software or parts
+thereof, must only be used on the BSV Blockchains.
+
+For the avoidance of doubt, this license is granted subject to and conditioned
+upon your compliance with these terms only. In the event of non-compliance, the
+license shall extinguish and you can be enjoined from violating BSV's
+intellectual property rights (incl. damages and similar related claims).
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES REGARDING ENTITLEMENT,
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO
+EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS THEREOF BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+
+
+Version 0.1.1 of the Bitcoin SV software, and prior versions of software upon
+which it was based, were licensed under the MIT License, which is included below.
+
+The MIT License (MIT)
+
+Copyright (c) 2009-2010 Satoshi Nakamoto
+Copyright (c) 2009-2015 Bitcoin Developers
+Copyright (c) 2009-2017 The Bitcoin Core developers
+Copyright (c) 2017 The Bitcoin ABC developers
+Copyright (c) 2018 Bitcoin Association for BSV
+Copyright (c) 2023 BSV Association
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,155 @@
+# BSV Ruby SDK
+
+[![CI](https://github.com/sgbett/bsv-ruby-sdk/actions/workflows/ci.yml/badge.svg)](https://github.com/sgbett/bsv-ruby-sdk/actions/workflows/ci.yml)
+[![codecov](https://codecov.io/gh/sgbett/bsv-ruby-sdk/branch/master/graph/badge.svg)](https://codecov.io/gh/sgbett/bsv-ruby-sdk)
+[![Gem Version](https://img.shields.io/gem/v/bsv-sdk)](https://rubygems.org/gems/bsv-sdk)
+[![Ruby](https://img.shields.io/badge/ruby-%3E%3D%202.7-red)](https://rubygems.org/gems/bsv-sdk)
+
+Welcome to the BSV Blockchain Libraries Project, the comprehensive Ruby SDK designed to provide an updated and unified layer for developing scalable applications on the BSV Blockchain. This SDK addresses the limitations of previous tools by offering a fresh, peer-to-peer approach, adhering to SPV, and ensuring privacy and scalability.
+
+## Table of Contents
+
+1. [Acknowledgements](#acknowledgements)
+2. [Objective](#objective)
+3. [Getting Started](#getting-started)
+4. [Features & Deliverables](#features--deliverables)
+5. [Documentation](#documentation)
+6. [Contribution Guidelines](#contribution-guidelines)
+7. [Support & Contacts](#support--contacts)
+8. [Licence](#licence)
+
+## Acknowledgements
+
+This Ruby SDK is a port of the official BSV Blockchain SDKs, which serve as its reference implementations. Primitives, script handling, and transaction logic are directly translated from them, adapted for Ruby idioms and conventions.
+
+The reference SDKs:
+
+- [TypeScript SDK](https://github.com/bsv-blockchain/ts-sdk)
+- [Go SDK](https://github.com/bsv-blockchain/go-sdk)
+- [Python SDK](https://github.com/bsv-blockchain/py-sdk)
+
+These are maintained under the BSV Blockchain organisation and backed by the Bitcoin Association. The debt to their contributors is substantial — their clear, robust code made this port both feasible and consistent.
+
+## Objective
+
+The BSV Blockchain Libraries Project aims to structure and maintain a middleware layer of the BSV Blockchain technology stack. By facilitating the development and maintenance of core libraries, it serves as an essential toolkit for developers looking to build on the BSV Blockchain.
+
+This Ruby SDK brings maximum compatibility with the official SDK family to the Ruby ecosystem. It was born from a practical need: building an attestation gem ([bsv-attest](https://rubygems.org/gems/bsv-attest)) required a complete, idiomatic Ruby implementation of BSV primitives, script handling, and transaction construction. Rather than wrapping FFI bindings or shelling out to other languages, the SDK implements everything in pure Ruby using only the standard library's OpenSSL bindings.
+
+<!-- TODO: Update bsv-attest link once gem documentation is published (see #48) -->
+
+## Getting Started
+
+### Requirements
+
+- Ruby >= 2.7
+- No external dependencies beyond Ruby's standard library (`openssl`)
+
+### Installation
+
+Add to your Gemfile:
+
+```ruby
+gem 'bsv-sdk'
+```
+
+Or install directly:
+
+```bash
+gem install bsv-sdk
+```
+
+### Basic Usage
+
+Create and sign a P2PKH transaction:
+
+```ruby
+require 'bsv-sdk'
+
+# Generate a new private key (or load from WIF)
+priv_key = BSV::Primitives::PrivateKey.generate
+
+# Derive the public key hash for locking scripts
+pubkey_hash = priv_key.public_key.hash160
+locking_script = BSV::Script::Script.p2pkh_lock(pubkey_hash)
+
+# Create a transaction spending a UTXO
+tx = BSV::Transaction::Transaction.new
+
+# Add an input referencing a previous transaction output
+input = BSV::Transaction::TransactionInput.new(
+  prev_tx_id: source_txid_bytes,   # 32-byte binary txid of the UTXO
+  prev_tx_out_index: 0
+)
+input.source_satoshis = 100_000
+input.source_locking_script = locking_script
+tx.add_input(input)
+
+# Add an output sending to the same address (for demonstration)
+tx.add_output(BSV::Transaction::TransactionOutput.new(
+  satoshis: 90_000,
+  locking_script: locking_script
+))
+
+# Sign the input using the P2PKH template
+template = BSV::Transaction::P2PKH.new(priv_key)
+tx.inputs[0].unlocking_script = template.sign(tx, 0)
+
+# The signed transaction is ready to broadcast
+puts tx.to_hex
+```
+
+## Features & Deliverables
+
+- **Cryptographic Primitives** — ECDSA signing with RFC 6979 deterministic nonces, Schnorr signatures, ECIES encryption/decryption, Bitcoin Signed Messages. All built on Ruby's stdlib OpenSSL.
+- **Key Management** — BIP-32 HD key derivation, BIP-39 mnemonic generation (12/24-word phrases), WIF import/export, Base58Check encoding/decoding.
+- **Script Layer** — Complete opcode set, script parsing and serialisation, type detection and predicates (`p2pkh?`, `p2pk?`, `p2sh?`, `multisig?`, `op_return?`), data extraction (pubkey hashes, script hashes, addresses), and a fluent builder API.
+- **Script Templates** — Ready-made locking and unlocking script generators for P2PKH, P2PK, P2MS (multisig), and OP_RETURN.
+- **Transaction Construction** — Input/output building, BIP-143 sighash computation (all SIGHASH types with FORKID), P2PKH signing, fee estimation.
+- **SPV Structures** — Merkle path construction and verification, BEEF (Background Evaluation Extended Format) serialisation and deserialisation.
+- **Network Integration** — ARC broadcaster for transaction submission, WhatsOnChain chain provider for UTXO queries and fee rates.
+- **Wallet** — Simple wallet that sources UTXOs, estimates fees, funds and signs transactions.
+
+## Documentation
+
+Full documentation is available at **[sgbett.github.io/bsv-ruby-sdk](https://sgbett.github.io/bsv-ruby-sdk/)**.
+
+**Guides:**
+
+- [Getting Started](https://sgbett.github.io/bsv-ruby-sdk/guides/getting-started/) — installation, first transaction
+- [Primitives](https://sgbett.github.io/bsv-ruby-sdk/guides/primitives/) — keys, signing, encryption, HD keys
+- [Script](https://sgbett.github.io/bsv-ruby-sdk/guides/script/) — construction, templates, detection
+- [Transaction](https://sgbett.github.io/bsv-ruby-sdk/guides/transaction/) — building, signing, BEEF
+
+**Additional resources:**
+
+- [API Reference](https://sgbett.github.io/bsv-ruby-sdk/reference/) — auto-generated from YARD annotations
+- [spec/ directory](https://github.com/sgbett/bsv-ruby-sdk/tree/master/spec) — runnable usage examples
+- [CHANGELOG](CHANGELOG.md) — release history
+
+**Protocol reference:**
+
+The [BSV Protocol Documentation](https://hub.bsvblockchain.org/bitcoin-protocol-documentation) on the BSV Hub is the canonical protocol reference — covering transaction format, script opcodes, sighash flags, BEEF/SPV structures, and BRC specifications. The project includes an [MCP](https://modelcontextprotocol.io/) configuration (`.mcp.json`) that connects [Claude Code](https://docs.anthropic.com/en/docs/claude-code) to the hub's search endpoint, giving AI-assisted development sessions direct access to protocol specs during implementation.
+
+## Contribution Guidelines
+
+Contributions are welcome — bug reports, feature requests, and pull requests.
+
+1. **Fork & Clone** — Fork this repository and clone it locally.
+2. **Set Up** — Run `bundle install` to install dependencies.
+3. **Branch** — Create a new branch for your changes.
+4. **Test** — Ensure all specs pass with `bundle exec rake` and lint passes with `bundle exec rubocop`.
+5. **Commit** — Follow [Conventional Commits](https://www.conventionalcommits.org/) for commit messages.
+6. **Pull Request** — Open a pull request against `master`.
+
+## Support & Contacts
+
+Maintainer: Simon Bettison
+
+For questions, bug reports, or feature requests, please [open an issue](https://github.com/sgbett/bsv-ruby-sdk/issues) on GitHub.
+
+## Licence
+
+[Open BSV Licence Version 5](LICENCE)
+
+Thank you for being a part of the BSV Blockchain Libraries Project. Let's build the future of BSV Blockchain together!

data/lib/bsv/attest/configuration.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module BSV
+  module Attest
+    class Configuration
+      attr_accessor :wallet, :broadcaster, :provider
+    end
+  end
+end

data/lib/bsv/attest/response.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module BSV
+  module Attest
+    class Response
+      attr_reader :hash, :transaction, :txid
+
+      def initialize(hash:, transaction:, txid:)
+        @hash = hash
+        @transaction = transaction
+        @txid = txid
+      end
+
+      def hash_hex
+        @hash.unpack1('H*')
+      end
+    end
+  end
+end

data/lib/bsv/attest/verification_error.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module BSV
+  module Attest
+    class VerificationError < StandardError; end
+  end
+end

data/lib/bsv/attest/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module BSV
+  module Attest
+    VERSION = '0.1.0'
+  end
+end

data/lib/bsv/attest.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module BSV
+  module Attest
+    autoload :Configuration,     'bsv/attest/configuration'
+    autoload :Response,          'bsv/attest/response'
+    autoload :VerificationError, 'bsv/attest/verification_error'
+    autoload :VERSION,           'bsv/attest/version'
+
+    class << self
+      def configuration
+        @configuration ||= Configuration.new
+      end
+
+      def configure
+        yield(configuration)
+      end
+
+      def reset_configuration!
+        @configuration = Configuration.new
+      end
+
+      def hash(data)
+        BSV::Primitives::Digest.sha256(data)
+      end
+
+      def publish(data, wallet: nil, broadcaster: nil)
+        w = wallet || configuration.wallet
+        b = broadcaster || configuration.broadcaster
+        raise ArgumentError, 'wallet is required' unless w
+        raise ArgumentError, 'broadcaster is required' unless b
+
+        digest = hash(data)
+
+        script = BSV::Script::Script.op_return(digest)
+        output = BSV::Transaction::TransactionOutput.new(satoshis: 0, locking_script: script)
+
+        tx = BSV::Transaction::Transaction.new
+        tx.add_output(output)
+
+        w.fund_and_sign(tx)
+
+        broadcast_response = b.broadcast(tx)
+
+        Response.new(hash: digest, transaction: tx, txid: broadcast_response.txid)
+      end
+
+      def verify(data, txid, provider: nil)
+        p = provider || configuration.provider
+        raise ArgumentError, 'provider is required' unless p
+
+        digest = hash(data)
+
+        tx = p.fetch_transaction(txid)
+
+        tx.outputs.each do |output|
+          chunks = output.locking_script.chunks
+          next if chunks.length < 3
+          next unless chunks[0].opcode == BSV::Script::Opcodes::OP_FALSE
+          next unless chunks[1].opcode == BSV::Script::Opcodes::OP_RETURN
+
+          chunks[2..].each do |chunk|
+            return true if chunk.data == digest
+          end
+        end
+
+        raise VerificationError, 'hash not found in transaction outputs'
+      end
+    end
+  end
+end

data/lib/bsv/network/arc.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+require 'uri'
+
+module BSV
+  module Network
+    # ARC broadcaster for submitting transactions to the BSV network.
+    #
+    # Any object responding to #broadcast(tx) can serve as a broadcaster;
+    # this class implements that contract using the ARC API.
+    #
+    # The HTTP client is injectable for testability. It must respond to
+    # #request(uri, request) and return an object with #code and #body.
+    class ARC
+      REJECTED_STATUSES = %w[REJECTED DOUBLE_SPEND_ATTEMPTED].freeze
+
+      def initialize(url, api_key: nil, http_client: nil)
+        @url = url.chomp('/')
+        @api_key = api_key
+        @http_client = http_client
+      end
+
+      # Submit a transaction to ARC.
+      # Returns BroadcastResponse on success, raises BroadcastError on failure.
+      def broadcast(tx)
+        uri = URI("#{@url}/v1/tx")
+        request = Net::HTTP::Post.new(uri)
+        request['Content-Type'] = 'application/octet-stream'
+        apply_auth_header(request)
+        request.body = tx.to_binary
+
+        response = execute(uri, request)
+        handle_broadcast_response(response)
+      end
+
+      # Query the status of a previously submitted transaction.
+      # Returns BroadcastResponse on success, raises BroadcastError on failure.
+      def status(txid)
+        uri = URI("#{@url}/v1/tx/#{txid}")
+        request = Net::HTTP::Get.new(uri)
+        apply_auth_header(request)
+
+        response = execute(uri, request)
+        handle_broadcast_response(response)
+      end
+
+      private
+
+      def apply_auth_header(request)
+        request['Authorization'] = "Bearer #{@api_key}" if @api_key
+      end
+
+      def execute(uri, request)
+        if @http_client
+          @http_client.request(uri, request)
+        else
+          Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
+            http.request(request)
+          end
+        end
+      end
+
+      def handle_broadcast_response(response)
+        body = parse_json(response.body)
+        code = response.code.to_i
+
+        unless (200..299).cover?(code)
+          raise BroadcastError.new(
+            body['detail'] || body['title'] || "HTTP #{code}",
+            status_code: code,
+            txid: body['txid']
+          )
+        end
+
+        tx_status = body['txStatus']
+        if rejected_status?(tx_status)
+          raise BroadcastError.new(
+            body['detail'] || body['title'] || tx_status,
+            status_code: code,
+            txid: body['txid']
+          )
+        end
+
+        build_response(body)
+      end
+
+      def rejected_status?(tx_status)
+        REJECTED_STATUSES.include?(tx_status)
+      end
+
+      def parse_json(raw)
+        JSON.parse(raw)
+      rescue JSON::ParserError
+        { 'detail' => raw }
+      end
+
+      def build_response(body)
+        BroadcastResponse.new(
+          txid: body['txid'],
+          tx_status: body['txStatus'],
+          message: body['title'],
+          extra_info: body['extraInfo'],
+          block_hash: body['blockHash'],
+          block_height: body['blockHeight'],
+          timestamp: body['timestamp'],
+          competing_txs: body['competingTxs']
+        )
+      end
+    end
+  end
+end

data/lib/bsv/network/broadcast_error.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module BSV
+  module Network
+    class BroadcastError < StandardError
+      attr_reader :status_code, :txid
+
+      def initialize(message, status_code: nil, txid: nil)
+        @status_code = status_code
+        @txid = txid
+        super(message)
+      end
+    end
+  end
+end

data/lib/bsv/network/broadcast_response.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module BSV
+  module Network
+    class BroadcastResponse
+      attr_reader :txid, :tx_status, :message, :extra_info,
+                  :block_hash, :block_height, :timestamp, :competing_txs
+
+      def initialize(attrs = {})
+        @txid = attrs[:txid]
+        @tx_status = attrs[:tx_status]
+        @message = attrs[:message]
+        @extra_info = attrs[:extra_info]
+        @block_hash = attrs[:block_hash]
+        @block_height = attrs[:block_height]
+        @timestamp = attrs[:timestamp]
+        @competing_txs = attrs[:competing_txs]
+      end
+
+      def success?
+        true
+      end
+
+      def mined?
+        tx_status == 'MINED'
+      end
+    end
+  end
+end

data/lib/bsv/network/chain_provider_error.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module BSV
+  module Network
+    class ChainProviderError < StandardError
+      attr_reader :status_code
+
+      def initialize(message, status_code: nil)
+        @status_code = status_code
+        super(message)
+      end
+    end
+  end
+end

data/lib/bsv/network/utxo.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module BSV
+  module Network
+    class UTXO
+      attr_reader :tx_hash, :tx_pos, :satoshis, :height
+
+      def initialize(tx_hash:, tx_pos:, satoshis:, height: nil)
+        @tx_hash = tx_hash
+        @tx_pos = tx_pos
+        @satoshis = satoshis
+        @height = height
+      end
+
+      def ==(other)
+        other.is_a?(self.class) &&
+          tx_hash == other.tx_hash &&
+          tx_pos == other.tx_pos
+      end
+
+      alias eql? ==
+
+      def hash
+        [tx_hash, tx_pos].hash
+      end
+    end
+  end
+end