bsv-sdk 0.14.0 → 0.16.0

data/lib/bsv/mcp/tools/fetch_tx.rb

@@ -49,8 +49,17 @@ module BSV
 
         def self.call(txid:, network: nil, server_context: nil)
           net_sym = Helpers.resolve_network_sym(network, server_context)
-          woc = BSV::Network::WhatsOnChain.new(network: net_sym)
-          tx = woc.fetch_transaction(txid)
+          provider = BSV::Network::Providers::WhatsOnChain.default(network: net_sym)
+          fetch_result = provider.call(:get_tx, txid)
+
+          unless fetch_result.success?
+            code = fetch_result.metadata[:status_code]
+            msg = fetch_result.message
+            msg = "#{msg} (HTTP #{code})" if code
+            return Helpers.error_response(msg)
+          end
+
+          tx = BSV::Transaction::Transaction.from_hex(fetch_result.data)
 
           result = {
             hex: tx.to_hex,
@@ -61,8 +70,6 @@ module BSV
             [::MCP::Content::Text.new(result.to_json)],
             structured_content: result
           )
-        rescue BSV::Network::ChainProviderError => e
-          Helpers.error_response("#{e.message} (HTTP #{e.status_code})")
         rescue ArgumentError => e
           Helpers.error_response(e.message)
         end

data/lib/bsv/mcp/tools/fetch_utxos.rb

@@ -50,8 +50,22 @@ module BSV
 
         def self.call(address:, network: nil, server_context: nil)
           net_sym = Helpers.resolve_network_sym(network, server_context)
-          woc = BSV::Network::WhatsOnChain.new(network: net_sym)
-          utxos = woc.fetch_utxos(address)
+          provider = BSV::Network::Providers::WhatsOnChain.default(network: net_sym)
+          utxo_result = provider.call(:get_utxos_all, address)
+
+          unless utxo_result.success?
+            code = utxo_result.metadata[:status_code]
+            msg = utxo_result.message
+            msg = "#{msg} (HTTP #{code})" if code
+            return Helpers.error_response(msg)
+          end
+
+          utxos = utxo_result.data.map do |entry|
+            BSV::Network::UTXO.new(
+              tx_hash: entry[:tx_hash], tx_pos: entry[:tx_pos],
+              satoshis: entry[:satoshis], height: entry[:height]
+            )
+          end
 
           result = {
             address: address,
@@ -63,8 +77,6 @@ module BSV
             [::MCP::Content::Text.new(result.to_json)],
             structured_content: result
           )
-        rescue BSV::Network::ChainProviderError => e
-          Helpers.error_response("#{e.message} (HTTP #{e.status_code})")
         end
       end
     end

data/lib/bsv/network/arc.rb

@@ -2,164 +2,24 @@
 
 module BSV
   module Network
-    # ARC broadcaster for submitting transactions to the BSV network.
-    #
-    # This facade preserves the legacy public API contract while delegating all
-    # HTTP logic to +Protocols::ARC+. It translates +Result+ objects returned by
-    # the protocol into +BroadcastResponse+ instances or raised +BroadcastError+
-    # exceptions as required by consumer code.
-    #
-    # Any object responding to #broadcast(tx) can serve as a broadcaster;
-    # this class implements that contract using the ARC API.
+    # @deprecated Use {BSV::Network::Protocols::ARC} directly instead.
+    #   The facade converted clean Result objects into exceptions — every
+    #   consumer immediately caught them and converted back to data.
+    #   Use the protocol layer, which returns Result objects natively.
     class ARC
-      # Returns an ARC instance pointed at the GorillaPool public ARC endpoint.
-      #
-      # @param testnet [Boolean] when true, uses the GorillaPool testnet endpoint
-      # @param api_key [String, nil] optional bearer token for Authorization
-      # @param http_client [#request, nil] injectable HTTP client for testing
-      # @param opts [Hash] ARC-specific options forwarded to the protocol
-      #   (e.g. +deployment_id:+, +callback_url:+, +callback_token:+)
-      # @return [ARC]
-      def self.default(testnet: false, api_key: nil, http_client: nil, **opts)
-        provider = Providers::GorillaPool.default(testnet: testnet)
-        arc_protocol = provider.protocol_for(:broadcast)
-        base_url = arc_protocol.base_url
-        new(
-          base_url,
-          api_key: api_key,
-          http_client: http_client,
-          **opts
-        )
-      end
-
-      # ARC response statuses that indicate the transaction was NOT accepted.
-      REJECTED_STATUSES = %w[
-        REJECTED
-        DOUBLE_SPEND_ATTEMPTED
-        INVALID
-        MALFORMED
-        MINED_IN_STALE_BLOCK
-      ].freeze
-
-      # @param url_or_protocol [String, Protocols::ARC] ARC base URL (without
-      #   trailing slash) or a pre-configured +Protocols::ARC+ instance. When a
-      #   URL string is supplied, the remaining keyword arguments are forwarded to
-      #   the underlying protocol constructor. When a protocol instance is supplied,
-      #   all keyword arguments are ignored.
-      # @param api_key [String, nil] optional bearer token for Authorization
-      # @param deployment_id [String, nil] optional deployment identifier for
-      #   the +XDeployment-ID+ header; defaults to a per-instance random value
-      # @param callback_url [String, nil] optional +X-CallbackUrl+ for ARC
-      #   status callbacks
-      # @param callback_token [String, nil] optional +X-CallbackToken+ for
-      #   ARC status callback authentication
-      # @param http_client [#request, nil] injectable HTTP client for testing
-      def initialize(url_or_protocol, api_key: nil, deployment_id: nil, callback_url: nil,
-                     callback_token: nil, http_client: nil)
-        @protocol =
-          if url_or_protocol.is_a?(String)
-            Protocols::ARC.new(
-              base_url: url_or_protocol,
-              api_key: api_key,
-              deployment_id: deployment_id,
-              callback_url: callback_url,
-              callback_token: callback_token,
-              http_client: http_client
-            )
-          else
-            url_or_protocol
-          end
-      end
-
-      # Submit a transaction to ARC.
-      #
-      # @param tx [Transaction] the transaction to broadcast
-      # @param wait_for [String, nil] ARC wait condition
-      # @param skip_fee_validation [Boolean, nil] when truthy, sends X-SkipFeeValidation header
-      # @param skip_script_validation [Boolean, nil] when truthy, sends X-SkipScriptValidation header
-      # @return [BroadcastResponse]
-      # @raise [BroadcastError] when ARC returns a non-2xx HTTP status or a
-      #   rejected/orphan +txStatus+
-      def broadcast(tx, wait_for: nil, skip_fee_validation: nil, skip_script_validation: nil)
-        result = @protocol.call(
-          :broadcast, tx,
-          wait_for: wait_for,
-          skip_fee_validation: skip_fee_validation,
-          skip_script_validation: skip_script_validation
-        )
-        result_to_response!(result)
-      end
-
-      # Submit multiple transactions to ARC in a single batch request.
-      #
-      # Returns a mixed array of {BroadcastResponse} and {BroadcastError} objects.
-      # Per-transaction rejections are returned as {BroadcastError} values rather
-      # than raised. Only HTTP-level errors raise a {BroadcastError} for the whole batch.
-      #
-      # @param txs [Array<Transaction>] transactions to broadcast
-      # @param wait_for [String, nil] ARC wait condition
-      # @param skip_fee_validation [Boolean, nil]
-      # @param skip_script_validation [Boolean, nil]
-      # @return [Array<BroadcastResponse, BroadcastError>]
-      # @raise [BroadcastError] when ARC returns a non-2xx HTTP status
-      def broadcast_many(txs, wait_for: nil, skip_fee_validation: nil, skip_script_validation: nil)
-        result = @protocol.call(
-          :broadcast_many, txs,
-          wait_for: wait_for,
-          skip_fee_validation: skip_fee_validation,
-          skip_script_validation: skip_script_validation
-        )
+      # Raised when deprecated facade classes are instantiated.
+      class DeprecationError < StandardError; end
 
-        case result
-        when Result::Success
-          result.data.map { |item| item_to_response_or_error(item) }
-        else
-          raise broadcast_error_from_result(result)
-        end
-      end
-
-      # Query the status of a previously submitted transaction.
-      #
-      # @param txid [String] transaction ID to query
-      # @return [BroadcastResponse]
-      # @raise [BroadcastError] on failure
-      def status(txid)
-        result = @protocol.call(:get_tx_status, txid)
-        result_to_response!(result)
-      end
-
-      private
-
-      # Translate a single-tx Result into a BroadcastResponse or raise BroadcastError.
-      def result_to_response!(result)
-        case result
-        when Result::Success
-          BroadcastResponse.new(result.data)
-        else
-          raise broadcast_error_from_result(result)
-        end
-      end
+      MESSAGE = 'BSV::Network::ARC is deprecated. ' \
+                'Use BSV::Network::Protocols::ARC directly — it returns Result objects ' \
+                'instead of raising exceptions. See BSV::Network::Protocols::ARC for usage.'
 
-      # Translate a per-item batch Result into a BroadcastResponse or BroadcastError
-      # (returned, not raised).
-      def item_to_response_or_error(item)
-        case item
-        when Result::Success
-          BroadcastResponse.new(item.data)
-        else
-          broadcast_error_from_result(item)
-        end
+      def self.default(**)
+        raise DeprecationError, MESSAGE
       end
 
-      # Build a BroadcastError from a Result::Error or Result::NotFound.
-      def broadcast_error_from_result(result)
-        meta = result.metadata || {}
-        BroadcastError.new(
-          result.message,
-          status_code: meta[:status_code],
-          txid: meta[:txid],
-          arc_status: meta[:arc_status]
-        )
+      def initialize(*)
+        raise DeprecationError, MESSAGE
       end
     end
   end

data/lib/bsv/network/whats_on_chain.rb

@@ -2,118 +2,24 @@
 
 module BSV
   module Network
-    # WhatsOnChain chain data provider for reading transactions and UTXOs
-    # from the BSV network.
-    #
-    # Any object responding to #fetch_utxos(address),
-    # #fetch_transaction(txid), #current_height,
-    # #get_block_header(height), and optionally
-    # #valid_root_for_height?(root_hex, height) can serve as a chain
-    # data source;
-    # this class implements that contract by delegating to
-    # Protocols::WoCREST.
-    #
-    # The HTTP client is injectable for testability. It must respond to
-    # #request(uri, request) and return an object with #code and #body.
+    # @deprecated Use {BSV::Network::Protocols::WoCREST} directly instead.
+    #   The facade converted clean Result objects into exceptions — every
+    #   consumer immediately caught them and converted back to data.
+    #   Use the protocol layer, which returns Result objects natively.
     class WhatsOnChain
-      # Returns a WhatsOnChain instance using the provider default.
-      #
-      # @param testnet [Boolean] when true, uses the testnet endpoint
-      # @param opts [Hash] forwarded to the underlying protocol (e.g. +api_key:+, +http_client:+)
-      # @return [WhatsOnChain]
-      def self.default(testnet: false, **opts)
-        provider = Providers::WhatsOnChain.default(testnet: testnet, **opts)
-        new(protocol: provider.protocol_for(:get_tx))
-      end
-
-      # @param network [Symbol] :main, :mainnet, :test, :testnet, :stn (legacy compat)
-      # @param http_client [#request, nil] injectable HTTP client
-      # @param protocol [BSV::Network::Protocols::WoCREST, nil] pre-configured protocol
-      def initialize(network: :mainnet, http_client: nil, protocol: nil)
-        if protocol
-          @protocol = protocol
-        else
-          provider = Providers::WhatsOnChain.default(network: network, http_client: http_client)
-          @protocol = provider.protocol_for(:get_tx)
-        end
-      end
-
-      # Fetch unspent transaction outputs for an address.
-      # @param address [String] BSV address
-      # @return [Array<UTXO>]
-      def fetch_utxos(address)
-        result = @protocol.call(:get_utxos_all, address)
-        raise_on_error(result)
-
-        result.data.map do |entry|
-          UTXO.new(
-            tx_hash: entry[:tx_hash],
-            tx_pos: entry[:tx_pos],
-            satoshis: entry[:satoshis],
-            height: entry[:height]
-          )
-        end
-      end
-
-      # Fetch a raw transaction by its txid and parse it.
-      # @param txid [String] transaction ID (hex)
-      # @return [BSV::Transaction::Transaction]
-      def fetch_transaction(txid)
-        result = @protocol.call(:get_tx, txid)
-        raise_on_error(result)
-
-        BSV::Transaction::Transaction.from_hex(result.data)
-      end
+      # Raised when deprecated facade classes are instantiated.
+      class DeprecationError < StandardError; end
 
-      # Return the current blockchain height.
-      # @return [Integer]
-      # @raise [BSV::Network::ChainProviderError] on network or API error
-      def current_height
-        result = @protocol.call(:current_height)
-        raise_on_error(result)
+      MESSAGE = 'BSV::Network::WhatsOnChain is deprecated. ' \
+                'Use BSV::Network::Protocols::WoCREST directly — it returns Result objects ' \
+                'instead of raising exceptions. See BSV::Network::Protocols::WoCREST for usage.'
 
-        result.data
+      def self.default(**)
+        raise DeprecationError, MESSAGE
       end
 
-      # Fetch the block header for a given height.
-      # @param height [Integer] block height
-      # @return [Hash] parsed block header JSON
-      # @raise [BSV::Network::ChainProviderError] on network or API error
-      def get_block_header(height)
-        result = @protocol.call(:get_block_header, height)
-        raise_on_error(result)
-
-        result.data
-      end
-
-      # Verify that a merkle root is valid for the given block height.
-      # Returns +false+ when the block is not found (404); raises on other errors.
-      # @param root [String] expected merkle root as hex
-      # @param height [Integer] block height
-      # @return [Boolean]
-      # @raise [BSV::Network::ChainProviderError] on network or non-404 API error
-      def valid_root_for_height?(root, height)
-        result = @protocol.call(:valid_root, root, height)
-        return false if result.not_found?
-
-        raise_on_error(result)
-
-        result.data == true
-      end
-
-      private
-
-      # Translates a non-success Protocol result into a raised ChainProviderError.
-      #
-      # @param result [Result::Error, Result::NotFound]
-      # @raise [ChainProviderError]
-      def raise_on_error(result)
-        return if result.success?
-
-        raise ChainProviderError.new(
-          result.message || 'Request failed',
-          status_code: result.metadata[:status_code]
-        )
+      def initialize(*)
+        raise DeprecationError, MESSAGE
       end
     end
   end

data/lib/bsv/overlay/admin_token_template.rb

@@ -90,7 +90,7 @@ module BSV
 
           sig_args = { hash_to_directly_sign: hash_bytes, protocol_id: @protocol_id, key_id: '1', counterparty: 'self' }
           sig_args[:originator] = @originator if @originator
-          result = @wallet.create_signature(sig_args)
+          result = @wallet.create_signature(**sig_args)
 
           sig_bytes = result[:signature].pack('C*')
           sig_with_hashtype = sig_bytes + [sighash_type].pack('C')
@@ -171,14 +171,14 @@ module BSV
         # Fetch the wallet's identity key (compressed public key hex)
         id_args = { identity_key: true }
         id_args[:originator] = @originator if @originator
-        identity_result = @wallet.get_public_key(id_args)
+        identity_result = @wallet.get_public_key(**id_args)
         identity_key_hex = identity_result[:public_key]
         identity_key_bytes = [identity_key_hex].pack('H*')
 
         # Derive the locking public key for this protocol
         lock_args = { protocol_id: protocol_id, key_id: '1', counterparty: 'self' }
         lock_args[:originator] = @originator if @originator
-        locking_result = @wallet.get_public_key(lock_args)
+        locking_result = @wallet.get_public_key(**lock_args)
         locking_pubkey_hex = locking_result[:public_key]
         locking_pubkey_bytes = [locking_pubkey_hex].pack('H*')
 
@@ -192,7 +192,7 @@ module BSV
         data_to_sign = (field_protocol + field_identity + field_domain + field_topic).unpack('C*')
         sig_args = { data: data_to_sign, protocol_id: protocol_id, key_id: '1', counterparty: 'self' }
         sig_args[:originator] = @originator if @originator
-        sig_result = @wallet.create_signature(sig_args)
+        sig_result = @wallet.create_signature(**sig_args)
         field_sig = sig_result[:signature].pack('C*')
 
         fields = [field_protocol, field_identity, field_domain, field_topic, field_sig]

data/lib/bsv/primitives/base58.rb

@@ -42,6 +42,7 @@ module BSV
         bytes.each_byte { |b| b.zero? ? leading_zeros += 1 : break }
 
         # Convert to big integer and repeatedly divide by 58
+        # C-backed hex conversion — 10x faster than pure-Ruby byte shifting; not a porting artefact.
         n = bytes.unpack1('H*').to_i(16)
         result = +''
         while n.positive?
@@ -78,7 +79,7 @@ module BSV
           n = (n * BASE) + digit
         end
 
-        # Convert integer to bytes
+        # Convert integer to bytes — C-backed hex round-trip is the fastest pure-Ruby integer→bytes path.
         hex = n.zero? ? '' : n.to_s(16)
         hex = "0#{hex}" if hex.length.odd?
         result = [hex].pack('H*')

data/lib/bsv/primitives/curve.rb

@@ -25,10 +25,11 @@ module BSV
 
       module_function
 
-      # Multiply the generator point by a scalar (variable-time, wNAF).
+      # Multiply the generator point by a scalar (constant-time).
       #
-      # Suitable for public scalars only (e.g. verify paths). For secret
-      # scalars use {multiply_generator_ct}.
+      # Uses the Montgomery ladder by default, matching OpenSSL convention.
+      # Safe for both secret and public scalars. For explicit variable-time
+      # multiplication of public scalars, use {multiply_generator_vt}.
       #
       # @param scalar_bn [OpenSSL::BN] the scalar multiplier
       # @return [OpenSSL::PKey::EC::Point] the resulting curve point
@@ -38,19 +39,31 @@ module BSV
 
       # Multiply the generator point by a secret scalar (constant-time).
       #
-      # Uses the Montgomery ladder to avoid timing side-channels on the
-      # scalar. Use for key generation and signing.
+      # Alias for {multiply_generator} — retained for backward compatibility
+      # and expressiveness.
       #
       # @param scalar_bn [OpenSSL::BN] the secret scalar multiplier
       # @return [OpenSSL::PKey::EC::Point] the resulting curve point
       def multiply_generator_ct(scalar_bn)
-        G.mul_ct(scalar_bn)
+        G.mul(scalar_bn)
       end
 
-      # Multiply an arbitrary curve point by a scalar (variable-time, wNAF).
+      # Multiply the generator point by a public scalar (variable-time, wNAF).
       #
-      # Suitable for public scalars only. For secret scalars use
-      # {multiply_point_ct}.
+      # Faster than {multiply_generator} but leaks timing information about
+      # the scalar. Use only for public scalars (e.g. signature verification).
+      #
+      # @param scalar_bn [OpenSSL::BN] the public scalar multiplier
+      # @return [OpenSSL::PKey::EC::Point] the resulting curve point
+      def multiply_generator_vt(scalar_bn)
+        G.mul_vt(scalar_bn)
+      end
+
+      # Multiply an arbitrary curve point by a scalar (constant-time).
+      #
+      # Uses the Montgomery ladder by default, matching OpenSSL convention.
+      # Safe for both secret and public scalars. For explicit variable-time
+      # multiplication of public scalars, use {multiply_point_vt}.
       #
       # @param point [OpenSSL::PKey::EC::Point] the point to multiply
       # @param scalar_bn [OpenSSL::BN] the scalar multiplier
@@ -61,14 +74,26 @@ module BSV
 
       # Multiply an arbitrary curve point by a secret scalar (constant-time).
       #
-      # Uses the Montgomery ladder to avoid timing side-channels on the
-      # scalar. Use for ECDH shared-secret derivation.
+      # Alias for {multiply_point} — retained for backward compatibility
+      # and expressiveness.
       #
       # @param point [OpenSSL::PKey::EC::Point] the base point
       # @param scalar_bn [OpenSSL::BN] the secret scalar multiplier
       # @return [OpenSSL::PKey::EC::Point] the resulting curve point
       def multiply_point_ct(point, scalar_bn)
-        point.mul_ct(scalar_bn)
+        point.mul(scalar_bn)
+      end
+
+      # Multiply an arbitrary curve point by a public scalar (variable-time, wNAF).
+      #
+      # Faster than {multiply_point} but leaks timing information about
+      # the scalar. Use only for public scalars (e.g. signature verification).
+      #
+      # @param point [OpenSSL::PKey::EC::Point] the point to multiply
+      # @param scalar_bn [OpenSSL::BN] the public scalar multiplier
+      # @return [OpenSSL::PKey::EC::Point] the resulting curve point
+      def multiply_point_vt(point, scalar_bn)
+        point.mul_vt(scalar_bn)
       end
 
       # Add two curve points together.

data/lib/bsv/primitives/ecdsa.rb

@@ -82,8 +82,8 @@ module BSV
         u1 = ((n - e) * r_inv) % n
         u2 = (s * r_inv) % n
 
-        p1 = Curve.multiply_generator(u1)
-        p2 = Curve.multiply_point(r_point, u2)
+        p1 = Curve.multiply_generator_vt(u1)
+        p2 = Curve.multiply_point_vt(r_point, u2)
         q = Curve.add_points(p1, p2)
 
         raise ArgumentError, 'recovered point is at infinity' if q.infinity?
@@ -112,8 +112,8 @@ module BSV
         u2 = (r * s_inv) % n
 
         # R' = u1*G + u2*Q
-        point1 = Curve.multiply_generator(u1)
-        point2 = Curve.multiply_point(public_key_point, u2)
+        point1 = Curve.multiply_generator_vt(u1)
+        point2 = Curve.multiply_point_vt(public_key_point, u2)
         result_point = Curve.add_points(point1, point2)
 
         return false if result_point.infinity?

data/lib/bsv/primitives/openssl_ec_shim.rb

@@ -66,6 +66,22 @@ class BSVShimECPoint
     pt
   end
 
+  # Scalar multiplication: self * scalar (constant-time, Montgomery ladder).
+  #
+  # Matches OpenSSL convention where +EC_POINT_mul+ is always constant-time.
+  # Safe for both secret and public scalars.
+  #
+  # Also supports the multi-scalar form: +mul(bns, points)+ computes
+  # <tt>bns[0]*self + bns[1]*points[0] + ...</tt>
+  # where +bns.length == points.length + 1+.
+  #
+  # @overload mul(scalar_bn)
+  #   @param scalar_bn [OpenSSL::BN, Integer] the scalar multiplier
+  # @overload mul(bns, points)
+  #   @param bns [Array<OpenSSL::BN>] scalars; must have +points.length + 1+ elements
+  #   @param points [Array<BSVShimECPoint>] additional points
+  #   @raise [NoMethodError] if +bns+ and +points+ lengths are mismatched
+  # @return [BSVShimECPoint]
   def mul(*args)
     if args.length == 1
       scalar = bn_to_int(args[0])
@@ -85,16 +101,27 @@ class BSVShimECPoint
     end
   end
 
-  # Constant-time scalar multiplication via the Montgomery ladder.
+  # Constant-time scalar multiplication (alias for {#mul}).
   #
-  # Delegates to {BSV::Primitives::Secp256k1::Point#mul_ct} to ensure
-  # secret-scalar paths execute in constant time.
+  # Retained for backward compatibility and expressiveness. Delegates
+  # to {#mul}, which is constant-time by default.
   #
-  # @param scalar_bn [OpenSSL::BN, Integer] the secret scalar
+  # @param scalar_bn [OpenSSL::BN, Integer] the scalar multiplier
   # @return [BSVShimECPoint]
   def mul_ct(scalar_bn)
+    mul(scalar_bn)
+  end
+
+  # Variable-time scalar multiplication (wNAF).
+  #
+  # Faster than {#mul} but leaks timing information about the scalar.
+  # Use only for public scalars (e.g. signature verification).
+  #
+  # @param scalar_bn [OpenSSL::BN, Integer] the public scalar multiplier
+  # @return [BSVShimECPoint]
+  def mul_vt(scalar_bn)
     scalar = bn_to_int(scalar_bn)
-    result = @secp_point.mul_ct(scalar)
+    result = @secp_point.mul_vt(scalar)
     self.class.from_secp_point(@group, result)
   end
 

data/lib/bsv/primitives/private_key.rb

@@ -165,7 +165,7 @@ module BSV
       def derive_child(public_key, invoice_number)
         shared = derive_shared_secret(public_key)
         hmac = Digest.hmac_sha256(shared.compressed, invoice_number.encode('UTF-8'))
-        hmac_bn = OpenSSL::BN.new(hmac.unpack1('H*'), 16)
+        hmac_bn = OpenSSL::BN.new(hmac, 2)
         PrivateKey.new(@bn.mod_add(hmac_bn, Curve::N))
       end
 
@@ -207,7 +207,7 @@ module BSV
           loop do
             counter_bytes = [i, attempts].pack('N*') + SecureRandom.random_bytes(32)
             h             = Digest.hmac_sha512(seed, counter_bytes)
-            candidate     = OpenSSL::BN.new(h.unpack1('H*'), 16) % PointInFiniteField::P
+            candidate     = OpenSSL::BN.new(h, 2) % PointInFiniteField::P
 
             attempts += 1
             raise ArgumentError, 'failed to generate unique x-coordinate after 5 attempts' if attempts > 5

data/lib/bsv/primitives/public_key.rb

@@ -132,7 +132,7 @@ module BSV
       def derive_child(private_key, invoice_number)
         shared = derive_shared_secret(private_key)
         hmac = Digest.hmac_sha256(shared.compressed, invoice_number.encode('UTF-8'))
-        hmac_bn = OpenSSL::BN.new(hmac.unpack1('H*'), 16)
+        hmac_bn = OpenSSL::BN.new(hmac, 2)
         hmac_point = Curve.multiply_generator_ct(hmac_bn)
         child_point = Curve.add_points(@point, hmac_point)
         PublicKey.new(child_point)

data/lib/bsv/primitives/schnorr.rb

@@ -97,15 +97,15 @@ module BSV
         e = compute_challenge(public_key_a, public_key_b, shared_secret, proof.s_prime, proof.r)
 
         # Equation 1: z·G == R + e·A
-        z_g = Curve.multiply_generator(proof.z)
-        e_a = Curve.multiply_point(public_key_a.point, e)
+        z_g = Curve.multiply_generator_vt(proof.z)
+        e_a = Curve.multiply_point_vt(public_key_a.point, e)
         r_plus_ea = Curve.add_points(proof.r.point, e_a)
 
         return false unless points_equal?(z_g, r_plus_ea)
 
         # Equation 2: z·B == S' + e·S
-        z_b = Curve.multiply_point(public_key_b.point, proof.z)
-        e_s = Curve.multiply_point(shared_secret.point, e)
+        z_b = Curve.multiply_point_vt(public_key_b.point, proof.z)
+        e_s = Curve.multiply_point_vt(shared_secret.point, e)
         sp_plus_es = Curve.add_points(proof.s_prime.point, e_s)
 
         points_equal?(z_b, sp_plus_es)