arkecosystem-crypto 0.1.0 → 0.2.0

data/lib/arkecosystem/crypto/transactions/serializers/delegate_registration.rb

@@ -0,0 +1,19 @@
+module ArkEcosystem
+  module Crypto
+    module Transactions
+      module Serializers
+        # The serializer for delegate registration transactions.
+        class DelegateRegistration < Base
+          def serialize
+            delegate_bytes = BTC::Data.hex_from_data(@transaction[:asset][:delegate][:username])
+
+            @bytes << [delegate_bytes.length / 2].pack('C')
+            @bytes << BTC::Data.data_from_hex(delegate_bytes)
+
+            @bytes
+          end
+        end
+      end
+    end
+  end
+end

data/lib/arkecosystem/crypto/transactions/serializers/delegate_resignation.rb

@@ -0,0 +1,14 @@
+module ArkEcosystem
+  module Crypto
+    module Transactions
+      module Serializers
+        # The serializer for delegate resignation transactions.
+        class DelegateResignation < Base
+          def serialize
+            @bytes
+          end
+        end
+      end
+    end
+  end
+end

data/lib/arkecosystem/crypto/transactions/serializers/ipfs.rb

@@ -0,0 +1,19 @@
+module ArkEcosystem
+  module Crypto
+    module Transactions
+      module Serializers
+        # The serializer for IPFS transactions.
+        class IPFS < Base
+          def serialize
+            dag = @transaction[:asset][:ipfs][:dag]
+
+            @bytes << [dag.length / 2].pack('C')
+            @bytes << BTC::Data.data_from_hex(dag)
+
+            @bytes
+          end
+        end
+      end
+    end
+  end
+end

data/lib/arkecosystem/crypto/transactions/serializers/multi_payment.rb

@@ -0,0 +1,25 @@
+module ArkEcosystem
+  module Crypto
+    module Transactions
+      module Serializers
+        # The serializer for multi payment transactions.
+        class MultiPayment < Base
+          def serialize
+            @bytes << [@transaction[:asset][:payments].count].pack('Q<')
+
+            @transaction[:asset][:payments].each do |_item|
+              @bytes << [@item[:amount]].pack('Q<')
+
+              recipient_id = BTC::Base58.data_from_base58check(@item[:recipientId])
+              recipient_id = BTC::Data.hex_from_data(recipient_id)
+
+              @bytes << [recipient_id].pack('H*')
+            end
+
+            @bytes
+          end
+        end
+      end
+    end
+  end
+end

data/lib/arkecosystem/crypto/transactions/serializers/multi_signature_registration.rb

@@ -0,0 +1,33 @@
+module ArkEcosystem
+  module Crypto
+    module Transactions
+      module Serializers
+        # The serializer for multi signature registrations transactions.
+        class MultiSignatureRegistration < Base
+          def serialize
+            keysgroup = []
+
+            if @transaction[:version] == 1 || @transaction[:version].empty?
+              @transaction[:asset][:multisignature][:keysgroup].each do |item|
+                if item.start_with?('+')
+                  keysgroup.push(item[1..-1])
+                else
+                  keysgroup.push(item)
+                end
+              end
+            else
+              keysgroup = @transaction[:asset][:multisignature][:keysgroup]
+            end
+
+            @bytes << [@transaction[:asset][:multisignature][:min]].pack('C')
+            @bytes << [@transaction[:asset][:multisignature][:keysgroup].count].pack('C')
+            @bytes << [@transaction[:asset][:multisignature][:lifetime]].pack('C')
+            @bytes << BTC::Data.data_from_hex(keysgroup.join(''))
+
+            @bytes
+          end
+        end
+      end
+    end
+  end
+end

data/lib/arkecosystem/crypto/transactions/serializers/second_signature_registration.rb

@@ -0,0 +1,16 @@
+module ArkEcosystem
+  module Crypto
+    module Transactions
+      module Serializers
+        # The serializer for second signature registrations transactions.
+        class SecondSignatureRegistration < Base
+          def serialize
+            @bytes << BTC::Data.data_from_hex(@transaction[:asset][:signature][:publicKey])
+
+            @bytes
+          end
+        end
+      end
+    end
+  end
+end

data/lib/arkecosystem/crypto/transactions/serializers/timelock_transfer.rb

@@ -0,0 +1,23 @@
+module ArkEcosystem
+  module Crypto
+    module Transactions
+      module Serializers
+        # The serializer for timelock transfer transactions.
+        class TimelockTransfer < Base
+          def serialize
+            @bytes << [@transaction[:amount]].pack('Q<')
+            @bytes << [@transaction[:timelocktype]].pack('h*')
+            @bytes << [@transaction[:timelock]].pack('V')
+
+            recipient_id = BTC::Base58.data_from_base58check(@transaction[:recipientId])
+            recipient_id = BTC::Data.hex_from_data(recipient_id)
+
+            @bytes << [recipient_id].pack('H*')
+
+            @bytes
+          end
+        end
+      end
+    end
+  end
+end

data/lib/arkecosystem/crypto/transactions/serializers/transfer.rb

@@ -0,0 +1,22 @@
+module ArkEcosystem
+  module Crypto
+    module Transactions
+      module Serializers
+        # The serializer for transfer transactions.
+        class Transfer < Base
+          def serialize
+            @bytes << [@transaction[:amount]].pack('Q<')
+            @bytes << [@transaction[:expiration] || 0].pack('V')
+
+            recipient_id = BTC::Base58.data_from_base58check(@transaction[:recipientId])
+            recipient_id = BTC::Data.hex_from_data(recipient_id)
+
+            @bytes << [recipient_id].pack('H*')
+
+            @bytes
+          end
+        end
+      end
+    end
+  end
+end

data/lib/arkecosystem/crypto/transactions/serializers/vote.rb

@@ -0,0 +1,25 @@
+module ArkEcosystem
+  module Crypto
+    module Transactions
+      module Serializers
+        # The serializer for vote transactions.
+        class Vote < Base
+          def serialize
+            vote_bytes = []
+
+            @transaction[:asset][:votes].each do |item|
+              prefix = item.start_with?('+') ? '01' : '00'
+
+              vote_bytes.push(prefix + item[1..-1])
+            end
+
+            @bytes << [@transaction[:asset][:votes].count].pack('C')
+            @bytes << BTC::Data.data_from_hex(vote_bytes.join(''))
+
+            @bytes
+          end
+        end
+      end
+    end
+  end
+end

data/lib/arkecosystem/crypto/transactions/transaction.rb

@@ -0,0 +1,198 @@
+require 'json'
+require 'btcruby'
+require 'arkecosystem/crypto/enums/types'
+
+module ArkEcosystem
+  module Crypto
+    module Transactions
+      # The model of a transaction.
+      class Transaction
+        attr_accessor :amount, :asset, :fee, :id, :recipient_id, :sender_public_key, :sign_signature, :second_signature, :signature, :signatures, :timestamp, :type, :vendor_field, :vendor_field_hex, :version, :network, :expiration, :timelocktype, :timelock
+
+        def initialize
+          @asset = {}
+        end
+
+        def get_id
+          Digest::SHA256.digest(to_bytes(false, false)).unpack('H*').first
+        end
+
+        def sign(passphrase)
+          private_key = ArkEcosystem::Crypto::Identities::PrivateKey.from_passphrase(passphrase)
+          @sender_public_key = private_key.public_key.unpack('H*').first
+          @signature = private_key.ecdsa_signature(Digest::SHA256.digest(to_bytes)).unpack('H*').first
+          self
+        end
+
+        def second_sign(second_passphrase)
+          second_key = ArkEcosystem::Crypto::Identities::PrivateKey.from_passphrase(second_passphrase)
+
+          @sign_signature = second_key.ecdsa_signature(Digest::SHA256.digest(to_bytes(false))).unpack('H*').first
+          self
+        end
+
+        def verify
+          public_only_key = BTC::Key.new(public_key: [@sender_public_key].pack('H*'))
+          public_only_key.verify_ecdsa_signature([@signature].pack('H*'), Digest::SHA256.digest(to_bytes))
+        end
+
+        def second_verify(second_public_key)
+          public_only_key = BTC::Key.new(public_key: [second_public_key].pack('H*'))
+          public_only_key.verify_ecdsa_signature([@sign_signature].pack('H*'), Digest::SHA256.digest(to_bytes(false)))
+        end
+
+        def to_bytes(skip_signature = true, skip_second_signature = true)
+          bytes = ''
+          bytes << [@type].pack('c')
+          bytes << [@timestamp].pack('V')
+          bytes << [@sender_public_key].pack('H*')
+
+          bytes << if @recipient_id
+          BTC::Base58.data_from_base58check(@recipient_id)
+          else
+            [].pack('x21')
+          end
+
+          if @vendor_field
+            bytes << @vendor_field
+
+            if @vendor_field.size < 64
+              bytes << [].pack("x#{64 - @vendor_field.size}")
+            end
+          else
+            bytes << [].pack('x64')
+          end
+
+          bytes << [@amount].pack('Q<')
+          bytes << [@fee].pack('Q<')
+
+          case @type
+          when ArkEcosystem::Crypto::Enums::Types::SECOND_SIGNATURE_REGISTRATION
+            asset_signature_public_key = @asset[:signature][:public_key]
+
+            bytes << [asset_signature_public_key].pack('H*')
+          when ArkEcosystem::Crypto::Enums::Types::DELEGATE_REGISTRATION
+            bytes << @asset[:delegate][:username]
+          when ArkEcosystem::Crypto::Enums::Types::VOTE
+            bytes << @asset[:votes].join('')
+          when ArkEcosystem::Crypto::Enums::Types::MULTI_SIGNATURE_REGISTRATION
+            ms_asset = @asset[:multisignature]
+
+            bytes << [ms_asset[:min]].pack('C')
+            bytes << [ms_asset[:lifetime]].pack('C')
+            bytes << ms_asset[:keysgroup].join('')
+          end
+
+          if !skip_signature && @signature
+            bytes << [@signature].pack('H*')
+          end
+
+          if !skip_second_signature && @sign_signature
+            bytes << [@sign_signature].pack('H*')
+          end
+
+          bytes
+        end
+
+        def parse_signatures(serialized, start_offset)
+          signature = serialized[start_offset..-1]
+
+          multi_signature_offset = 0
+
+          if !signature.length
+            @signature = nil
+          else
+            # First Signature
+            signature_length = signature[2, 2].to_i(16) + 2
+            @signature = serialized[start_offset, signature_length * 2]
+
+            # Multi Signature
+            multi_signature_offset += signature_length * 2
+
+            # Second Signature
+            @second_signature = serialized[(start_offset + signature_length * 2)..-1]
+
+            if @second_signature.empty?
+              @second_signature = nil
+            elsif @second_signature[0, 2] == 'ff'
+              @second_signature = nil
+            else
+              # Second Signature
+              second_signature_length = @second_signature[2, 2].to_i(16) + 2
+              @second_signature = @second_signature[0, second_signature_length * 2]
+
+              # Multi Signature
+              multi_signature_offset += second_signature_length * 2
+            end
+
+            # All Signatures
+            signatures = serialized[(start_offset + multi_signature_offset)..-1]
+
+            return self if signatures.empty?
+
+            return self if signatures[0, 2] != 'ff'
+
+            # Parse Multi Signatures
+            signatures = signatures[2..-1]
+            @signatures = []
+
+            more_signatures = true
+
+            while more_signatures
+              break if signatures.empty?
+
+              multi_signature_length = signatures[2, 2].to_i(16) + 2
+
+              if multi_signature_length > 0
+                @signatures.push(signatures[0, multi_signature_length * 2])
+              else
+                more_signatures = false
+              end
+
+              signatures = signatures[(multi_signature_length * 2)..-1]
+            end
+
+            self
+          end
+        end
+
+        def serialize(transaction)
+          ArkEcosystem::Crypto::Serialiser.new(transaction).serialize
+        end
+
+        def deserialize(serialized)
+          ArkEcosystem::Crypto::Transactions::Deserializer.new(serialized).deserialize
+        end
+
+        def to_params
+          {
+            type: type,
+            amount: amount,
+            fee: fee,
+            vendorField: vendor_field,
+            timestamp: timestamp,
+            recipientId: recipient_id,
+            senderPublicKey: sender_public_key,
+            signature: signature,
+            id: id
+          }.tap do |h|
+            h[:asset] = asset.deep_transform_keys { |key| snake_case_to_camel_case(key) } if asset.any?
+            h[:signSignature] = sign_signature if sign_signature
+          end
+        end
+
+        def to_json
+          to_params.to_json
+        end
+
+        private
+
+        def snake_case_to_camel_case(string)
+          string.to_s.split('_').enum_for(:each_with_index).collect do |s, index|
+            index.zero? ? s : s.capitalize
+          end.join
+        end
+      end
+    end
+  end
+end

data/lib/arkecosystem/crypto/utils/message.rb

@@ -0,0 +1,42 @@
+module ArkEcosystem
+  module Crypto
+    module Utils
+      # The builder to work with signed messages.
+      class Message
+        def initialize(message)
+          @public_key = message[:publickey]
+          @signature = message[:signature]
+          @message = message[:message]
+        end
+
+        def self.sign(message, passphrase)
+          key = ArkEcosystem::Crypto::Identities::PrivateKey.from_passphrase(passphrase)
+
+          hash = Digest::SHA256.digest(message)
+
+          Message.new(publickey: BTC.to_hex(key.public_key),
+                      signature: BTC.to_hex(key.ecdsa_signature(hash)),
+                      message: message)
+        end
+
+        def verify
+          key = BTC::Key.new(public_key: BTC.from_hex(@public_key))
+
+          hash = Digest::SHA256.digest(@message)
+
+          key.verify_ecdsa_signature(BTC.from_hex(@signature), hash)
+        end
+
+        def to_params
+          { publickey: @public_key,
+            signature: @signature,
+            message: @message }
+        end
+
+        def to_json
+          to_params.to_json
+        end
+      end
+    end
+  end
+end