glueby 0.1.0 → 0.2.0

data/lib/glueby/internal.rb

@@ -0,0 +1,6 @@
+module Glueby
+  module Internal
+    autoload :Wallet, 'glueby/internal/wallet'
+    autoload :RPC, 'glueby/internal/rpc'
+  end
+end

data/lib/glueby/internal/rpc.rb

@@ -0,0 +1,35 @@
+module Glueby
+  module Internal
+    module RPC
+      module_function
+
+      def client
+        @rpc ||= Tapyrus::RPC::TapyrusCoreClient.new(@config)
+      end
+
+      def configure(config)
+        @config = config
+      end
+
+      # Perform RPC call on the specific wallet.
+      # This method needs block, and pass a client as as block argument. You can call RPCs on the wallet using the
+      # client object. See an example below.
+      # @param [string] wallet name on Tapyrus Core Wallet
+      # @return [Object] The return object of the block
+      #
+      # ## Example
+      # ```ruby
+      # perform_as('mywallet') do |client|
+      #   client.getbalance
+      # end
+      # ```
+      def perform_as(wallet)
+        before = client.config[:wallet]
+        client.config[:wallet] = wallet
+        yield(client)
+      ensure
+        client.config[:wallet] = before
+      end
+    end
+  end
+end

data/lib/glueby/internal/wallet.rb

@@ -0,0 +1,122 @@
+module Glueby
+  module Internal
+    # # Glueby::Internal::Wallet
+    #
+    # This module provides the way to deal about wallet that includes key management, address management, getting UTXOs.
+    #
+    # ## How to use
+    #
+    # First, you need to configure which wallet implementation is used in Glueby::Internal::Wallet. For now, below wallets are
+    # supported.
+    #
+    # * [Tapyrus Core](https://github.com/chaintope/tapyrus-core)
+    #
+    # Here shows an example to use Tapyrus Core wallet.
+    #
+    # ```ruby
+    # # Setup Tapyrus Core RPC connection
+    # config = {schema: 'http', host: '127.0.0.1', port: 12381, user: 'user', password: 'pass'}
+    # Glueby::Internal::RPC.configure(config)
+    #
+    # # Setup wallet adapter
+    # Glueby::Internal::Wallet.wallet_adapter = Glueby::Internal::Wallet::TapyrusCoreWalletAdapter.new
+    #
+    # # Create wallet
+    # wallet = Glueby::Internal::Wallet.create
+    # wallet.balance # => 0
+    # wallet.list_unspent
+    # ```
+    class Wallet
+      autoload :AbstractWalletAdapter, 'glueby/internal/wallet/abstract_wallet_adapter'
+      autoload :AR, 'glueby/internal/wallet/active_record'
+      autoload :TapyrusCoreWalletAdapter, 'glueby/internal/wallet/tapyrus_core_wallet_adapter'
+      autoload :ActiveRecordWalletAdapter, 'glueby/internal/wallet/active_record_wallet_adapter'
+      autoload :Errors, 'glueby/internal/wallet/errors'
+
+      class << self
+        attr_writer :wallet_adapter
+
+        def create
+          new(wallet_adapter.create_wallet)
+        end
+
+        def load(wallet_id)
+          begin
+            wallet_adapter.load_wallet(wallet_id)
+          rescue Errors::WalletAlreadyLoaded => _
+            # Ignore when wallet is already loaded.
+          end
+          new(wallet_id)
+        end
+
+        def wallets
+          wallet_adapter.wallets.map { |id| new(id) }
+        end
+
+        def wallet_adapter
+          @wallet_adapter or
+            raise Errors::ShouldInitializeWalletAdapter, 'You should initialize wallet adapter using `Glueby::Internal::Wallet.wallet_adapter = some wallet adapter instance`.'
+        end
+      end
+
+      attr_reader :id
+
+      def initialize(wallet_id)
+        @id = wallet_id
+      end
+
+      def balance(only_finalized = true)
+        wallet_adapter.balance(id, only_finalized)
+      end
+
+      def list_unspent(only_finalized = true)
+        wallet_adapter.list_unspent(id, only_finalized)
+      end
+
+      def delete
+        wallet_adapter.delete_wallet(id)
+      end
+
+      def sign_tx(tx, prev_txs = [])
+        wallet_adapter.sign_tx(id, tx, prev_txs)
+      end
+
+      def broadcast(tx)
+        wallet_adapter.broadcast(id, tx)
+      end
+
+      def receive_address
+        wallet_adapter.receive_address(id)
+      end
+
+      def change_address
+        wallet_adapter.change_address(id)
+      end
+
+      def create_pubkey
+        wallet_adapter.create_pubkey(id)
+      end
+
+      def collect_uncolored_outputs(amount)
+        utxos = list_unspent
+
+        utxos.inject([0, []]) do |sum, output|
+          next sum if output[:color_id]
+
+          new_sum = sum[0] + output[:amount]
+          new_outputs = sum[1] << output
+          return [new_sum, new_outputs] if new_sum >= amount
+
+          [new_sum, new_outputs]
+        end
+        raise Glueby::Contract::Errors::InsufficientFunds
+      end
+
+      private
+
+      def wallet_adapter
+        self.class.wallet_adapter
+      end
+    end
+  end
+end

data/lib/glueby/internal/wallet/abstract_wallet_adapter.rb

@@ -0,0 +1,131 @@
+module Glueby
+  module Internal
+    class Wallet
+      # This is an abstract class for wallet adapters. If you want to use a wallet
+      # component with Glueby modules, you can use it by adding subclass of this abstract
+      # class for the wallet component.
+      class AbstractWalletAdapter
+        # Creates a new wallet inside the wallet component and returns `wallet_id`. The created
+        # wallet is loaded from at first.
+        # @return [String] wallet_id
+        def create_wallet
+          raise NotImplementedError, "You must implement #{self.class}##{__method__}"
+        end
+
+        # Delete the wallet inside the wallet component.
+        # This method expect that the wallet will be removed completely
+        # in the wallet and it cannot restore. It is assumed that the main use-case of
+        # this method is for testing.
+        #
+        # @param [String] wallet_id - The wallet id that is offered by `create_wallet()` method.
+        # @return [Boolean] The boolean value whether the deletion was success.
+        def delete_wallet(wallet_id)
+          raise NotImplementedError, "You must implement #{self.class}##{__method__}"
+        end
+
+        # Load the wallet inside the wallet component.
+        # This method makes the wallet to possible to use on other methods like `balance`,
+        # `list_unspent`, etc. All the methods that gets `wallet_id` as a argument needs to
+        # load the wallet before use it.
+        # If the wallet component doesn't need such as load operation to prepare to use the
+        # wallet, `load_wallet` can be empty method.
+        #
+        # @param [String] wallet_id - The wallet id that is offered by `create_wallet()` method.
+        # @raise [Glueby::Internal::Wallet::Errors::WalletAlreadyLoaded] when the specified wallet has been already loaded.
+        def load_wallet(wallet_id)
+          raise NotImplementedError, "You must implement #{self.class}##{__method__}"
+        end
+
+        # Unload the wallet inside the wallet component.
+        #
+        # @param [String] wallet_id - The wallet id that is offered by `create_wallet()` method.
+        # @return [Boolean] The boolean value whether the unloading was success.
+        def unload_wallet(wallet_id)
+          raise NotImplementedError, "You must implement #{self.class}##{__method__}"
+        end
+
+        # Returns list of loaded wallet_id.
+        #
+        # @return [Array of String] - Array of wallet_id
+        def wallets
+          raise NotImplementedError, "You must implement #{self.class}##{__method__}"
+        end
+
+        # Returns amount of tapyrus that the wallet has.
+        #
+        # @param [String] wallet_id - The wallet id that is offered by `create_wallet()` method.
+        # @param [Boolean] only_finalized - The balance includes only finalized UTXO value if it
+        #                                   is true. Default is true.
+        # @return [Integer] The balance of the wallet. The unit is 'tapyrus'.
+        #                   1 TPC equals to 10^8 'tapyrus'.
+        def balance(wallet_id, only_finalized = true)
+          raise NotImplementedError, "You must implement #{self.class}##{__method__}"
+        end
+
+        # Returns all the UTXOs that the wallet has.
+        #
+        # @param [String] wallet_id - The wallet id that is offered by `create_wallet()` method.
+        # @param [Boolean] only_finalized - The UTXOs includes only finalized UTXO value if it
+        #                                   is true. Default is true.
+        # @return [Array of UTXO]
+        #
+        # ## The UTXO structure
+        #
+        # - txid: [String] Transaction id
+        # - vout: [Integer] Output index
+        # - amount: [Integer] Amount of the UTXO as tapyrus unit
+        # - finalized: [Boolean] Whether the UTXO is finalized
+        def list_unspent(wallet_id, only_finalized = true)
+          raise NotImplementedError, "You must implement #{self.class}##{__method__}"
+        end
+
+        # Sign to the transaction with a key in the wallet.
+        #
+        # @param [String] wallet_id - The wallet id that is offered by `create_wallet()` method.
+        # @param [Tapyrus::Tx] tx - The transaction will be signed.
+        # @param [Array] prevtxs array of hash that represents unbroadcasted transaction outputs used by signing tx. 
+        #                Each hash has `txid`, `vout`, `scriptPubKey`, `amount` fields.
+        # @return [Tapyrus::Tx]
+        def sign_tx(wallet_id, tx, prevtxs = [])
+          raise NotImplementedError, "You must implement #{self.class}##{__method__}"
+        end
+
+        # Broadcast the transaction to the Tapyrus Network.
+        #
+        # @param [String] wallet_id - The wallet id that is offered by `create_wallet()` method.
+        # @param [Tapyrus::Tx] tx - The transaction to be broadcasterd.
+        # @return [String] txid
+        def broadcast(wallet_id, tx)
+          raise NotImplementedError, "You must implement #{self.class}##{__method__}"
+        end
+
+        # Returns an address to receive coin.
+        #
+        # @param [String] wallet_id - The wallet id that is offered by `create_wallet()` method.
+        # @return [String] P2PKH address
+        def receive_address(wallet_id)
+          raise NotImplementedError, "You must implement #{self.class}##{__method__}"
+        end
+
+        # Returns an address to change coin.
+        #
+        # @param [String] wallet_id - The wallet id that is offered by `create_wallet()` method.
+        # @return [String] P2PKH address
+        def change_address(wallet_id)
+          raise NotImplementedError, "You must implement #{self.class}##{__method__}"
+        end
+
+        # Returns a new public key.
+        #
+        # This method is expected to returns a new public key. The key would generate internally. This key is provided
+        # for contracts that need public key such as multi sig transaction.
+        #
+        # @param [String] wallet_id - The wallet id that is offered by `create_wallet()` method.
+        # @return [Tapyrus::Key]
+        def create_pubkey(wallet_id)
+          raise NotImplementedError, "You must implement #{self.class}##{__method__}"
+        end
+      end
+    end
+  end
+end

data/lib/glueby/internal/wallet/active_record.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'active_record'
+
+module Glueby
+  module Internal
+    class Wallet
+      module AR
+        autoload :Key, 'glueby/internal/wallet/active_record/key'
+        autoload :Utxo, 'glueby/internal/wallet/active_record/utxo'
+        autoload :Wallet, 'glueby/internal/wallet/active_record/wallet'
+      end
+    end
+  end
+end

data/lib/glueby/internal/wallet/active_record/key.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Glueby
+  module Internal
+    class Wallet
+      module AR
+        class Key < ::ActiveRecord::Base
+          before_create :generate_key
+          before_create :set_script_pubkey
+
+          belongs_to :wallet
+
+          enum purpose: { receive: 0, change: 1 }
+
+          validates :purpose, presence: true
+          validates :private_key, uniqueness: { case_sensitive: false }
+
+          def to_p2pkh
+            Tapyrus::Script.to_p2pkh(Tapyrus.hash160(public_key))
+          end
+
+          def sign(data)
+            Tapyrus::Key.new(priv_key: self.private_key).sign(data, algo: :schnorr)
+          end
+
+          def address
+            to_p2pkh.addresses.first
+          end
+
+          # Return Glueby::Internal::Wallet::AR::Key object for output.
+          # If output is colored output, key is found by corresponding `uncolored` script.
+          #
+          # @param [Tapyrus::TxOut] output
+          # @return [Glueby::Internal::Wallet::AR::Key] key for output
+          def self.key_for_output(output)
+            key_for_script(output.script_pubkey)
+          end
+
+          # Return Glueby::Internal::Wallet::AR::Key object for script.
+          # If script is colored, key is found by corresponding `uncolored` script.
+          #
+          # @param [Tapyrus::Script] script_pubkey
+          # @return [Glueby::Internal::Wallet::AR::Key] key for input
+          def self.key_for_script(script_pubkey)
+            script_pubkey = if script_pubkey.colored?
+              script_pubkey.remove_color.to_hex
+            else
+              script_pubkey.to_hex
+            end
+            find_by(script_pubkey: script_pubkey)
+          end
+
+          private
+
+          def generate_key
+            key = if private_key
+              Tapyrus::Key.new(priv_key: private_key)
+            else
+              Tapyrus::Key.generate
+            end
+            self.private_key ||= key.priv_key
+            self.public_key ||= key.pubkey
+          end
+
+          def set_script_pubkey
+            self.script_pubkey = to_p2pkh.to_hex
+          end
+        end
+      end
+    end
+  end
+end

data/lib/glueby/internal/wallet/active_record/utxo.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Glueby
+  module Internal
+    class Wallet
+      module AR
+        class Utxo < ::ActiveRecord::Base
+          belongs_to :key
+
+          validates :txid, uniqueness: { scope: :index, case_sensitive: false }
+
+          enum status: { init: 0, broadcasted: 1, finalized: 2 }
+
+          def color_id
+            script = Tapyrus::Script.parse_from_payload(script_pubkey.htb)
+            script.color_id&.to_hex
+          end
+
+          # Delete utxo spent by specified tx.
+          #
+          # @param [Tapyrus::Tx] the spending tx
+          def self.destroy_for_inputs(tx)
+            tx.inputs.each do |input|
+              Utxo.destroy_by(txid: input.out_point.txid, index: input.out_point.index)
+            end
+          end
+
+          # Create utxo or update utxo for tx outputs
+          # if there is no key for script pubkey in an output, utxo for the output is not created.
+          #
+          # @param [Tapyrus::Tx] tx
+          def self.create_or_update_for_outputs(tx, status: :finalized)
+            tx.outputs.each.with_index do |output, index|
+              key = Key.key_for_output(output)
+              next unless key
+
+              utxo = Utxo.find_or_initialize_by(txid: tx.txid, index: index)
+              utxo.update!(
+                script_pubkey: output.script_pubkey.to_hex,
+                value: output.value,
+                status: status,
+                key: key
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/glueby/internal/wallet/active_record/wallet.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'active_record'
+
+module Glueby
+  module Internal
+    class Wallet
+      module AR
+        class Wallet < ::ActiveRecord::Base
+          has_many :keys
+
+          validates :wallet_id, uniqueness: { case_sensitive: false }
+
+          # @param [Tapyrus::Tx] tx
+          # @param [Array] prevtxs array of outputs
+          def sign(tx, prevtxs = [])
+            tx.inputs.each.with_index do |input, index|
+              script_pubkey = script_for_input(input, prevtxs)
+              next unless script_pubkey
+              key = Key.key_for_script(script_pubkey)
+              next unless key
+              sign_tx_for_p2pkh(tx, index, key, script_pubkey)
+            end
+            tx
+          end
+
+          def utxos
+            Glueby::Internal::Wallet::AR::Utxo.where(key: keys)
+          end
+
+          private
+
+          def sign_tx_for_p2pkh(tx, index, key, script_pubkey)
+            sighash = tx.sighash_for_input(index, script_pubkey)
+            sig = key.sign(sighash) + [Tapyrus::SIGHASH_TYPE[:all]].pack('C')
+            script_sig = Tapyrus::Script.parse_from_payload(Tapyrus::Script.pack_pushdata(sig) + Tapyrus::Script.pack_pushdata(key.public_key.htb))
+            tx.inputs[index].script_sig = script_sig
+          end
+
+          def script_for_input(input, prevtxs = [])
+            out_point = input.out_point
+            utxo = Utxo.find_by(txid: out_point.txid, index: out_point.index)
+            if utxo
+              Tapyrus::Script.parse_from_payload(utxo.script_pubkey.htb)
+            else
+              output = prevtxs.select { |output| output[:txid] == out_point.txid && output[:vout] == out_point.index }.first
+              Tapyrus::Script.parse_from_payload(output[:scriptPubKey].htb) if output
+            end
+          end
+        end
+      end
+    end
+  end
+end