osbc 0.1.5

data/app/controllers/signatures_controller.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+class SignaturesController < ApplicationController
+  before_action :set_signature, only: %i[ show edit update destroy ]
+
+  # GET /signatures or /signatures.json
+  def index
+    @signatures = Signature.all
+  end
+
+  # GET /signatures/1 or /signatures/1.json
+  def show
+  end
+
+  private
+    # Use callbacks to share common setup or constraints between actions.
+    def set_signature
+      @signature = Signature.find(params[:id])
+    end
+
+    # Only allow a list of trusted parameters through.
+    def signature_params
+      params.require(:signature).permit(:signature, :time_ref, :contract_id, :common_word, :symbol_sequence, :number_sequence, :verify_sig, :block_hash, :signature_hash)
+    end
+end

data/app/controllers/tickets_controller.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+class TicketsController < ApplicationController
+  before_action :set_ticket, only: %i[ show edit update destroy ]
+  before_action :authenticate_user!
+
+  # GET /tickets or /tickets.json
+  def index
+    @tickets = Ticket.all
+  end
+
+  # GET /tickets/1 or /tickets/1.json
+  def show
+  end
+
+  # GET /tickets/new
+  def new
+    @ticket = Ticket.new
+  end
+
+  # GET /tickets/1/edit
+  def edit
+  end
+
+  # POST /tickets or /tickets.json
+  def create
+    return no_transactions_response if block_transactions.empty?
+    create_ticket
+    redirect_to tickets_path, notice: "Processing ticket, please wait, wait a minute and refresh the page"
+  end
+
+  # PATCH/PUT /tickets/1 or /tickets/1.json
+  def update
+    respond_to do |format|
+      if @ticket.update(ticket_params)
+        format.html { redirect_to ticket_url(@ticket), notice: "Ticket was successfully updated." }
+        format.json { render :show, status: :ok, location: @ticket }
+      else
+        format.html { render :edit, status: :unprocessable_entity }
+        format.json { render json: @ticket.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  # DELETE /tickets/1 or /tickets/1.json
+  def destroy
+    @ticket.destroy
+
+    respond_to do |format|
+      format.html { redirect_to tickets_url, notice: "Ticket was successfully destroyed." }
+      format.json { head :no_content }
+    end
+  end
+
+  private
+    def create_ticket
+      CreateTicketWorker.perform_async(current_user.id, current_pool.id, time_ref)
+    end
+    # Use callbacks to share common setup or constraints between actions.
+    def set_ticket
+      @ticket = Ticket.find(params[:id])
+    end
+
+    def time_ref
+      @time_ref = block_transactions.first.created_at
+    end
+
+    def no_transactions_response
+      redirect_to root_path, notice: "No transactions yet"
+    end
+
+    # Only allow a list of trusted parameters through.
+    def ticket_params
+      params.require(:ticket).permit(:user_id, :pool_id, :status, :time_ref)
+    end
+end

data/app/controllers/transactions_controller.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+class TransactionsController < ApplicationController
+  before_action :set_transaction, only: %i[ show edit update destroy ]
+  before_action :authenticate_user!, except: [:index, :show]
+
+  # GET /transactions or /transactions.json
+  def index
+    @transactions = Transaction.all
+  end
+
+  # GET /transactions/1 or /transactions/1.json
+  def show
+  end
+
+  # GET /transactions/new
+  def new
+    @transaction = Transaction.new
+  end
+
+  # POST /transactions or /transactions.json
+  def create
+    @receiver_key = transaction_params[:receiver_key]
+    @amount = transaction_params[:amount]
+    @sender_key = Wallet.find_by(user_id: current_user.id).pv_key
+    create_transaction_in_block
+    redirect_to transactions_path, notice: "Processing transaction, please wait a minute and refresh the page"
+  end
+
+  private
+    def create_transaction_in_block
+      block = Block.where(master_hash: nil).first
+      work.perform_async(@receiver_key, @sender_key, @amount, block.id)
+    end
+
+    def work
+      TransactionToBlockWorker
+    end
+    # Use callbacks to share common setup or constraints between actions.
+    def set_transaction
+      @transaction = Transaction.find(params[:id])
+    end
+
+    # Only allow a list of trusted parameters through.
+    def transaction_params
+      params.require(:transaction).permit(:sender_key, :receiver_key, :signature_time, :status, :data, :upl_file, :upl_file_name, :upl_file_type, :upl_file_size, :upl_file_hash, :amount, :fee, :block_id)
+    end
+end

data/app/controllers/users/confirmations_controller.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+class Users::ConfirmationsController < Devise::ConfirmationsController
+  # GET /resource/confirmation/new
+  # def new
+  #   super
+  # end
+
+  # POST /resource/confirmation
+  # def create
+  #   super
+  # end
+
+  # GET /resource/confirmation?confirmation_token=abcdef
+  # def show
+  #   super
+  # end
+
+  # protected
+
+  # The path used after resending confirmation instructions.
+  # def after_resending_confirmation_instructions_path_for(resource_name)
+  #   super(resource_name)
+  # end
+
+  # The path used after confirmation.
+  # def after_confirmation_path_for(resource_name, resource)
+  #   super(resource_name, resource)
+  # end
+end

data/app/controllers/users/omniauth_callbacks_controller.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+class Users::OmniauthCallbacksController < Devise::OmniauthCallbacksController
+  # You should configure your model like this:
+  # devise :omniauthable, omniauth_providers: [:twitter]
+
+  # You should also create an action method in this controller like this:
+  # def twitter
+  # end
+
+  # More info at:
+  # https://github.com/heartcombo/devise#omniauth
+
+  # GET|POST /resource/auth/twitter
+  # def passthru
+  #   super
+  # end
+
+  # GET|POST /users/auth/twitter/callback
+  # def failure
+  #   super
+  # end
+
+  # protected
+
+  # The path used when OmniAuth fails
+  # def after_omniauth_failure_path_for(scope)
+  #   super(scope)
+  # end
+end

data/app/controllers/users/passwords_controller.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+class Users::PasswordsController < Devise::PasswordsController
+  # GET /resource/password/new
+  # def new
+  #   super
+  # end
+
+  # POST /resource/password
+  # def create
+  #   super
+  # end
+
+  # GET /resource/password/edit?reset_password_token=abcdef
+  # def edit
+  #   super
+  # end
+
+  # PUT /resource/password
+  # def update
+  #   super
+  # end
+
+  # protected
+
+  # def after_resetting_password_path_for(resource)
+  #   super(resource)
+  # end
+
+  # The path used after sending reset password instructions
+  # def after_sending_reset_password_instructions_path_for(resource_name)
+  #   super(resource_name)
+  # end
+end

data/app/controllers/users/registrations_controller.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+class Users::RegistrationsController < Devise::RegistrationsController
+  before_action :configure_sign_up_params, only: [:create]
+  # before_action :configure_account_update_params, only: [:update]
+
+  # GET /resource/sign_up
+  # def new
+  #   super
+  # end
+
+  # POST /resource
+  def create
+    super
+  end
+
+  # GET /resource/edit
+  # def edit
+  #   super
+  # end
+
+  # PUT /resource
+  # def update
+  #   super
+  # end
+
+  # DELETE /resource
+  # def destroy
+  #   super
+  # end
+
+  # GET /resource/cancel
+  # Forces the session data which is usually expired after sign
+  # in to be expired now. This is useful if the user wants to
+  # cancel oauth signing in/up in the middle of the process,
+  # removing all OAuth session data.
+  # def cancel
+  #   super
+  # end
+
+  protected
+    # If you have extra params to permit, append them to the sanitizer.
+    def configure_sign_up_params
+      devise_parameter_sanitizer.permit(:sign_up, keys: [:username])
+    end
+
+    # If you have extra params to permit, append them to the sanitizer.
+    # def configure_account_update_params
+    #   devise_parameter_sanitizer.permit(:account_update, keys: [:attribute])
+    # end
+
+    # The path used after sign up.
+    def after_sign_up_path_for(resource)
+      root_path
+    end
+
+  # The path used after sign up for inactive accounts.
+  # def after_inactive_sign_up_path_for(resource)
+  #   super(resource)
+  # end
+end

data/app/controllers/users/sessions_controller.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class Users::SessionsController < Devise::SessionsController
+  # before_action :configure_sign_in_params, only: [:create]
+
+  # GET /resource/sign_in
+  # def new
+  #   super
+  # end
+
+  # POST /resource/sign_in
+  # def create
+  #   super
+  # end
+
+  # DELETE /resource/sign_out
+  # def destroy
+  #   super
+  # end
+
+  # protected
+
+  # If you have extra params to permit, append them to the sanitizer.
+  # def configure_sign_in_params
+  #   devise_parameter_sanitizer.permit(:sign_in, keys: [:attribute])
+  # end
+end

data/app/controllers/users/unlocks_controller.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+class Users::UnlocksController < Devise::UnlocksController
+  # GET /resource/unlock/new
+  # def new
+  #   super
+  # end
+
+  # POST /resource/unlock
+  # def create
+  #   super
+  # end
+
+  # GET /resource/unlock?unlock_token=abcdef
+  # def show
+  #   super
+  # end
+
+  # protected
+
+  # The path used after sending unlock password instructions
+  # def after_sending_unlock_instructions_path_for(resource)
+  #   super(resource)
+  # end
+
+  # The path used after unlocking the resource
+  # def after_unlock_path_for(resource)
+  #   super(resource)
+  # end
+end

data/app/controllers/wallets_controller.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class WalletsController < ApplicationController
+  before_action :set_wallet, only: %i[ show edit update destroy ]
+  before_action :authenticate_user!
+
+  def index
+    @wallets = current_user.wallet
+  end
+
+  def show
+  end
+
+  private
+    def set_wallet
+      @wallet = Wallet.find(params[:id])
+    end
+end

data/app/helpers/application_helper.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+module ApplicationHelper
+end

data/app/helpers/blocks_helper.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+module BlocksHelper
+end

data/app/helpers/chains_helper.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+module ChainsHelper
+end

data/app/helpers/contracts_helper.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+module ContractsHelper
+end

data/app/helpers/pools_helper.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+module PoolsHelper
+end

data/app/helpers/signatures_helper.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+module SignaturesHelper
+end

data/app/helpers/tickets_helper.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+module TicketsHelper
+end

data/app/helpers/transactions_helper.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+module TransactionsHelper
+end

data/app/helpers/wallets_helper.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+module WalletsHelper
+end

data/app/javascript/application.js

@@ -0,0 +1,3 @@
+// Configure your import map in config/importmap.rb. Read more: https://github.com/rails/importmap-rails
+import "@hotwired/turbo-rails"
+import "controllers"

data/app/javascript/controllers/application.js

@@ -0,0 +1,9 @@
+import { Application } from "@hotwired/stimulus"
+
+const application = Application.start()
+
+// Configure Stimulus development experience
+application.debug = false
+window.Stimulus   = application
+
+export { application }

data/app/javascript/controllers/hello_controller.js

@@ -0,0 +1,7 @@
+import { Controller } from "@hotwired/stimulus"
+
+export default class extends Controller {
+  connect() {
+    this.element.textContent = "Hello World!"
+  }
+}

data/app/javascript/controllers/index.js

@@ -0,0 +1,11 @@
+// Import and register all your controllers from the importmap under controllers/*
+
+import { application } from "controllers/application"
+
+// Eager load all controllers defined in the import map under controllers/**/*_controller
+import { eagerLoadControllersFrom } from "@hotwired/stimulus-loading"
+eagerLoadControllersFrom("controllers", application)
+
+// Lazy load controllers as they appear in the DOM (remember not to preload controllers in import map!)
+// import { lazyLoadControllersFrom } from "@hotwired/stimulus-loading"
+// lazyLoadControllersFrom("controllers", application)

data/app/jobs/application_job.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class ApplicationJob < ActiveJob::Base
+  # Automatically retry jobs that encountered a deadlock
+  # retry_on ActiveRecord::Deadlocked
+
+  # Most jobs are safe to ignore if the underlying records are no longer available
+  # discard_on ActiveJob::DeserializationError
+end

data/app/mailers/application_mailer.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+class ApplicationMailer < ActionMailer::Base
+  default from: "from@example.com"
+  layout "mailer"
+end

data/app/models/acceptable_number_sequence.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class AcceptableNumberSequence < ApplicationRecord
+end

data/app/models/acceptable_symbol_sequence.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class AcceptableSymbolSequence < ApplicationRecord
+end

data/app/models/acceptable_word.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class AcceptableWord < ApplicationRecord
+end

data/app/models/application_record.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class ApplicationRecord < ActiveRecord::Base
+  primary_abstract_class
+end

data/app/models/block.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class Block < ApplicationRecord
+  belongs_to :chain
+  validates :nonce, presence: true
+  validates :previous_hash, presence: true
+  validates :block_data, presence: true
+  validates :connections, presence: true
+  has_many :transactions, dependent: :destroy, counter_cache: true
+  after_create :create_pool
+  has_one :pool, dependent: :destroy, inverse_of: :block
+
+  private
+    def create_pool
+      Pool.create(block_id: self.id)
+    end
+end

data/app/models/chain.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+class Chain < ApplicationRecord
+  validates :name, presence: true, uniqueness: true, length: { maximum: 20 }
+  validates :maintainer, presence: true, length: { maximum: 50 }
+  validates :chain_version, presence: true, length: { maximum: 20 }
+  validates :description, presence: true, length: { maximum: 1000 }
+
+  has_many :blocks, dependent: :destroy
+end

data/app/models/concerns/sequences_validator.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+class SequencesValidator < ActiveModel::Validator
+  def validate(record)
+    @record = record
+    @word = record.common_word
+    @symbol_seq = record.symbol_sequence
+    @number_seq = record.number_sequence
+    record.errors.add(:base, "Invalid Hashable Content") unless valid_checker
+  end
+
+  private
+    attr_reader :record, :word, :symbol_seq, :number_seq
+
+    def valid_checker
+      acceptable_word? && acceptable_symbol_sequence? && acceptable_number_sequence?
+    end
+
+    def acceptable_word?
+      AcceptableWord.find_by(word: word).present?
+    end
+
+    def acceptable_symbol_sequence?
+      AcceptableSymbolSequence.find_by(seq: symbol_seq).present?
+    end
+
+    def acceptable_number_sequence?
+      AcceptableNumberSequence.find_by(seq: number_seq).present?
+    end
+end

data/app/models/concerns/wallet_exists_validator.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class WalletExistsValidator < ActiveModel::Validator
+  def validate(record)
+    if Wallet.find_by(pr_key: record.receiver_key).nil?
+      record.errors[:sender_key] << "Sender key is not valid"
+    end
+
+    if Wallet.find_by(pv_key: record.sender_key).nil?
+      record.errors[:receiver_key] << "Receiver key is not valid"
+    end
+  end
+end

data/app/models/contract.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class Contract < ApplicationRecord
+  validates :blk_transaction, presence: true
+  belongs_to :blk_transaction, class_name: "Transaction", foreign_key: "transaction_id", inverse_of: :contract
+  has_many :signatures, inverse_of: :contract, dependent: :destroy
+end

data/app/models/pool.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class Pool < ApplicationRecord
+  belongs_to :block
+end

data/app/models/signature.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+class Signature < ApplicationRecord
+  belongs_to :contract
+  belongs_to :ticket
+  belongs_to :user
+  validates :signature, presence: true, length: { is: 64 }, uniqueness: true
+  # validates :common_word, presence: true
+  # validates :symbol_sequence, presence: true
+  # validates :number_sequence, presence: true
+  # validates_with SequencesValidator
+end

data/app/models/ticket.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class Ticket < ApplicationRecord
+  belongs_to :user
+  belongs_to :pool
+  validates :time_ref, presence: true
+  validates :status, presence: true
+  has_many :signatures
+
+  enum status: { active: 0, inactive: 1 }
+end

data/app/models/transaction.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+class Transaction < ApplicationRecord
+  include ActiveModel::Validations
+  validates :sender_key, presence: true
+  validates :receiver_key, presence: true
+  validates :fee, presence: true, numericality: { greater_than: 0 }
+  validates :amount, presence: true, numericality: { greater_than: 0 }
+  validates_with WalletExistsValidator
+  belongs_to :block
+  has_one :contract, dependent: :destroy, inverse_of: :blk_transaction
+  after_create :create_contract
+
+  def sender
+    Wallet.find_by(pv_key: sender_key).user.username
+  end
+
+  def receiver
+    Wallet.find_by(pr_key: receiver_key).user.username
+  end
+
+  def create_contract
+    Contract.create(blk_transaction: self)
+  end
+end