bsv-wallet-postgres 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9afef26a167d09125962a45afc6d24d0233de215847c34233346fc1dbba11f34
+  data.tar.gz: 453a4d2d63f1735beae93aeb4e32ef37c9a15ab09141865a7789b736824b4507
+SHA512:
+  metadata.gz: 600ceec193391521686eae2a52201e905cd9d9ac495a07060747eb7e3b97b5d8bf1172774d1b67f16d15328d94e51e20eab2c1afd13c7e7042221f053fd99537
+  data.tar.gz: 60925f55c22d87445398817f1368096df57b639b2e439b60e09a40ecc716c6d70abaeee49294b8bef9f30d92bf41d88906a9e45000be8ca03d6c07214733bb64

data/CHANGELOG-wallet-postgres.md

@@ -0,0 +1,55 @@
+# Changelog — bsv-wallet-postgres
+
+All notable changes to the `bsv-wallet-postgres` gem are documented here.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/)
+and this gem adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## 0.1.0 — 2026-04-09
+
+Initial release of `bsv-wallet-postgres`, a PostgreSQL-backed
+`BSV::Wallet::StorageAdapter` implementation. Unblocks production
+deployments of `bsv-wallet` where state has to survive container
+restarts, and makes multi-instance wallet services possible for the
+first time.
+
+### Added
+
+- **`BSV::Wallet::PostgresStore`** — full
+  `StorageAdapter` implementation over Sequel + Postgres. Passes the
+  same shared conformance suite that MemoryStore and FileStore pass
+  (53 examples), plus 10 postgres-specific specs covering upsert
+  semantics, GIN tag queries, JSONB attribute containment, concurrent
+  inserts, and migration idempotency.
+
+- **Shipped Sequel migration** at
+  `lib/bsv/wallet_postgres/migrations/001_create_wallet_tables.rb`.
+  Five tables (wallet_outputs, wallet_actions, wallet_certificates,
+  wallet_proofs, wallet_transactions) with JSONB data columns,
+  dedicated indexed columns for filter paths, and GIN indexes on the
+  `tags` / `labels` arrays.
+
+- **`PostgresStore.migrate!(db)`** convenience
+  wrapper over `Sequel::Migrator.run` so consumers can apply the
+  shipped schema with a single call. Operators who prefer their own
+  migration framework can copy the migration file instead.
+
+- **Docs** at `docs/guides/wallet-postgres.md` with
+  a 30-second quickstart, schema overview, and production
+  considerations (pool sizing, multi-instance, backups,
+  thread-safety).
+
+### Infrastructure
+
+- **CI postgres service**. The GitHub Actions test job now runs a
+  Postgres 16 container and exposes `DATABASE_URL` to rspec, so the
+  `:postgres`-tagged specs run against a live database on every
+  Ruby matrix row (2.7 → 3.4). Local developers without Postgres
+  still get a green suite — those specs skip gracefully.
+
+### Dependencies
+
+- `bsv-wallet-postgres` runtime: `bsv-wallet >= 0.3.4, < 1.0`,
+  `sequel ~> 5`, `pg ~> 1`. The wallet floor matches the pinning style
+  `bsv-wallet` uses for its `bsv-sdk` dependency so security releases
+  propagate.

data/LICENSE

@@ -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/lib/bsv/wallet_postgres/migrations/001_create_wallet_tables.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+# Initial wallet schema for BSV::Wallet::PostgresStore.
+#
+# Five tables, all indexed for the query patterns the StorageAdapter
+# interface exposes. JSONB blobs hold the full hash the SDK stored so
+# adding fields to bsv-wallet's output/action/certificate records does
+# not require a schema change — only the fields we actively filter on
+# get dedicated indexed columns.
+Sequel.migration do
+  change do
+    create_table(:wallet_outputs) do
+      primary_key :id
+      String :outpoint, null: false, unique: true
+      String :basket
+      column :tags, 'text[]'
+      TrueClass :spendable, null: false, default: true
+      jsonb :data, null: false
+      DateTime :created_at, null: false, default: Sequel::CURRENT_TIMESTAMP
+      index %i[basket spendable]
+      index :tags, type: :gin
+    end
+
+    create_table(:wallet_actions) do
+      primary_key :id
+      String :txid, null: false
+      column :labels, 'text[]'
+      jsonb :data, null: false
+      DateTime :created_at, null: false, default: Sequel::CURRENT_TIMESTAMP
+      index :labels, type: :gin
+    end
+
+    create_table(:wallet_certificates) do
+      primary_key :id
+      String :type, null: false
+      String :serial_number, null: false
+      String :certifier, null: false
+      String :subject
+      jsonb :data, null: false
+      DateTime :created_at, null: false, default: Sequel::CURRENT_TIMESTAMP
+      unique %i[type serial_number certifier], name: :wallet_certificates_natural_key
+      index :certifier
+      index :subject
+    end
+
+    create_table(:wallet_proofs) do
+      String :txid, primary_key: true
+      String :bump_hex, text: true, null: false
+      DateTime :created_at, null: false, default: Sequel::CURRENT_TIMESTAMP
+    end
+
+    create_table(:wallet_transactions) do
+      String :txid, primary_key: true
+      String :tx_hex, text: true, null: false
+      DateTime :created_at, null: false, default: Sequel::CURRENT_TIMESTAMP
+    end
+  end
+end

data/lib/bsv/wallet_postgres/postgres_store.rb

@@ -0,0 +1,291 @@
+# frozen_string_literal: true
+
+require 'sequel'
+require 'sequel/extensions/migration'
+require 'json'
+
+module BSV
+  module Wallet
+    # PostgreSQL-backed storage adapter for +BSV::Wallet+.
+    #
+    # Implements the full {StorageAdapter} interface against a Sequel
+    # +Database+ object. Survives process restarts, scales to multiple
+    # instances, and is thread-safe via Sequel's connection pool.
+    #
+    # @example Quickstart
+    #   require 'bsv-wallet-postgres'
+    #
+    #   db = Sequel.connect(ENV['DATABASE_URL'])
+    #   BSV::Wallet::PostgresStore.migrate!(db)
+    #
+    #   store  = BSV::Wallet::PostgresStore.new(db)
+    #   wallet = BSV::Wallet::WalletClient.new(key, storage: store)
+    #
+    # @example Bringing your own migration runner
+    #   # Copy lib/bsv/wallet_postgres/migrations/001_create_wallet_tables.rb
+    #   # into your own db/migrate directory, then run your framework's
+    #   # migrator as normal. `migrate!` is a convenience — not a requirement.
+    #
+    # === Design notes
+    #
+    # * JSONB is the source of truth. Every row stores the full record
+    #   hash in a +data+ jsonb column; dedicated indexed columns
+    #   (+basket+, +tags+, +labels+, +certifier+, ...) exist only to make
+    #   queries fast. Reads return the jsonb blob so adding fields to
+    #   bsv-wallet's record hashes does not require a schema change.
+    #
+    # * Outputs upsert on +outpoint+ (unique); certificates upsert on the
+    #   composite unique +(type, serial_number, certifier)+. Proofs and
+    #   transactions upsert on their +txid+ primary key. Actions are
+    #   append-only — the interface has no natural key for actions.
+    #
+    # * Pagination is ordered by insertion (+id ASC+) to match MemoryStore.
+    #
+    # * This class is thread-safe because Sequel is — the adapter itself
+    #   holds no mutable state beyond the injected database handle.
+    class PostgresStore
+      include StorageAdapter
+
+      MIGRATIONS_DIR = File.expand_path('migrations', __dir__)
+
+      # Run the shipped wallet schema migrations against +db+.
+      #
+      # Uses Sequel's migrator so every schema change ships as a numbered
+      # migration file and the database tracks which ones have been
+      # applied. Safe to call repeatedly.
+      #
+      # Consumers who prefer their own migration framework can copy the
+      # migration file(s) out of +lib/bsv/wallet_postgres/migrations/+
+      # instead of calling this helper.
+      #
+      # @param db [Sequel::Database]
+      # @return [void]
+      def self.migrate!(db)
+        Sequel::Migrator.run(db, MIGRATIONS_DIR)
+      end
+
+      # Register the global Sequel query-builder helpers used by this class
+      # (+Sequel.pg_array_op+ / +Sequel.pg_jsonb_op+). Unlike the per-database
+      # +pg_array+ / +pg_json+ extensions loaded in +initialize+, +pg_array_ops+
+      # and +pg_json_ops+ are global — they mutate Sequel's top-level namespace
+      # the first time this class body is evaluated (typically on autoload).
+      # This is an intentional side effect: any consumer that has
+      # +require 'bsv-wallet-postgres'+ in their Gemfile has opted in.
+      Sequel.extension :pg_array_ops
+      Sequel.extension :pg_json_ops
+
+      # @param db [Sequel::Database] a Sequel database handle. The caller
+      #   owns connection lifecycle, pool sizing, and migrations.
+      def initialize(db)
+        @db = db
+        @db.extension :pg_array
+        @db.extension :pg_json
+      end
+
+      # @return [Sequel::Database] the underlying database handle
+      attr_reader :db
+
+      # --- Actions ---
+
+      def store_action(action_data)
+        row = action_row(action_data)
+        @db[:wallet_actions].insert(row)
+        action_data
+      end
+
+      def find_actions(query)
+        ds = filter_actions(@db[:wallet_actions], query)
+        paginate(ds, query).map { |r| symbolise_keys(r[:data]) }
+      end
+
+      def count_actions(query)
+        filter_actions(@db[:wallet_actions], query).count
+      end
+
+      # --- Outputs ---
+
+      def store_output(output_data)
+        row = output_row(output_data)
+        @db[:wallet_outputs]
+          .insert_conflict(
+            target: :outpoint,
+            update: { basket: row[:basket], tags: row[:tags], spendable: row[:spendable], data: row[:data] }
+          )
+          .insert(row)
+        output_data
+      end
+
+      def find_outputs(query)
+        ds = filter_outputs(@db[:wallet_outputs], query)
+        paginate(ds, query).map { |r| symbolise_keys(r[:data]) }
+      end
+
+      def count_outputs(query)
+        filter_outputs(@db[:wallet_outputs], query).count
+      end
+
+      def delete_output(outpoint)
+        @db[:wallet_outputs].where(outpoint: outpoint).delete.positive?
+      end
+
+      # --- Certificates ---
+
+      def store_certificate(cert_data)
+        row = certificate_row(cert_data)
+        @db[:wallet_certificates]
+          .insert_conflict(
+            target: %i[type serial_number certifier],
+            update: { subject: row[:subject], data: row[:data] }
+          )
+          .insert(row)
+        cert_data
+      end
+
+      def find_certificates(query)
+        ds = filter_certificates(@db[:wallet_certificates], query)
+        paginate(ds, query).map { |r| symbolise_keys(r[:data]) }
+      end
+
+      def count_certificates(query)
+        filter_certificates(@db[:wallet_certificates], query).count
+      end
+
+      def delete_certificate(type:, serial_number:, certifier:)
+        @db[:wallet_certificates]
+          .where(type: type, serial_number: serial_number, certifier: certifier)
+          .delete
+          .positive?
+      end
+
+      # --- Proofs ---
+
+      def store_proof(txid, bump_hex)
+        @db[:wallet_proofs]
+          .insert_conflict(target: :txid, update: { bump_hex: bump_hex })
+          .insert(txid: txid, bump_hex: bump_hex)
+      end
+
+      def find_proof(txid)
+        @db[:wallet_proofs].where(txid: txid).get(:bump_hex)
+      end
+
+      # --- Transactions ---
+
+      def store_transaction(txid, tx_hex)
+        @db[:wallet_transactions]
+          .insert_conflict(target: :txid, update: { tx_hex: tx_hex })
+          .insert(txid: txid, tx_hex: tx_hex)
+      end
+
+      def find_transaction(txid)
+        @db[:wallet_transactions].where(txid: txid).get(:tx_hex)
+      end
+
+      private
+
+      # --- Row builders ---
+
+      def action_row(data)
+        {
+          txid: data[:txid],
+          labels: Sequel.pg_array(Array(data[:labels]), :text),
+          data: Sequel.pg_jsonb(data.to_h)
+        }
+      end
+
+      def output_row(data)
+        spendable = data[:spendable] != false # nil treated as spendable, like MemoryStore
+        {
+          outpoint: data[:outpoint],
+          basket: data[:basket],
+          tags: Sequel.pg_array(Array(data[:tags]), :text),
+          spendable: spendable,
+          data: Sequel.pg_jsonb(data.to_h)
+        }
+      end
+
+      def certificate_row(data)
+        {
+          type: data[:type],
+          serial_number: data[:serial_number],
+          certifier: data[:certifier],
+          subject: data[:subject],
+          data: Sequel.pg_jsonb(data.to_h)
+        }
+      end
+
+      # --- Filters ---
+
+      def filter_actions(ds, query)
+        apply_array_filter(ds, :labels, query[:labels], query[:label_query_mode])
+      end
+
+      def filter_outputs(ds, query)
+        ds = ds.where(outpoint: query[:outpoint]) if query[:outpoint]
+        ds = ds.where(basket: query[:basket]) if query[:basket]
+        ds = apply_array_filter(ds, :tags, query[:tags], query[:tag_query_mode])
+        ds = ds.where(spendable: true) unless query[:include_spent]
+        ds
+      end
+
+      def filter_certificates(ds, query)
+        ds = ds.where(certifier: query[:certifiers]) if query[:certifiers]
+        ds = ds.where(type: query[:types]) if query[:types]
+        ds = ds.where(subject: query[:subject]) if query[:subject]
+        ds = apply_attributes_filter(ds, query[:attributes]) if query[:attributes]
+        ds
+      end
+
+      def apply_array_filter(ds, column, values, mode)
+        return ds unless values
+
+        array = Sequel.pg_array(Array(values), :text)
+        op    = Sequel.pg_array_op(column)
+        if mode == 'all'
+          ds.where(op.contains(array))
+        else
+          ds.where(op.overlaps(array))
+        end
+      end
+
+      def apply_attributes_filter(ds, attrs)
+        # Match certificates whose stored fields hash contains every
+        # key/value pair in +attrs+. Symbol keys stringify when the
+        # record is serialised to JSONB, so symbol/string keys both work.
+        fragment = attrs.each_with_object({}) { |(k, v), h| h[k.to_s] = v }
+        ds.where(Sequel.lit('data->\'fields\' @> ?::jsonb', fragment.to_json))
+      end
+
+      # --- Pagination ---
+
+      def paginate(ds, query)
+        ds.order(:id)
+          .offset(query[:offset] || 0)
+          .limit(query[:limit] || 10)
+          .all
+      end
+
+      # --- JSONB read helpers ---
+
+      # Recursively convert string-keyed hashes to symbol-keyed hashes so
+      # reads round-trip with MemoryStore's contract. pg_json returns
+      # string keys by default wrapped in +Sequel::Postgres::JSONBHash+
+      # / +JSONBArray+, which are +DelegateClass+-based — not Hash/Array
+      # subclasses — so the case statement uses +to_hash+ / +to_ary+
+      # coercion to handle them.
+      def symbolise_keys(obj)
+        case obj
+        when Hash
+          obj.each_with_object({}) { |(k, v), h| h[k.to_sym] = symbolise_keys(v) }
+        when Array
+          obj.map { |e| symbolise_keys(e) }
+        else
+          return symbolise_keys(obj.to_hash) if obj.respond_to?(:to_hash)
+          return symbolise_keys(obj.to_ary)  if obj.respond_to?(:to_ary)
+
+          obj
+        end
+      end
+    end
+  end
+end

data/lib/bsv/wallet_postgres/version.rb

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

data/lib/bsv/wallet_postgres.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module BSV
+  # Top-level module for the bsv-wallet-postgres gem.
+  module WalletPostgres
+    autoload :VERSION, 'bsv/wallet_postgres/version'
+  end
+
+  module Wallet
+    autoload :PostgresStore, 'bsv/wallet_postgres/postgres_store'
+  end
+end

data/lib/bsv-wallet-postgres.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require 'sequel'
+require 'bsv-wallet'
+require_relative 'bsv/wallet_postgres'

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: bsv-wallet-postgres
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Simon Bettison
+bindir: bin
+cert_chain: []
+date: 2026-04-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bsv-wallet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.4
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.4
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5'
+description: Persistent Sequel/Postgres-backed BSV::Wallet::StorageAdapter implementation
+  for production BSV wallet deployments.
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG-wallet-postgres.md
+- LICENSE
+- lib/bsv-wallet-postgres.rb
+- lib/bsv/wallet_postgres.rb
+- lib/bsv/wallet_postgres/migrations/001_create_wallet_tables.rb
+- lib/bsv/wallet_postgres/postgres_store.rb
+- lib/bsv/wallet_postgres/version.rb
+homepage: https://github.com/sgbett/bsv-ruby-sdk
+licenses:
+- LicenseRef-OpenBSV
+metadata:
+  homepage_uri: https://github.com/sgbett/bsv-ruby-sdk
+  source_code_uri: https://github.com/sgbett/bsv-ruby-sdk
+  changelog_uri: https://github.com/sgbett/bsv-ruby-sdk/blob/master/CHANGELOG-wallet-postgres.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.7'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: PostgreSQL storage adapter for bsv-wallet
+test_files: []