webcash-rb 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 95aab40d012c2dcfedd0bc7f300e73c0400b897f59265e03c9ddcea86c91349a
+  data.tar.gz: a686a4cc24dafecfc57ef967d1ce862c9e309ab0bd39a98de4a9ec6fae00a093
+SHA512:
+  metadata.gz: eb4f02e2446599c0b513c56e020cd16c71ec9242e5bb5f42dbf2fc19634ccecdc8104031a65dcb416dce0cf6ae73294a4935a8948083ed881e24caf683561399
+  data.tar.gz: '09fc45f8561423df3abee27795912e9abcab7e667d89f15cf78eaa56e095f28ee18450b7cb1e2963fee2f72124ddebbf0836fda138bb5ed98ebe6cfa08a43f07'

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,2 @@
+inherit_gem:
+  rubocop-rails-omakase: rubocop.yml

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2024-09-06
+
+- Initial release

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,132 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, caste, color, religion, or sexual
+identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall
+  community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or advances of
+  any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email address,
+  without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official email address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+[INSERT CONTACT METHOD].
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of
+actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or permanent
+ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the
+community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.1, available at
+[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
+
+Community Impact Guidelines were inspired by
+[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
+
+For answers to common questions about this code of conduct, see the FAQ at
+[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at
+[https://www.contributor-covenant.org/translations][translations].
+
+[homepage]: https://www.contributor-covenant.org
+[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity
+[FAQ]: https://www.contributor-covenant.org/faq
+[translations]: https://www.contributor-covenant.org/translations

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 acidtib
+
+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,65 @@
+# webcash-rb
+
+Webcash is an experimental electronic cash library for decentralized payments.
+Webcash facilitates decentralized, peer-to-peer electronic cash transactions. It allows users to send webcash directly to one another and includes mechanisms for detecting double-spending and maintaining monetary supply integrity.
+
+Navigate to https://webcash.org/ for more information, including the Terms of Service.
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+```bash
+bundle add webcash-rb
+```
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+```bash
+gem install webcash-rb
+```
+
+## Usage
+```ruby
+require "webcash"
+
+wallet = Webcash::Wallet.new(
+  master_secret: "19be5ea41c71836f78b5691fe69af918a5f003719b7a7e2a30533737c04521fc",
+)
+
+# Set the legal agreements to true
+wallet.set_legal_agreements_to_true
+
+# Recover webcash using the wallet's master secret.
+wallet.recover
+
+# Check webcash in wallet. Remove any spent webcash.
+wallet.check
+
+# Insert webcash into the wallet.
+wallet.insert("e20:secret:8c2e565a1649b03052833c508b237bacd2c62995c7e8ed5dc9fe644850808192")
+
+# Pay webcash from the wallet.
+wallet.pay(4.20)
+
+# Get wallet balance
+pp wallet.get_balance
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/acidtib/webcash-rb. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/acidtib/webcash-rb/blob/master/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the Webcash project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/acidtib/webcash-rb/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/lib/webcash/helpers.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+# lib/webcash/helpers.rb
+require "bigdecimal"
+require "securerandom"
+require "base64"
+require "digest"
+
+module Webcash
+  # Provides helper methods for Webcash.
+  module Helpers
+    def self.range(start, stop, step = 1)
+      return [] if (step.positive? && start >= stop) || (step.negative? && start <= stop)
+
+      result = []
+      i = start
+      while step.positive? ? i < stop : i > stop
+        result << i
+        i += step
+      end
+
+      result
+    end
+
+    def self.chunk_array(array, chunk_size)
+      array.each_slice(chunk_size).to_a
+    end
+
+    # Check that the amount has no more than a maximum number of decimal places.
+    def self.validate_amount_decimals(amount)
+      if amount.is_a?(String)
+        amount = parse_amount_from_string(amount)
+      elsif amount.is_a?(Float)
+        amount = BigDecimal(amount.to_s)
+      else
+        amount = BigDecimal(amount)
+      end
+
+      raise RangeError, "Amount precision should be at most 8 decimals." unless amount.scale <= 8
+
+      true
+    end
+
+    def self.deserialize_webcash(webcash)
+      raise Error, "Unusable format for webcash." unless webcash.include?(":")
+
+      parts = webcash.split(":")
+      raise Error, "Don't know how to deserialize this webcash." if parts.length < 2
+
+      amount_raw = parts[0]
+      public_or_secret = parts[1]
+      value = parts[2]
+
+      raise Error, "Can't deserialize this webcash, value is missing." if value.nil?
+
+      unless %w[public secret].include?(public_or_secret)
+        raise Error, "Can't deserialize this webcash, needs to be either public/secret."
+      end
+
+      amount = parse_amount_from_string(amount_raw)
+
+      if public_or_secret == "secret"
+        Webcash::Secret.new(amount, value)
+      else
+        Webcash::Public.new(amount, value)
+      end
+    end
+
+    def self.parse_amount_from_string(amount_raw)
+      # If there is a colon in the value, then the amount is going to be on the
+      # left hand side.
+      part1 = amount_raw.split(":")[0]
+
+      # There can be at most one 'e' in the value, at the beginning.
+      count = part1.count("e")
+      if count.zero?
+        BigDecimal(part1)
+      elsif count <= 1
+        # should be at the beginning
+        raise Error, "Invalid amount format for webcash." unless part1[0] == "e"
+        # there needs to be an actual amount
+        raise Error, "Invalid amount format for webcash." unless part1 != "e"
+
+        part2 = part1.split("e")[1]
+        BigDecimal(part2)
+
+      else
+        raise Error, "Invalid amount format for webcash."
+      end
+    end
+
+    def self.convert_secret_value_to_public_value(secret_value)
+      Digest::SHA256.hexdigest(secret_value)
+    end
+
+    # Convert from a string amount to a Decimal value.
+    def self.string_amount_to_decimal(amount)
+      BigDecimal(amount)
+    end
+
+
+    # Convert a decimal amount to a string. This is used for representing
+    # different webcash when serializing webcash. When the amount is not known,
+    # the string should be "?".
+    def self.decimal_amount_to_string(amount)
+      return "?" if amount.nil?
+
+      if amount.frac.zero?
+        amount.to_i.to_s
+      else
+        # Force 8 decimals and trim trailing zeros
+        amount_str = format("%.8f", amount)
+        amount_str.sub(/\.?0+$/, "")
+      end
+    end
+
+    def self.create_webcash_with_random_secret_from_amount(amount)
+      "e#{amount.to_s('F')}:secret:#{generate_random_value(32)}"
+    end
+
+    def self.hex_to_padded_bytes(hex, padding_target_length = 32)
+      bytes = [ hex.sub(/^0x/, "") ].pack("H*").bytes
+      padded_bytes = Array.new(padding_target_length - bytes.length, 0) + bytes
+      padded_bytes
+    end
+
+    def self.convert_secret_hex_to_bytes(secret)
+      hex_to_padded_bytes(secret)
+    end
+
+    def self.hex_to_bytes(hex)
+      hex = hex.sub(/^0x/i, "")
+      hex.scan(/../).map { |x| x.hex }
+    end
+
+    def self.padded_bytes(bytes, padding_target_length = 32)
+      if bytes.length == padding_target_length
+        bytes
+      elsif bytes.length > padding_target_length
+        raise "Can only handle up to #{padding_target_length} bytes, int too big to convert"
+      else
+        padding_needed = padding_target_length - bytes.length
+        Array.new(padding_needed, 0) + bytes
+      end
+    end
+
+    def self.long_to_byte_array(num)
+      byte_array = Array.new(8, 0)
+
+      (0...byte_array.length).each do |index|
+        byte_array[index] = num & 0xff
+        num >>= 8
+      end
+
+      byte_array
+    end
+
+    def self.assert_is_array(input)
+      unless input.is_a?(Array) && input.all? { |e| e.is_a?(Integer) }
+        raise "This method only supports number arrays but input was: #{input}"
+      end
+    end
+
+    def self.sha256_from_array(array)
+      assert_is_array(array)
+
+      # Convert the array of integers to a binary string
+      binary_string = array.pack("C*")
+
+      # Create and return the SHA256 digest
+      Digest::SHA256.digest(binary_string)
+    end
+
+    def self.generate_random_value(length)
+      (1..length).map { rand(16).to_s(16) }.join
+    end
+  end
+end

data/lib/webcash/public.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+# lib/webcash/public.rb
+
+module Webcash
+  class Public
+    attr_reader :amount, :hashed_value
+
+    def initialize(amount, hashed_value)
+      Webcash::Helpers.validate_amount_decimals(amount)
+      @amount = amount
+      @hashed_value = hashed_value
+    end
+
+    def self.deserialize(webcash)
+      Webcash::Helpers.deserialize_webcash(webcash)
+    end
+
+    def is_equal(other)
+      if other.is_a?(Webcash::Secret)
+        return true if @hashed_value == other.to_public.hashed_value
+      elsif other.is_a?(Webcash::Public)
+        return true if @hashed_value == other.hashed_value
+      end
+
+      false
+    end
+
+    def to_s
+      "e#{@amount.to_s('F').sub(/\.0+$/, '')}:public:#{@hashed_value}"
+    end
+
+    def ==(other)
+      other.is_a?(Webcash::Public) && @amount == other.amount && @hashed_value == other.hashed_value
+    end
+  end
+end

data/lib/webcash/secret.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+# lib/webcash/secret.rb
+
+module Webcash
+  class Secret
+    attr_accessor :amount
+    attr_reader :amount, :secret_value
+
+    def initialize(amount, secret_value)
+      Webcash::Helpers.validate_amount_decimals(amount)
+      @amount = amount
+      @secret_value = secret_value
+    end
+
+    def self.deserialize(webcash)
+      Webcash::Helpers.deserialize_webcash(webcash)
+    end
+
+    def self.from_amount(amount)
+      Webcash::Secret.deserialize(Webcash::Helpers.create_webcash_with_random_secret_from_amount(amount))
+    end
+
+    def is_equal(other)
+      if other.is_a?(Webcash::Secret)
+        return true if @secret_value == other.secret_value
+      elsif other.is_a?(Webcash::Public)
+        return true if to_public.hashed_value == other.hashed_value
+      end
+
+      false
+    end
+
+    def to_s
+      "e#{@amount.to_s('F').sub(/\.0+$/, '')}:secret:#{@secret_value}"
+    end
+
+    def ==(other)
+      other.is_a?(Webcash::Secret) && @amount == other.amount && @secret_value == other.secret_value
+    end
+
+    def to_public
+      hashed_value = Webcash::Helpers.convert_secret_value_to_public_value(@secret_value)
+      Webcash::Public.new(@amount, hashed_value)
+    end
+  end
+end

data/lib/webcash/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Webcash
+  VERSION = "0.1.0"
+end

data/lib/webcash/wallet.rb

@@ -0,0 +1,464 @@
+# frozen_string_literal: true
+
+# lib/webcash/wallet.rb
+
+require "httparty"
+require "json"
+
+module Webcash
+  class Wallet
+    attr_accessor :version,
+                  :legalese,
+                  :webcash,
+                  :unconfirmed,
+                  :log,
+                  :master_secret,
+                  :walletdepths
+
+    DEFAULT_WALLETDEPTHS = {
+      "RECEIVE" => 0,
+      "PAY" => 0,
+      "CHANGE" => 0,
+      "MINING" => 0
+    }
+
+    DEFAULT_LEGALESE = { "terms" => nil }
+
+    CHAIN_CODES = {
+      "RECEIVE" => 0,
+      "PAY" => 1,
+      "CHANGE" => 2,
+      "MINING" => 3
+    }
+
+    API_REPLACE = "https://webcash.org/api/v1/replace"
+    API_HEALTHCHECK = "https://webcash.org/api/v1/health_check"
+
+    def initialize(
+      version: "1.0",
+      legalese: DEFAULT_LEGALESE,
+      webcash: [],
+      unconfirmed: [],
+      log: [],
+      master_secret: "",
+      walletdepths: DEFAULT_WALLETDEPTHS
+    )
+      @version = version
+      @legalese = legalese
+      @webcash = webcash
+      @unconfirmed = unconfirmed
+      @log = log
+      @master_secret = master_secret.empty? ? Webcash::Helpers.generate_random_value(32) : master_secret
+      @walletdepths = walletdepths
+    end
+
+    # Check that the legal agreements have been agreed to and acknowledged.
+    def check_legal_agreements
+      @legalese["terms"] == true
+    end
+
+    # Set the legal agreements to true
+    def set_legal_agreements_to_true
+      @legalese["terms"] = true
+    end
+
+    # Get all contents of the wallet
+    def get_contents
+      {
+        master_secret: @master_secret,
+        walletdepths: @walletdepths,
+        webcash: @webcash,
+        unconfirmed: @unconfirmed,
+        log: @log,
+        version: @version,
+        legalese: @legalese
+      }
+    end
+
+    # Calculate the balance based on the webcash in the wallet
+    def get_balance
+      @webcash
+        .map { |n| Webcash::Secret.deserialize(n).amount }
+        .reduce(BigDecimal("0")) { |prev, next_val| prev + next_val }
+    end
+
+    # Generate the next secret based on chain code and seek value
+    def generate_next_secret(chain_code, seek = false)
+      walletdepth = seek ? seek : @walletdepths[chain_code]
+
+      master_secret = @master_secret
+      master_secret_bytes = Webcash::Helpers.convert_secret_hex_to_bytes(master_secret)
+
+      chain_coded = CHAIN_CODES[chain_code]
+      raise ArgumentError, "Invalid chain code" if chain_coded.nil?
+
+      # Tag as byte array
+      tag = Webcash::Helpers.sha256_from_array([ 119, 101, 98, 99, 97, 115, 104, 119, 97, 108, 108, 101, 116, 118, 49 ])
+
+      array = []
+      tag_numbers = tag.unpack("C*")
+      array.concat(tag_numbers)
+      array.concat(tag_numbers)
+      array.concat(master_secret_bytes)
+      array.concat(Webcash::Helpers.long_to_byte_array(chain_coded).reverse)
+      array.concat(Webcash::Helpers.long_to_byte_array(walletdepth).reverse)
+
+      new_secret = Webcash::Helpers.sha256_from_array(array)
+
+      new_hex_secret = new_secret.unpack1("H*") # Convert binary data to hex string
+
+      # Update wallet depths if seek is false
+      unless seek
+        @walletdepths[chain_code] += 1
+      end
+
+      new_hex_secret
+    end
+
+    # Insert webcash into the wallet. Replace the given webcash with new webcash.
+    def insert(webcash, memo = "")
+      # Deserialize the given webcash if it's a string
+      if webcash.is_a?(String)
+        webcash = Webcash::Secret.deserialize(webcash)
+      end
+
+      # Create a new secret webcash
+      new_webcash = Webcash::Secret.new(webcash.amount, generate_next_secret("RECEIVE"))
+
+      # Check if the legal agreements have been accepted
+      unless check_legal_agreements
+        raise "User hasn't agreed to the legal terms."
+      end
+
+      # Prepare the replacement request body
+      replace_request_body = {
+        webcashes: [ webcash.to_s ],
+        new_webcashes: [ new_webcash.to_s ],
+        legalese: @legalese
+      }
+
+      # Save the new webcash into the wallet so the value isn't lost if there's a network error
+      new_webcash_str = new_webcash.to_s
+      @unconfirmed.push(new_webcash_str)
+
+      # Execute the replacement request
+      begin
+        # Make the POST request using HTTParty
+        response = HTTParty.post(API_REPLACE, body: JSON.dump(replace_request_body), headers: { "Content-Type" => "application/json" })
+
+        # Log the response
+        puts "After replace API call. Response = #{response.body}"
+
+        # Check if the response was successful
+        unless response.success?
+          raise "Server returned an error: #{response.body}"
+        end
+
+      rescue => e
+        # Handle network or other exceptions, log them, and raise
+        puts "Could not successfully call replacement API"
+        raise e
+      end
+
+      # Handle existing webcash
+      existing_webcash_str = @webcash.find { |w| w == webcash.to_s }
+      if existing_webcash_str
+        # Replace existing webcash with new webcash
+        @webcash.reject! { |item| item == existing_webcash_str }
+      end
+
+      # Remove from unconfirmed
+      @unconfirmed.reject! { |item| item == new_webcash_str }
+
+      # Add the new webcash to the wallet
+      @webcash.push(new_webcash.to_s)
+
+      # Log the operation
+      @log.push({
+        type: "insert",
+        amount: Webcash::Helpers.decimal_amount_to_string(new_webcash.amount),
+        webcash: webcash.to_s,
+        new_webcash: new_webcash_str,
+        memo: memo,
+        timestamp: Time.now.to_i.to_s
+      })
+
+      # Return the new webcash
+      new_webcash.to_s
+    end
+
+    def pay(amount, memo = "")
+      amount = BigDecimal(amount.to_s)
+
+      # Check legal agreements
+      raise "User hasn't agreed to the legal terms." unless check_legal_agreements
+
+      have_enough = false
+      input_webcash = []
+
+      # Try to satisfy the request with a single payment that matches the size
+      @webcash.each do |webcash_str|
+        webcash = Webcash::Secret.deserialize(webcash_str)
+        if webcash.amount >= amount
+          input_webcash.push(webcash)
+          have_enough = true
+          break
+        end
+      end
+
+      unless have_enough
+        running_amount = BigDecimal("0")
+        running_webcash = []
+
+        @webcash.each do |webcash_str|
+          webcash = Webcash::Secret.deserialize(webcash_str)
+          running_amount += webcash.amount
+          running_webcash.push(webcash)
+          if running_amount >= amount
+            input_webcash = running_webcash
+            have_enough = true
+            break
+          end
+        end
+      end
+
+      unless have_enough
+        raise "Wallet does not have enough funds to make the transfer."
+      end
+
+      found_amount = input_webcash.sum(&:amount)
+      change_amount = found_amount - amount
+
+      new_webcash = []
+      if change_amount > BigDecimal("0")
+        change_webcash = Webcash::Secret.new(change_amount, generate_next_secret("CHANGE"))
+        new_webcash.push(change_webcash.to_s)
+      end
+
+      transfer_webcash = Webcash::Secret.new(amount, generate_next_secret("PAY"))
+      new_webcash.push(transfer_webcash.to_s)
+
+      # Prepare the replacement request body
+      replace_request_body = {
+        webcashes: input_webcash.map(&:to_s),
+        new_webcashes: new_webcash,
+        legalese: @legalese
+      }
+
+      # Save the new webcash into the wallet
+      @unconfirmed.push(transfer_webcash.to_s)
+      @unconfirmed.push(change_webcash.to_s) if change_webcash
+
+      # Execute the replacement request
+      begin
+        response = HTTParty.post(API_REPLACE, body: JSON.dump(replace_request_body), headers: { "Content-Type" => "application/json" })
+
+        raise "Server returned an error: #{response.body}" unless response.success?
+      rescue => e
+        puts "Could not successfully call the replacement API"
+        raise e
+      end
+
+      # Remove the webcash from the wallet
+      @webcash.reject! { |item| replace_request_body[:webcashes].include?(item) }
+      @unconfirmed.reject! { |item| item == transfer_webcash.to_s || item == change_webcash.to_s }
+
+      # Record change
+      if change_webcash
+        @webcash.push(change_webcash.to_s)
+        @log.push({
+          type: "change",
+          amount: Webcash::Helpers.decimal_amount_to_string(change_amount),
+          webcash: change_webcash.to_s,
+          timestamp: Time.now.to_i.to_s
+        })
+      end
+
+      # Record payment
+      @log.push({
+        type: "payment",
+        amount: Webcash::Helpers.decimal_amount_to_string(transfer_webcash.amount),
+        webcash: transfer_webcash.to_s,
+        memo: memo,
+        timestamp: Time.now.to_i.to_s
+      })
+
+      # Return the transfer webcash
+      transfer_webcash.to_s
+    end
+
+    def process_healthcheck_results(results, webcashes_map = {})
+      results.each do |public_webcash, result|
+        hashed_value = Webcash::Public.deserialize(public_webcash).hashed_value
+        wallet_cash = Webcash::Secret.deserialize(webcashes_map[hashed_value])
+
+        if result["spent"] == false
+          # Check the amount.
+          result_amount = BigDecimal(result["amount"].to_s)
+          if result_amount != wallet_cash.amount
+            puts "Wallet was mistaken about amount stored by a certain webcash. Updating."
+            @webcash.reject! { |item| item == webcashes_map[hashed_value] }
+            @webcash.push(Webcash::Secret.new(result_amount, wallet_cash.secret_value).to_s)
+          end
+        elsif [ nil, true ].include?(result["spent"])
+          # Invalid webcash found. Remove from wallet.
+          puts "Removing some webcash."
+          @webcash.reject! { |item| item == webcashes_map[hashed_value] }
+          @unconfirmed.push(webcashes_map[hashed_value])
+        else
+          raise "Invalid webcash status: #{result["spent"]}"
+        end
+      end
+    end
+
+    # Check every webcash in the wallet and remove any invalid already-spent
+    def check
+      webcashes = {}
+      @webcash.each do |webcash|
+        sk = Webcash::Secret.deserialize(webcash)
+        hashed_value = sk.to_public.hashed_value
+
+        # Detect and remove duplicates.
+        if webcashes.key?(hashed_value)
+          puts "Duplicate webcash detected in wallet, moving it to unconfirmed"
+          @unconfirmed.push(webcash)
+
+          # Remove all copies
+          @webcash.reject! { |item| item == webcash }
+
+          # Add one copy back for a total of one
+          @webcash.push(webcash)
+
+          save if respond_to?(:save)
+        end
+
+        # Make a map from the hashed value back to the webcash which can
+        # be used for lookups when the server gives a response.
+        webcashes[hashed_value] = webcash
+      end
+
+      chunks = Webcash::Helpers.chunk_array(@webcash, 25)
+
+      chunks.each do |chunk|
+        health_check_request = chunk.map { |webcash| Webcash::Secret.deserialize(webcash).to_public.to_s }
+
+        begin
+          response = HTTParty.post(
+            API_HEALTHCHECK,
+            body: JSON.dump(health_check_request),
+            headers: { "Content-Type" => "application/json" }
+          )
+
+          response_content = response.body
+          if response.code != 200
+            raise "Server returned an error: #{response_content}"
+          end
+
+          response_data = JSON.parse(response_content)
+          results = response_data["results"]
+
+          process_healthcheck_results(results, webcashes)
+        rescue => e
+          puts "Could not successfully call the healthcheck API"
+          raise e
+        end
+      end
+    end
+
+    def recover(gaplimit: 20, sweep_payments: false)
+      # Start by healthchecking the contents of the wallet.
+      check
+
+      @walletdepths.each do |chain_code, reported_walletdepth|
+        current_walletdepth = 0
+        last_used_walletdepth = 0
+        has_had_webcash = true
+        idx = 0
+
+        while has_had_webcash
+          puts "Checking gaplimit #{gaplimit} secrets for chainCode #{chain_code}, round #{idx}"
+
+          # Assume this is the last iteration
+          has_had_webcash = false
+
+          # Check the next gaplimit number of secrets
+          health_check_request = []
+          check_webcashes = {}
+          walletdepths = {}
+
+          Webcash::Helpers.range(current_walletdepth, current_walletdepth + gaplimit).each do |x|
+            secret = generate_next_secret(chain_code, x)
+            webcash = Webcash::Secret.new(BigDecimal(1), secret)
+            public_webcash = webcash.to_public
+            check_webcashes[public_webcash.hashed_value] = webcash
+            walletdepths[public_webcash.hashed_value] = x
+            health_check_request << public_webcash.to_s
+          end
+
+          # Fetch the response from the healthcheck API
+          begin
+            response = HTTParty.post(
+              API_HEALTHCHECK,
+              body: JSON.dump(health_check_request),
+              headers: { "Content-Type" => "application/json" }
+            )
+
+            response_content = response.body
+            if response.code != 200
+              raise "Server returned an error: #{response_content}"
+            end
+
+            response_data = JSON.parse(response_content)
+            results = response_data["results"]
+
+            # Use results and check_webcashes to process
+            results.each do |public_webcash_str, result|
+              public_webcash = Webcash::Public.deserialize(public_webcash_str)
+              if result["spent"] != nil
+                has_had_webcash = true
+                last_used_walletdepth = walletdepths[public_webcash.hashed_value]
+              end
+
+              if result["spent"] == false
+                swc = check_webcashes[public_webcash.hashed_value]
+                swc.amount = BigDecimal(result["amount"])
+
+                if sweep_payments || chain_code != "PAY"
+                  unless @webcash.include?(swc.to_s)
+                    puts "Recovered webcash: #{Webcash::Helpers.decimal_amount_to_string(swc.amount)}"
+                    @webcash.push(swc.to_s)
+                  end
+                else
+                  puts "Found known webcash of amount: #{Webcash::Helpers.decimal_amount_to_string(swc.amount)}"
+                end
+              end
+            end
+
+            if current_walletdepth < reported_walletdepth
+              has_had_webcash = true
+            end
+
+            if has_had_webcash
+              current_walletdepth += gaplimit
+            end
+
+            idx += 1
+          rescue => e
+            puts "Could not successfully call the healthcheck API"
+            raise e
+          end
+        end
+
+        if reported_walletdepth > last_used_walletdepth + 1
+          puts "Something may have gone wrong: reported walletdepth was #{reported_walletdepth} but only found up to #{last_used_walletdepth} depth."
+        end
+
+        if reported_walletdepth < last_used_walletdepth
+          @walletdepths[chain_code] = last_used_walletdepth + 1
+        end
+      end
+
+      save if respond_to?(:save)
+    end
+  end
+end

data/lib/webcash.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# lib/webcash.rb
+require_relative "webcash/version"
+require_relative "webcash/helpers"
+require_relative "webcash/public"
+require_relative "webcash/secret"
+require_relative "webcash/wallet"
+
+module Webcash
+  class Error < StandardError; end
+end

data/sig/webcash.rbs

@@ -0,0 +1,4 @@
+module Webcash
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,161 @@
+--- !ruby/object:Gem::Specification
+name: webcash-rb
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- acidtib
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2024-09-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bigdecimal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: digest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: base64
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: securerandom
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.1
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Webcash facilitates decentralized, peer-to-peer electronic cash transactions.
+  It allows users to send webcash directly to one another and includes mechanisms
+  for detecting double-spending and maintaining monetary supply integrity.
+email:
+- hello@dainelvera.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/webcash.rb
+- lib/webcash/helpers.rb
+- lib/webcash/public.rb
+- lib/webcash/secret.rb
+- lib/webcash/version.rb
+- lib/webcash/wallet.rb
+- sig/webcash.rbs
+homepage: https://github.com/acidtib/webcash-rb
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/acidtib/webcash-rb
+  source_code_uri: https://github.com/acidtib/webcash-rb
+  changelog_uri: https://github.com/acidtib/webcash-rb/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.16
+signing_key:
+specification_version: 4
+summary: Webcash is an experimental electronic cash library for decentralized payments.
+test_files: []