silkey-sdk 0.0.1

data/lib/silkey-sdk.rb

@@ -0,0 +1,23 @@
+require 'eth'
+require 'ethereum.rb'
+# require 'json'
+require 'jwt'
+require 'logger'
+require 'pry'
+#require 'active_support'
+#require 'active_support/core_ext/module'
+require 'virtus_convert'
+require 'virtus'
+# require 'retriable'
+require 'silkey'
+
+require_relative 'silkey/contract'
+require_relative 'silkey/configuration'
+require_relative 'silkey/factories/client_factory'
+require_relative 'silkey/factories/contract_factory'
+require_relative 'silkey/models/jwt_payload'
+require_relative 'silkey/services/logger_service'
+require_relative 'silkey/sdk'
+require_relative 'silkey/utils'
+
+require_relative 'silkey/registry_contract/registry_contract'

data/lib/silkey.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'silkey/version'
+require 'active_support/all'
+
+module Silkey
+  def self.root_path
+    File.dirname __dir__
+  end
+
+  def self.bin_path
+    File.join root_path, 'bin'
+  end
+
+  def self.lib_path
+    File.join root_path, 'lib'
+  end
+
+  def self.abi_path
+    File.join root_path, 'lib/silkey/abi'
+  end
+end

data/lib/silkey/abi/registry_contract_abi.json

@@ -0,0 +1,129 @@
+[
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "previousOwner",
+        "type": "address"
+      },
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "newOwner",
+        "type": "address"
+      }
+    ],
+    "name": "OwnershipTransferred",
+    "type": "event"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "bytes32",
+        "name": "name",
+        "type": "bytes32"
+      }
+    ],
+    "name": "getAddress",
+    "outputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "bytes32[]",
+        "name": "names",
+        "type": "bytes32[]"
+      },
+      {
+        "internalType": "address[]",
+        "name": "destinations",
+        "type": "address[]"
+      }
+    ],
+    "name": "importAddresses",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "owner",
+    "outputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "renounceOwnership",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "bytes32",
+        "name": "",
+        "type": "bytes32"
+      }
+    ],
+    "name": "repository",
+    "outputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "bytes32",
+        "name": "name",
+        "type": "bytes32"
+      }
+    ],
+    "name": "requireAndGetAddress",
+    "outputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "newOwner",
+        "type": "address"
+      }
+    ],
+    "name": "transferOwnership",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  }
+]

data/lib/silkey/configuration.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Silkey
+  class Configuration
+    class << self
+      attr_accessor :client_url
+      attr_accessor :registry_contract_abi
+      attr_accessor :registry_contract_address
+      attr_accessor :enable_logs
+
+      def setup
+        yield self
+      end
+    end
+
+    self.client_url = 'http://localhost:8545'
+    self.enable_logs = false
+
+    self.registry_contract_abi =
+      File.read(File.expand_path('./registry_contract_abi.json', Silkey.abi_path))
+
+    self.registry_contract_address = ''
+  end
+end

data/lib/silkey/contract.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Silkey # :nodoc: all
+  class Contract < SimpleDelegator
+    def initialize(contract, client)
+      super(contract)
+      @contract = contract
+      @client = client
+      _, @functions, = Ethereum::Abi.parse_abi(contract.abi)
+    end
+
+    def call_func_for_block(func_name, default_block = 'latest', *args)
+      fun = @functions.find { |f| f.name == func_name.to_s }
+
+      raise 'FunctionNotFoundError', func_name unless fun
+
+      raw_result = @client.send_command('eth_call',
+                                        FrozenArray.new(@contract.call_args(fun, args),
+                                                        default_block))['result']
+
+      output = Ethereum::Decoder.new.decode_arguments(fun.outputs, raw_result)
+
+      return output[0] if output.length == 1
+
+      output
+    end
+
+    class FrozenArray < Array
+      def initialize(*args)
+        super(args)
+      end
+
+      def <<(_)
+        self
+      end
+    end
+  end
+end

data/lib/silkey/factories/client_factory.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Silkey # :nodoc: all
+  class ClientFactory
+    def self.call(params = {})
+      new(params).call
+    end
+
+    def initialize(params)
+      @client_url = params.fetch(:client_url, Configuration.client_url)
+      @log = params.fetch(:enable_logs, Configuration.enable_logs)
+    end
+
+    def call
+      @client = new_client
+
+      client
+    end
+
+    private
+
+    attr_reader :client,
+                :log,
+                :client_url
+
+    def new_client
+      Ethereum::HttpClient.new(client_url, nil, log)
+    end
+  end
+end

data/lib/silkey/factories/contract_factory.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Silkey # :nodoc: all
+  class ContractFactory
+    def self.call(params)
+      new(params).call
+    end
+
+    def initialize(params = {})
+      @abi =
+        params.fetch(:abi)
+      @address =
+        params.fetch(:address)
+      @client_url =
+        params.fetch(:client_url, Configuration.client_url)
+      @name =
+        params.fetch(:name)
+    end
+
+    def call
+      @contract = create_contract
+
+      contract
+    end
+
+    private
+
+    attr_reader :abi,
+                :address,
+                :contract,
+                :client_url,
+                :name
+
+    def client
+      ClientFactory.call(client_url: client_url)
+    end
+
+    def create_contract
+      Silkey::Contract.new(Ethereum::Contract.create(
+                             name: name,
+                             address: address,
+                             abi: abi,
+                             client: client
+                           ), client)
+    end
+  end
+end

data/lib/silkey/models/jwt_payload.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+module Silkey
+  module Models
+    class JwtPayload
+      include Virtus.model
+
+      SCOPE_DIVIDER = ','
+
+      # rubocop:disable Style/HashSyntax
+      attribute :address, String, :writer => :private
+      attribute :email, String, :writer => :private
+      attribute :silkey_signature, String, :writer => :private
+      attribute :silkey_signature_timestamp, Integer
+      attribute :user_signature, String, :writer => :private
+      attribute :user_signature_timestamp, Integer
+      attribute :ref_id, String, :writer => :private
+      attribute :_scope, {}, :writer => :private, :reader => :private
+      # rubocop:enable Style/HashSyntax
+
+      def scope
+        _scope.keys.sort.join(SCOPE_DIVIDER)
+      end
+
+      def scope_divider
+        SCOPE_DIVIDER
+      end
+
+      # rubocop:disable Naming/AccessorMethodName
+      def set_scope(scope)
+        return self if Silkey::Utils.empty?(scope)
+
+        _scope[scope] = true
+        self
+      end
+
+      def set_address(addr)
+        raise "`#{addr}` is not ethereum address" unless Silkey::Utils.ethereum_address?(addr)
+
+        self.address = addr
+        self
+      end
+
+      def set_email(email)
+        self.email = email
+        self
+      end
+
+      def set_ref_id(ref_id)
+        self.ref_id = ref_id
+        self
+      end
+
+      def set_user_signature(sig, timestamp)
+        raise "user signature invalid: `#{sig}`" unless Silkey::Utils.signature?(sig)
+        raise 'empty user signature timestamp' if Silkey::Utils.empty?(timestamp)
+
+        self.user_signature = sig
+        self.user_signature_timestamp = timestamp
+        self
+      end
+
+      def set_silkey_signature(sig, timestamp)
+        raise "silkey signature invalid: `#{sig}`" unless Silkey::Utils.signature?(sig)
+        raise 'empty silkey signature timestamp' if Silkey::Utils.empty?(timestamp)
+
+        self.silkey_signature = sig
+        self.silkey_signature_timestamp = timestamp
+        self
+      end
+
+      # rubocop:enable Naming/AccessorMethodName
+
+      ##
+      #  Creates message that's need to be sign by user
+      def message_to_sign_by_user
+        if !Silkey::Utils.empty?(address) && Silkey::Utils.empty?(user_signature_timestamp)
+          self.user_signature_timestamp = Silkey::Utils.current_timestamp
+        end
+
+        str1_hex = 'address'.unpack('H*')[0]
+        adr_hex = Silkey::Utils.remove0x(address).downcase
+
+        str2_hex = [
+          'refId', ref_id.to_s,
+          'scope', scope,
+          'userSignatureTimestamp'
+        ].map { |str| str.to_s.unpack('H*') }.join('')
+
+        str_hex = "#{str1_hex}#{adr_hex}#{str2_hex}"
+
+        return str_hex if Silkey::Utils.empty?(user_signature_timestamp)
+
+        "#{str_hex}#{Silkey::Utils.int_to_hex(user_signature_timestamp.to_s)}"
+      end
+
+      def message_to_sign_by_silkey
+        return '' if Silkey::Utils.empty?(email)
+
+        if Silkey::Utils.empty?(silkey_signature_timestamp)
+          self.silkey_signature_timestamp = Silkey::Utils.current_timestamp
+        end
+
+        str_hex = [
+          'email', email,
+          'silkeySignatureTimestamp'
+        ].map { |str| str.to_s.unpack('H*') }.join('')
+
+        "#{str_hex}#{Silkey::Utils.int_to_hex(silkey_signature_timestamp.to_s)}"
+      end
+
+      def validate
+        raise "address is invalid: #{address}" unless Silkey::Utils.ethereum_address?(address)
+
+        unless Silkey::Utils.signature?(user_signature)
+          raise "user_signature is invalid: #{user_signature}"
+        end
+
+        raise 'user_signature_timestamp is empty' if Silkey::Utils.empty?(user_signature_timestamp)
+
+        return self if Silkey::Utils.empty?(scope) || scope == 'id'
+
+        validate_scope_email
+      end
+
+      def import(hash)
+        hash.each do |k, v|
+          var = k.to_s.underscore
+
+          if k == 'scope'
+            set_scope(v)
+          else
+            self.instance_variable_set("@#{var}", v)
+          end
+        end
+
+        self
+      end
+
+      private
+
+      def validate_scope_email
+        raise 'email is empty' if Silkey::Utils.empty?(email)
+
+        unless Silkey::Utils.signature?(silkey_signature)
+          raise "silkey_signature is invalid: #{silkey_signature}"
+        end
+
+        if Silkey::Utils.empty?(silkey_signature_timestamp)
+          raise 'silkey_signature_timestamp is empty'
+        end
+
+        self
+      end
+    end
+  end
+end