mixin_bot 0.12.0 → 1.0.0

data/lib/mixin_bot/client.rb

@@ -4,153 +4,102 @@ module MixinBot
   class Client
     SERVER_SCHEME = 'https'
 
-    attr_reader :host
-
-    def initialize(host = 'api.mixin.one')
-      @host = host
+    attr_reader :config, :conn
+
+    def initialize(config)
+      @config = config || MixinBot.config
+      @conn = Faraday.new(
+        url: "#{SERVER_SCHEME}://#{config.api_host}",
+        headers: {
+          'Content-Type' => 'application/json',
+          'User-Agent' => "mixin_bot/#{MixinBot::VERSION}"
+        }
+      ) do |f|
+        f.request :json
+        f.request :retry
+        f.response :json
+        f.response :logger if config.debug
+      end
     end
 
-    def get(path, options = {})
-      request(:get, path, options)
+    def get(path, *, **)
+      request(:get, path, *, **)
     end
 
-    def post(path, options = {})
-      request(:post, path, options)
+    def post(path, *, **)
+      request(:post, path, *, **)
     end
 
     private
 
-    def request(verb, path, options = {})
-      uri = uri_for path
-
-      options[:headers] ||= {}
-      options[:headers]['Content-Type'] ||= 'application/json'
-
-      begin
-        response = HTTP.timeout(connect: 5, write: 5, read: 5).request(verb, uri, options)
-      rescue HTTP::Error => e
-        raise HttpError, e.message
-      end
-
-      raise RequestError, response.to_s unless response.status.success?
-
-      parse_response(response) do |parse_as, result|
-        case parse_as
-        when :json
-          if result['error'].nil?
-            result.merge! result['data'] if result['data'].is_a? Hash
-            break result
-          end
+    def request(verb, path, *args, **kwargs)
+      access_token = kwargs.delete :access_token
+      exp_in = kwargs.delete(:exp_in) || 600
+      scp = kwargs.delete(:scp) || 'FULL'
 
-          errmsg = "errcode: #{result['error']['code']}, errmsg: #{result['error']['description']}, request_id: #{response&.[]('X-Request-Id')}, server_time: #{response&.[]('X-Server-Time')}'"
-
-          # status code description
-          # 202	400	The request body can’t be pasred as valid data.
-          # 202	401	Unauthorized.
-          # 202	403	Forbidden.
-          # 202	404	The endpoint is not found.
-          # 202	429	Too Many Requests.
-          # 202	10006	App update required.
-          # 202	20116	The group chat is full.
-          # 500	500	Internal Server Error.
-          # 500	7000	Blaze server error.
-          # 500	7001	The blaze operation timeout.
-          # 202	10002	Illegal request paramters.
-          # 202	20117	Insufficient balance。
-          # 202	20118	PIN format error.
-          # 202	20119	PIN error.
-          # 202	20120	Transfer amount is too small.
-          # 202	20121	Authorization code has expired.
-          # 202	20124	Insufficient withdrawal fee.
-          # 202	20125	The transfer has been paid by someone else.
-          # 202	20127	The withdrawal amount is too small.
-          # 202	20131	Withdrawal Memo format error.
-          # 500	30100	The current asset's public chain synchronization error.
-          # 500	30101	Wrong private key.
-          # 500	30102	Wrong withdrawal address.
-          # 500	30103	Insufficient pool.
-          # 500	7000	WebSocket server error.
-          # 500	7001	WebSocket operation timeout.
-          case result['error']['code']
-          when 401, 20121
-            raise UnauthorizedError, errmsg
-          when 403, 20116, 10002, 429
-            raise ForbiddenError, errmsg
-          when 404
-            raise NotFoundError, errmsg
-          when 400, 10006, 20133, 500, 7000, 7001
-            raise ResponseError, errmsg
-          when 20117
-            raise InsufficientBalanceError, errmsg
-          when 20118, 20119
-            raise PinError, errmsg
-          when 30103
-            raise InsufficientPoolError, errmsg
+      kwargs.compact!
+      body =
+        if verb == :post
+          if args.present?
+            args.to_json
           else
-            raise ResponseError, errmsg
+            kwargs.to_json
           end
         else
-          result
+          ''
         end
-      end
-    end
-
-    def uri_for(path)
-      uri_options = {
-        scheme: SERVER_SCHEME,
-        host: host,
-        path: path
-      }
-      Addressable::URI.new(uri_options)
-    end
 
-    def parse_response(response)
-      content_type = response.headers[:content_type]
-      parse_as = {
-        %r{^application/json} => :json,
-        %r{^image/.*} => :file,
-        %r{^text/html} => :xml,
-        %r{^text/plain} => :plain
-      }.each_with_object([]) { |match, memo| memo << match[1] if content_type =~ match[0] }.first || :plain
+      path = "#{path}?#{URI.encode_www_form(kwargs.sort_by { |k, _v| k })}" if verb == :get && kwargs.present?
+      access_token ||=
+        MixinBot.utils.access_token(
+          verb.to_s.upcase,
+          path,
+          body,
+          exp_in:,
+          scp:,
+          app_id: config.app_id,
+          session_id: config.session_id,
+          private_key: config.session_private_key
+        )
+      authorization = format('Bearer %<access_token>s', access_token:)
+
+      response =
+        case verb
+        when :get
+          @conn.get path, nil, { Authorization: authorization }
+        when :post
+          @conn.post path, body, { Authorization: authorization }
+        end
 
-      if parse_as == :plain
-        result = JSON.parse(response&.body&.to_s)
-        result && yield(:json, result)
+      result = response.body
 
-        yield(:plain, response.body)
+      if result['error'].blank?
+        result.merge! result['data'] if result['data'].is_a? Hash
+        return result
       end
 
-      case parse_as
-      when :json
-        result = JSON.parse(response.body.to_s)
-      when :file
-        extension =
-          if response.headers[:content_type] =~ %r{^image/.*}
-            {
-              'image/gif': '.gif',
-              'image/jpeg': '.jpg',
-              'image/png': '.png'
-            }[response.headers['content-type']]
-          else
-            ''
-          end
-
-        begin
-          file = Tempfile.new(['mixin-file-', extension])
-          file.binmode
-          file.write(response.body)
-        ensure
-          file&.close
-        end
-
-        result = file
-      when :xml
-        result = Hash.from_xml(response.body.to_s)
+      errmsg = "#{verb.upcase}|#{path}|#{body}, errcode: #{result['error']['code']}, errmsg: #{result['error']['description']}, request_id: #{response&.[]('X-Request-Id')}, server_time: #{response&.[]('X-Server-Time')}'"
+
+      case result['error']['code']
+      when 401, 20121
+        raise UnauthorizedError, errmsg
+      when 403, 20116, 10002, 429
+        raise ForbiddenError, errmsg
+      when 404
+        raise NotFoundError, errmsg
+      when 400, 10006, 20133, 500, 7000, 7001
+        raise ResponseError, errmsg
+      when 20117
+        raise InsufficientBalanceError, errmsg
+      when 20118, 20119
+        raise PinError, errmsg
+      when 30103
+        raise InsufficientPoolError, errmsg
+      when 10404
+        raise UserNotFoundError, errmsg
       else
-        result = response.body
+        raise ResponseError, errmsg
       end
-
-      yield(parse_as, result)
     end
   end
 end

data/lib/mixin_bot/configuration.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module MixinBot
+  class Configuration
+    CONFIGURABLE_ATTRS = %i[
+      app_id
+      client_secret
+      session_id
+      session_private_key
+      server_public_key
+      spend_key
+      pin
+      api_host
+      blaze_host
+      session_private_key_curve25519
+      server_public_key_curve25519
+      debug
+    ].freeze
+    attr_accessor(*CONFIGURABLE_ATTRS)
+
+    def initialize(**kwargs)
+      @app_id = kwargs[:app_id] || kwargs[:client_id]
+      @client_secret = kwargs[:client_secret]
+      @session_id = kwargs[:session_id]
+      @api_host = kwargs[:api_host] || 'api.mixin.one'
+      @blaze_host = kwargs[:blaze_host] || 'blaze.mixin.one'
+      @debug = kwargs[:debug] || false
+
+      self.session_private_key = kwargs[:session_private_key] || kwargs[:private_key]
+      self.server_public_key = kwargs[:server_public_key] || kwargs[:pin_token]
+      self.spend_key = kwargs[:spend_key]
+      self.pin = kwargs[:pin] || spend_key
+    end
+
+    def valid?
+      %i[app_id session_id session_private_key server_public_key].all? do |attr|
+        send(attr).present?
+      end
+    end
+
+    def session_private_key=(key)
+      return if key.blank?
+
+      _private_key = decode_key key
+      @session_private_key =
+        if _private_key.size == 32
+          JOSE::JWA::Ed25519.keypair(_private_key).last
+        else
+          _private_key
+        end
+
+      @session_private_key_curve25519 = JOSE::JWA::Ed25519.sk_to_curve25519(@session_private_key) if @session_private_key.size == 64
+    end
+
+    def server_public_key=(key)
+      return if key.blank?
+
+      @server_public_key = decode_key key
+      # HEX encoded
+      @server_public_key_curve25519 =
+        if key.match?(/\A[\h]{32,}\z/i)
+          JOSE::JWA::Ed25519.pk_to_curve25519 @server_public_key
+        else
+          server_public_key
+        end
+    end
+
+    def spend_key=(key)
+      return if key.blank?
+
+      _private_key = decode_key key
+      @spend_key =
+        if _private_key.size == 32
+          JOSE::JWA::Ed25519.keypair(_private_key).last
+        else
+          _private_key
+        end
+    end
+
+    def pin=(key)
+      return if key.blank?
+
+      _private_key = decode_key key
+      @pin =
+        if _private_key.size == 32
+          JOSE::JWA::Ed25519.keypair(_private_key).last
+        else
+          _private_key
+        end
+    end
+
+    private
+
+    def decode_key(key)
+      MixinBot.utils.decode_key key
+    end
+  end
+end

data/lib/mixin_bot/nfo.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+module MixinBot
+  class Nfo
+    NFT_MEMO_PREFIX = 'NFO'
+    NFT_MEMO_VERSION = 0x00
+    NFT_MEMO_DEFAULT_CHAIN = '43d61dcd-e413-450d-80b8-101d5e903357'
+    NFT_MEMO_DEFAULT_CLASS = '3c8c161a18ae2c8b14fda1216fff7da88c419b5d'
+    NULL_UUID = '00000000-0000-0000-0000-000000000000'
+
+    attr_reader :prefix, :version, :raw
+    attr_accessor :mask, :chain, :nm_class, :collection, :token, :extra, :memo, :hex
+
+    def initialize(**kwargs)
+      @prefix = NFT_MEMO_PREFIX
+      @version = NFT_MEMO_VERSION
+      @mask = kwargs[:mask] || 0
+      @chain = kwargs[:chain] || NFT_MEMO_DEFAULT_CHAIN
+      @nm_class = kwargs[:nm_class] || NFT_MEMO_DEFAULT_CLASS
+      @collection = kwargs[:collection] || NULL_UUID
+      @token = kwargs[:token].presence&.to_i
+      @extra = kwargs[:extra]
+      @memo = kwargs[:memo]
+      @hex = kwargs[:hex]
+    end
+
+    def mint_memo
+      raise MixinBot::InvalidNfoFormatError, 'token is required' if token.blank?
+      raise MixinBot::InvalidNfoFormatError, 'extra must be 256-bit string' if extra.blank? || extra.size != 64
+
+      @collection = NULL_UUID if collection.blank?
+      @chain = NFT_MEMO_DEFAULT_CHAIN
+      @nm_class = NFT_MEMO_DEFAULT_CLASS
+      mark 0
+      encode
+
+      memo
+    end
+
+    def unique_token_id
+      bytes = []
+      bytes += MixinBot::UUID.new(hex: chain).packed.bytes
+      bytes += [nm_class].pack('H*').bytes
+      bytes += MixinBot::UUID.new(hex: collection).packed.bytes
+      bytes += MixinBot.utils.encode_int token
+
+      md5 = Digest::MD5.new
+      md5.update bytes.pack('c*')
+      digest = [md5.hexdigest].pack('H*').bytes
+
+      digest[6] = (digest[6] & 0x0f) | 0x30
+      digest[8] = (digest[8] & 0x3f) | 0x80
+
+      hex = digest.pack('c*').unpack1('H*')
+
+      MixinBot::UUID.new(hex:).unpacked
+    end
+
+    def mark(*indexes)
+      indexes.map do |index|
+        raise ArgumentError, "invalid NFO memo index #{index}" if index >= 64 || index.negative?
+
+        @mask = mask ^ (1 << index)
+      end
+    end
+
+    def encode
+      bytes = []
+
+      bytes += prefix.bytes
+      bytes += [version]
+
+      if mask.zero?
+        bytes += [0]
+      else
+        bytes += [1]
+        bytes += MixinBot.utils.encode_uint_64 mask
+        bytes += MixinBot::UUID.new(hex: chain).packed.bytes
+
+        class_bytes = [nm_class].pack('H*').bytes
+        bytes += MixinBot.utils.encode_int class_bytes.size
+        bytes += class_bytes
+
+        collection_bytes = collection.split('-').pack('H* H* H* H* H*').bytes
+        bytes += MixinBot.utils.encode_int collection_bytes.size
+        bytes += collection_bytes
+
+        # token_bytes = memo[:token].split('-').pack('H* H* H* H* H*').bytes
+        token_bytes = MixinBot.utils.encode_int token
+        bytes += MixinBot.utils.encode_int token_bytes.size
+        bytes += token_bytes
+      end
+
+      extra_bytes = [extra].pack('H*').bytes
+      bytes += MixinBot.utils.encode_int extra_bytes.size
+      bytes += extra_bytes
+
+      @raw = bytes.pack('C*')
+      @hex = raw.unpack1('H*')
+      @memo = Base64.urlsafe_encode64 raw, padding: false
+
+      self
+    end
+
+    def decode
+      @raw =
+        if memo.present?
+          Base64.urlsafe_decode64 memo
+        elsif hex.present?
+          [hex].pack('H*')
+        else
+          raise InvalidNfoFormatError, 'memo or hex is required'
+        end
+
+      @hex = raw.unpack1('H*') if hex.blank?
+      @memo = Base64.urlsafe_encode64 raw, padding: false if memo.blank?
+
+      decode_bytes
+      self
+    end
+
+    def decode_bytes
+      bytes = raw.bytes
+
+      _prefix = bytes.shift(3).pack('C*')
+      raise MixinBot::InvalidNfoFormatError, "NFO prefix #{_prefix}" if _prefix != prefix
+
+      _version = bytes.shift
+      raise MixinBot::InvalidNfoFormatError, "NFO version #{prefix}" if _version != version
+
+      hint = bytes.shift
+      if hint == 1
+        @mask = bytes.shift(8).reverse.pack('C*').unpack1('Q*')
+
+        @chain = MixinBot::UUID.new(hex: bytes.shift(16).pack('C*').unpack1('H*')).unpacked
+
+        class_length = bytes.shift
+        @nm_class = bytes.shift(class_length).pack('C*').unpack1('H*')
+
+        collection_length = bytes.shift
+        @collection = MixinBot::UUID.new(hex: bytes.shift(collection_length).pack('C*').unpack1('H*')).unpacked
+
+        token_length = bytes.shift
+        @token = MixinBot.utils.decode_int bytes.shift(token_length)
+      end
+
+      extra_length = bytes.shift
+      @extra = bytes.shift(extra_length).pack('C*').unpack1('H*')
+
+      self
+    end
+
+    def to_h
+      hash = {
+        prefix:,
+        version:,
+        mask:,
+        chain:,
+        class: nm_class,
+        collection:,
+        token:,
+        extra:,
+        memo:,
+        hex:
+      }
+
+      hash.each do |key, value|
+        hash.delete key if value.blank?
+      end
+
+      hash
+    end
+  end
+end