mixin_bot 1.4.0 → 2.0.0

data/lib/mixin_bot/cli.rb

@@ -5,86 +5,162 @@ require 'cli/ui'
 require 'thor'
 require 'yaml'
 require 'json'
-require_relative 'cli/api'
-require_relative 'cli/node'
-require_relative 'cli/utils'
+
+require_relative 'cli/base'
+require_relative 'cli/errors'
+require_relative 'cli/output'
+require_relative 'cli/schema'
 
 module MixinBot
   class CLI < Thor
-    # https://github.com/Shopify/cli-ui
+    include CLIHelpers
+    include CLIOutput
+
     UI = ::CLI::UI
 
     class_option :apihost, type: :string, aliases: '-a', default: 'api.mixin.one', desc: 'Specify mixin api host'
-    class_option :pretty, type: :boolean, aliases: '-r', default: true, desc: 'Print output in pretty'
+    class_option :output, type: :string, aliases: '-o', enum: CLIOutput::OUTPUT_FORMATS,
+                          desc: 'Output format: pretty, json, yaml (default: pretty in TTY, json when piped)'
+    class_option :pretty, type: :boolean, aliases: '-r', default: true,
+                          desc: 'Pretty-print output (alias for --output pretty when set false → json)'
 
     attr_reader :keystore, :api_instance
 
-    def initialize(*args)
-      super
+    desc 'version', 'Display MixinBot version'
+    def version
+      with_command_name('version') do
+        emit_success({ 'version' => MixinBot::VERSION }, command: 'version')
+      end
+    end
+
+    def self.exit_on_failure?
+      true
+    end
+
+    private
+
+    def setup_api_instance!
+      MixinBot.config.api_host = options[:apihost] if options[:apihost].present?
+
       if options[:keystore].blank?
         @api_instance = MixinBot::API.new
-        return
+        return @api_instance
       end
 
-      keystore =
-        if File.file? options[:keystore]
-          File.read options[:keystore]
+      raw =
+        if File.file?(options[:keystore])
+          File.read(options[:keystore])
         else
           options[:keystore]
         end
 
       @keystore =
         begin
-          JSON.parse keystore
+          JSON.parse(raw)
         rescue JSON::ParserError
-          log UI.fmt(
-            format(
-              '{{x}} falied to parse keystore.json: %<keystore>s',
-              keystore: options[:keystore]
-            )
+          abort_with_error(
+            format('failed to parse keystore JSON: %<path>s', path: options[:keystore]),
+            kind: :invalid_args,
+            hint: 'mixinbot call me -k keystore.json'
           )
         end
 
-      return unless @keystore
+      @api_instance = build_api_from_keystore(@keystore)
+    rescue StandardError => e
+      abort_with_error(
+        format('failed to initialize API (check keystore): %<error>s', error: e.message),
+        kind: CLIErrors.kind_for_exception(e),
+        exception: e
+      )
+    end
 
-      MixinBot.config.api_host = options[:apihost]
-      @api_instance ||=
-        begin
-          MixinBot::API.new(
-            app_id: @keystore['app_id'] || @keystore['client_id'],
-            session_id: @keystore['session_id'],
-            server_public_key: @keystore['server_public_key'] || @keystore['pin_token'],
-            session_private_key: @keystore['session_private_key'] || @keystore['private_key']
-          )
-        rescue StandardError => e
-          log UI.fmt '{{x}}: Failed to initialize api, maybe your keystore is incorrect: %<error>s', error: e.message
-        end
+    def build_api_from_keystore(store)
+      MixinBot::API.new(
+        app_id: store['app_id'] || store['client_id'],
+        session_id: store['session_id'],
+        server_public_key: store['server_public_key'] || store['pin_token'],
+        session_private_key: store['session_private_key'] || store['private_key'],
+        spend_key: store['spend_key'],
+        client_secret: store['client_secret'],
+        pin: store['pin']
+      )
     end
 
-    # desc 'node', 'mixin node commands helper'
-    # subcommand 'node', MixinBot::NodeCLI
+    def parse_json_data(json_string, label: 'data')
+      return {} if json_string.blank?
 
-    desc 'version', 'Distay MixinBot version'
-    def version
-      log MixinBot::VERSION
-    end
+      parsed = JSON.parse(json_string)
+      abort_with_error("#{label} must be a JSON object", kind: :invalid_args) unless parsed.is_a?(Hash)
 
-    def self.exit_on_failure?
-      true
+      parsed.transform_keys(&:to_sym)
+    rescue JSON::ParserError => e
+      abort_with_error("invalid JSON for #{label}: #{e.message}", kind: :invalid_args)
     end
 
-    private
+    def invoke_api(method_name, kwargs: {}, positional: [])
+      sym = method_name.to_sym
+      unless CLIHelpers.api_method_callable?(sym)
+        abort_with_error(
+          format('unknown or unsupported API method: %<method>s (run `mixinbot list`)', method: method_name),
+          kind: :unsupported,
+          hint: 'mixinbot list'
+        )
+      end
 
-    def log(obj)
-      if options[:pretty]
-        if obj.is_a? String
-          puts obj
-        else
-          ap obj
-        end
-      else
-        puts obj.inspect
+      if CLIHelpers::INTERACTIVE_API_METHODS.include?(sym)
+        abort_with_error(
+          format('%<method>s is interactive and not supported from the CLI', method: method_name),
+          kind: :unsupported,
+          hint: 'Use the Ruby API for Blaze WebSocket (see examples/blaze.rb)'
+        )
       end
+
+      api_instance.public_send(sym, *positional, **kwargs)
+    rescue ::ArgumentError => e
+      abort_with_error(
+        format('invalid arguments for %<method>s: %<error>s', method: method_name, error: e.message),
+        kind: :invalid_args,
+        hint: format('mixinbot list %<method>s', method: method_name)
+      )
+    rescue MixinBot::Error => e
+      abort_with_error(e.message, exception: e)
+    end
+
+    def invoke_utils(method_name, kwargs: {}, positional: [])
+      sym = method_name.to_sym
+      unless CLIHelpers.utils_callable_methods.include?(sym)
+        abort_with_error(
+          format('unknown utils method: %<method>s', method: method_name),
+          kind: :unsupported,
+          hint: 'mixinbot utils list'
+        )
+      end
+
+      MixinBot.utils.public_send(sym, *positional, **kwargs)
+    rescue ::ArgumentError => e
+      abort_with_error(
+        format('invalid arguments for utils.%<method>s: %<error>s', method: method_name, error: e.message),
+        kind: :invalid_args
+      )
+    end
+
+    def warn_deprecated(message)
+      emit_info("warning: #{message}")
+    end
+  end
+end
+
+require_relative 'cli/call'
+require_relative 'cli/api'
+require_relative 'cli/node'
+require_relative 'cli/utils'
+require_relative 'cli/schema_command'
+
+module MixinBot
+  class CLI
+    if system('which mixin > /dev/null 2>&1')
+      desc 'node SUBCOMMAND', 'Experimental mixin node CLI helpers (requires `mixin` binary)'
+      subcommand 'node', NodeCLI
     end
   end
 end

data/lib/mixin_bot/client/error_mapper.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module MixinBot
+  class Client
+    ##
+    # Maps Mixin API +error+ objects to Ruby exceptions.
+    #
+    module ErrorMapper
+      module_function
+
+      def raise_for!(verb:, path:, body:, response:, result:)
+        err = result['error'] || {}
+        code = err['code']
+        desc = err['description']
+        req_id = response&.headers&.[]('X-Request-Id')
+        srv_time = response&.headers&.[]('X-Server-Time')
+        errmsg = "#{verb.upcase} | #{path} | #{body}, errcode: #{code}, errmsg: #{desc}, request_id: #{req_id}, server_time: #{srv_time}"
+
+        case code
+        when 401, 20_121
+          raise UnauthorizedError, errmsg
+        when 403, 20_116, 10_002, 429
+          raise ForbiddenError, errmsg
+        when 404
+          raise NotFoundError, errmsg
+        when 20_117
+          raise InsufficientBalanceError, errmsg
+        when 20_118, 20_119
+          raise PinError, errmsg
+        when 30_103
+          raise InsufficientPoolError, errmsg
+        when 10_404
+          raise UserNotFoundError, errmsg
+        else
+          raise ResponseError, errmsg
+        end
+      end
+    end
+  end
+end

data/lib/mixin_bot/client.rb

@@ -1,6 +1,11 @@
 # frozen_string_literal: true
 
+require_relative 'client/error_mapper'
+
 module MixinBot
+  ##
+  # HTTP client for making requests to the Mixin Network API.
+  #
   class Client
     SERVER_SCHEME = 'https'
 
@@ -16,88 +21,113 @@ module MixinBot
         }
       ) do |f|
         f.request :json
-        f.request :retry
+        f.request :retry, max: 2, interval: 0.5, interval_randomness: 0.5, backoff_factor: 2,
+                          exceptions: [Faraday::ConnectionFailed, Faraday::TimeoutError]
         f.response :json
         f.response :logger if config.debug
       end
     end
 
-    def get(path, *, **)
-      request(:get, path, *, **)
-    end
+    ##
+    # GET request. Remaining keyword arguments are treated as query-string parameters.
+    #
+    # @return [MixinBot::Models::ApiEnvelope]
+    #
+    def get(path, **kwargs)
+      access_token = kwargs.delete(:access_token)
+      exp_in = kwargs.delete(:exp_in) || 600
+      scp = kwargs.delete(:scp) || 'FULL'
 
-    def post(path, *, **)
-      request(:post, path, *, **)
-    end
+      kwargs.compact!
+      body = ''
+      full_path = kwargs.empty? ? path : "#{path}?#{URI.encode_www_form(kwargs.sort_by { |k, _| k.to_s })}"
 
-    private
+      token = access_token.presence || sign_token('GET', full_path, body, exp_in:, scp:)
+      response = @conn.get(full_path, nil, authorization_headers(token))
+      parse_response!(verb: 'GET', path: full_path, body:, response:)
+    end
 
-    def request(verb, path, *args, **kwargs)
-      access_token = kwargs.delete :access_token
+    ##
+    # POST with a Hash body (+**kwargs+ merged into JSON object) or an Array body (+*args+).
+    #
+    # @return [MixinBot::Models::ApiEnvelope]
+    #
+    def post(path, *args, **kwargs)
+      access_token = kwargs.delete(:access_token)
       exp_in = kwargs.delete(:exp_in) || 600
       scp = kwargs.delete(:scp) || 'FULL'
 
-      kwargs.compact!
       body =
-        if verb == :post
-          if args.present?
-            args.to_json
-          else
-            kwargs.to_json
-          end
+        if args.present?
+          args.to_json
         else
-          ''
+          kwargs.compact.to_json
         end
 
-      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
+      token = access_token.presence || sign_token('POST', path, body, exp_in:, scp:)
+      response = @conn.post(path, body, authorization_headers(token))
+      parse_response!(verb: 'POST', path:, body:, response:)
+    end
 
-      result = response.body
+    ##
+    # Explicit query-string GET (preferred for new code).
+    #
+    def fetch_get(path, query: nil, access_token: nil, exp_in: 600, scp: 'FULL')
+      q = (query || {}).dup
+      q.compact!
+      body = ''
+      full_path = q.empty? ? path : "#{path}?#{URI.encode_www_form(q.sort_by { |k, _| k.to_s })}"
+      token = access_token.presence || sign_token('GET', full_path, body, exp_in:, scp:)
+      response = @conn.get(full_path, nil, authorization_headers(token))
+      parse_response!(verb: 'GET', path: full_path, body:, response:)
+    end
 
-      if result['error'].blank?
-        result.merge! result['data'] if result['data'].is_a? Hash
-        return result
-      end
+    ##
+    # Explicit JSON-object POST (preferred for new code).
+    #
+    def fetch_post(path, body:, access_token: nil, exp_in: 600, scp: 'FULL')
+      payload = body.is_a?(String) ? body : body.compact.to_json
+      token = access_token.presence || sign_token('POST', path, payload, exp_in:, scp:)
+      response = @conn.post(path, payload, authorization_headers(token))
+      parse_response!(verb: 'POST', path:, body: payload, response:)
+    end
 
-      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 20117
-        raise InsufficientBalanceError, errmsg
-      when 20118, 20119
-        raise PinError, errmsg
-      when 30103
-        raise InsufficientPoolError, errmsg
-      when 10404
-        raise UserNotFoundError, errmsg
-      else
-        raise ResponseError, errmsg
-      end
+    ##
+    # Explicit JSON-array POST (e.g. +/users/fetch+, +/safe/keys+).
+    #
+    def fetch_post_array(path, array_body, access_token: nil, exp_in: 600, scp: 'FULL')
+      payload = array_body.to_json
+      token = access_token.presence || sign_token('POST', path, payload, exp_in:, scp:)
+      response = @conn.post(path, payload, authorization_headers(token))
+      parse_response!(verb: 'POST', path:, body: payload, response:)
+    end
+
+    private
+
+    def authorization_headers(token)
+      return {} if token.blank?
+
+      { Authorization: format('Bearer %<access_token>s', access_token: token) }
+    end
+
+    def sign_token(method, uri, body, exp_in:, scp:)
+      MixinBot.utils.access_token(
+        method,
+        uri,
+        body,
+        exp_in:,
+        scp:,
+        app_id: config.app_id,
+        session_id: config.session_id,
+        private_key: config.session_private_key
+      )
+    end
+
+    def parse_response!(verb:, path:, body:, response:)
+      result = response.body
+      return MixinBot::Models::ApiEnvelope.new(result) if result['error'].blank?
+
+      ErrorMapper.raise_for!(verb:, path:, body:, response:, result:)
     end
   end
 end

data/lib/mixin_bot/computer.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require 'faraday'
+
+module MixinBot
+  # Mixin Computer API client (https://computer.mixin.one).
+  class Computer
+    BASE_URI = 'https://computer.mixin.one'
+    OPERATION_TYPE_ADD_USER = 1
+    OPERATION_TYPE_SYSTEM_CALL = 2
+    OPERATION_TYPE_USER_DEPOSIT = 3
+    SOLANA_CHAIN_ID = '64692c23-8971-4cf4-84a7-4dd1271dd887'
+
+    class << self
+      def connection
+        @connection ||= Faraday.new(url: BASE_URI) do |f|
+          f.request :json
+          f.response :json
+          f.adapter Faraday.default_adapter
+        end
+      end
+
+      def request(method, path, body = nil)
+        response =
+          case method.to_s.upcase
+          when 'GET'
+            connection.get(path)
+          when 'POST'
+            connection.post(path, body)
+          else
+            raise ArgumentError, "unsupported method #{method}"
+          end
+        raise MixinBot::ServerError, "computer HTTP #{response.status}" if response.status >= 500
+
+        response.body
+      end
+
+      def info
+        request 'GET', '/'
+      end
+      alias get_computer_info info
+
+      def user(addr)
+        request 'GET', "/users/#{addr}"
+      end
+      alias get_computer_user user
+
+      def deployed_assets
+        request 'GET', '/deployed_assets'
+      end
+      alias get_computer_deployed_assets deployed_assets
+
+      def system_call(id)
+        request 'GET', "/system_calls/#{id}"
+      end
+      alias get_computer_system_call system_call
+
+      def deploy_external_assets(assets)
+        assets = Array(assets)
+        raise ArgumentError, "cannot deploy asset from Solana: #{SOLANA_CHAIN_ID}" if assets.include?(SOLANA_CHAIN_ID)
+
+        request 'POST', '/deployed_assets', assets
+      end
+      alias computer_deploy_external_asset deploy_external_assets
+
+      def lock_nonce_account(mix)
+        request 'POST', '/nonce_accounts', { mix: }
+      end
+      alias lock_computer_nonce_account lock_nonce_account
+
+      def fee_on_xin_from_sol(sol_amount)
+        request 'POST', '/fee', { sol_amount: sol_amount.to_s }
+      end
+      alias get_fee_on_xin_based_on_sol fee_on_xin_from_sol
+
+      def register_computer(api)
+        info_data = info
+        mix = MixinBot::MixAddress.from_members(members: [api.config.app_id], threshold: 1).address
+        memo = encode_mtg_extra(
+          info_data.dig('members', 'app_id'),
+          encode_operation_memo(OPERATION_TYPE_ADD_USER, mix)
+        )
+        trace = MixinBot.utils.unique_object_id(mix, 'computer_register')
+        api.create_safe_transfer(
+          members: info_data.dig('members', 'members'),
+          threshold: info_data.dig('members', 'threshold'),
+          asset_id: info_data.dig('params', 'operation', 'asset'),
+          amount: info_data.dig('params', 'operation', 'price'),
+          trace_id: trace,
+          memo:
+        )
+      end
+
+      def user_id_to_bytes(id)
+        n = Integer(id, 10)
+        raise ArgumentError, "invalid user id: #{id}" if n.negative?
+
+        [n].pack('Q>')
+      end
+      alias computer_user_id_to_bytes user_id_to_bytes
+
+      def build_system_call_extra(uid, cid, skip_process: false, fid: nil)
+        extra = user_id_to_bytes(uid)
+        extra += MixinBot::UUID.new(hex: cid).packed
+        extra += [skip_process ? 1 : 0].pack('C')
+        extra += MixinBot::UUID.new(hex: fid).packed if fid.present?
+        extra
+      end
+
+      def encode_operation_memo(operation, extra = +'')
+        [operation].pack('C') + extra.to_s
+      end
+
+      def encode_mtg_extra(app_id, extra)
+        data = MixinBot::UUID.new(hex: app_id).packed + extra.to_s
+        Base64.urlsafe_encode64(data, padding: false)
+      end
+
+      def decode_computer_extra_base64(extra)
+        data = Base64.urlsafe_decode64(extra)
+        return ['', nil] if data.length < 16
+
+        app_id = MixinBot::UUID.new(raw: data[0, 16]).unpacked
+        [app_id, data[16..]]
+      end
+
+      def solana_asset_id_for(deployed)
+        MixinBot.utils.unique_object_id(SOLANA_CHAIN_ID, deployed['address'])
+      end
+    end
+  end
+end