mixin_bot 0.12.1 → 1.0.0

data/lib/mixin_bot/api.rb

@@ -1,62 +1,86 @@
 # frozen_string_literal: true
 
-require_relative './client'
-require_relative './api/app'
-require_relative './api/asset'
-require_relative './api/attachment'
-require_relative './api/auth'
-require_relative './api/blaze'
-require_relative './api/collectible'
-require_relative './api/conversation'
-require_relative './api/encrypted_message'
-require_relative './api/me'
-require_relative './api/message'
-require_relative './api/multisig'
-require_relative './api/payment'
-require_relative './api/pin'
-require_relative './api/rpc'
-require_relative './api/snapshot'
-require_relative './api/transaction'
-require_relative './api/transfer'
-require_relative './api/user'
-require_relative './api/withdraw'
+require_relative 'client'
+require_relative 'configuration'
+require_relative 'api/address'
+require_relative 'api/app'
+require_relative 'api/asset'
+require_relative 'api/attachment'
+require_relative 'api/auth'
+require_relative 'api/blaze'
+require_relative 'api/collectible'
+require_relative 'api/conversation'
+require_relative 'api/encrypted_message'
+require_relative 'api/legacy_multisig'
+require_relative 'api/legacy_output'
+require_relative 'api/legacy_payment'
+require_relative 'api/legacy_snapshot'
+require_relative 'api/legacy_transaction'
+require_relative 'api/legacy_transfer'
+require_relative 'api/me'
+require_relative 'api/message'
+require_relative 'api/multisig'
+require_relative 'api/output'
+require_relative 'api/payment'
+require_relative 'api/pin'
+require_relative 'api/rpc'
+require_relative 'api/snapshot'
+require_relative 'api/tip'
+require_relative 'api/transaction'
+require_relative 'api/transfer'
+require_relative 'api/user'
+require_relative 'api/withdraw'
 
 module MixinBot
   class API
-    attr_reader :client_id, :client_secret, :session_id, :pin_token, :private_key, :client, :blaze_host, :key_type
-
-    def initialize(options = {})
-      @client_id = options[:client_id] || MixinBot.client_id
-      @client_secret = options[:client_secret] || MixinBot.client_secret
-      @session_id = options[:session_id] || MixinBot.session_id
-      @client = Client.new(MixinBot.api_host || 'api.mixin.one')
-      @blaze_host = MixinBot.blaze_host || 'blaze.mixin.one'
-      @pin_token =
-        begin
-          Base64.urlsafe_decode64 options[:pin_token] || MixinBot.pin_token
-        rescue StandardError
-          ''
+    attr_reader :config, :client
+
+    def initialize(**kwargs)
+      @config =
+        if kwargs.present?
+          MixinBot::Configuration.new(**kwargs)
+        else
+          MixinBot.config
         end
-      _private_key = options[:private_key] || MixinBot.private_key
-      if /^-----BEGIN RSA PRIVATE KEY-----/.match? _private_key
-        @private_key = _private_key.gsub('\\r\\n', "\n").gsub("\r\n", "\n")
-        @key_type = :rsa
-      else
-        @private_key = Base64.urlsafe_decode64 _private_key
-        @key_type = :ed25519
-      end
+
+      @client = Client.new(@config)
+    end
+
+    def utils
+      MixinBot::Utils
+    end
+
+    def client_id
+      config.app_id
     end
 
-    def sign_raw_transaction(tx)
-      MixinBot::Utils.sign_raw_transaction tx
+    def access_token(method, uri, body, **kwargs)
+      utils.access_token(
+        method,
+        uri,
+        body,
+        exp_in: kwargs.delete(:exp_in) || 600,
+        scp: kwargs.delete(:scp) || 'FULL',
+        app_id: config.app_id,
+        session_id: config.session_id,
+        private_key: config.session_private_key
+      )
+    end
+
+    def encode_raw_transaction(tx)
+      utils.encode_raw_transaction tx
     end
 
     def decode_raw_transaction(raw)
-      MixinBot::Utils.decode_raw_transaction raw
+      utils.decode_raw_transaction raw
+    end
+
+    def generate_trace_from_hash(hash, output_index = 0)
+      utils.generate_trace_from_hash hash, output_index
     end
 
     # Use a mixin software to implement transaction build
-    def sign_raw_transaction_native(json)
+    def encode_raw_transaction_native(json)
       ensure_mixin_command_exist
       command = format("mixin signrawtransaction --raw '%<arg>s'", arg: json)
 
@@ -77,6 +101,7 @@ module MixinBot
       JSON.parse output.chomp
     end
 
+    include MixinBot::API::Address
     include MixinBot::API::App
     include MixinBot::API::Asset
     include MixinBot::API::Attachment
@@ -85,13 +110,21 @@ module MixinBot
     include MixinBot::API::Collectible
     include MixinBot::API::Conversation
     include MixinBot::API::EncryptedMessage
+    include MixinBot::API::LegacyMultisig
+    include MixinBot::API::LegacyOutput
+    include MixinBot::API::LegacyPayment
+    include MixinBot::API::LegacySnapshot
+    include MixinBot::API::LegacyTransaction
+    include MixinBot::API::LegacyTransfer
     include MixinBot::API::Me
     include MixinBot::API::Message
     include MixinBot::API::Multisig
+    include MixinBot::API::Output
     include MixinBot::API::Payment
     include MixinBot::API::Pin
     include MixinBot::API::Rpc
     include MixinBot::API::Snapshot
+    include MixinBot::API::Tip
     include MixinBot::API::Transaction
     include MixinBot::API::Transfer
     include MixinBot::API::User

data/lib/mixin_bot/cli/api.rb

@@ -34,16 +34,16 @@ module MixinBot
         end
 
       access_token = options[:accesstoken] || api_instance.access_token(options[:method].upcase, path, payload.blank? ? '' : payload.to_json)
-      authorization = format('Bearer %<access_token>s', access_token: access_token)
+      authorization = format('Bearer %<access_token>s', access_token:)
       res = {}
 
       CLI::UI::Spinner.spin("#{options[:method]} #{path}, payload: #{payload}") do |_spinner|
         res =
           case options[:method].downcase.to_sym
           when :post
-            api_instance.client.post(path, headers: { 'Authorization': authorization }, json: payload)
+            api_instance.client.post(path, headers: { Authorization: authorization }, json: payload)
           when :get
-            api_instance.client.get(path, headers: { 'Authorization': authorization })
+            api_instance.client.get(path, headers: { Authorization: authorization })
           end
       end
 
@@ -52,19 +52,163 @@ module MixinBot
 
     desc 'authcode', 'code to authorize other mixin account'
     option :keystore, type: :string, aliases: '-k', required: true, desc: 'keystore or keystore.json file path'
-    option :client_id, type: :string, required: true, aliases: '-c', desc: 'client_id of bot to authorize'
+    option :app_id, type: :string, required: true, aliases: '-c', desc: 'app_id of bot to authorize'
     option :scope, type: :array, default: ['PROFILE:READ'], aliases: '-s', desc: 'scope to authorize'
     def authcode
       res = {}
       CLI::UI::Spinner.spin('POST /oauth/authorize') do |_spinner|
         res =
           api_instance.authorize_code(
-            user_id: options[:client_id],
+            user_id: options[:app_id],
             scope: options[:scope],
             pin: keystore['pin']
           )
       end
       log res['data']
     end
+
+    desc 'updatetip PIN', 'update TIP pin'
+    option :keystore, type: :string, aliases: '-k', required: true, desc: 'keystore or keystore.json file path'
+    def updatetip(pin)
+      profile = api_instance.me
+      log UI.fmt "{{v}} #{profile['full_name']}, TIP counter: #{profile['tip_counter']}"
+
+      counter = profile['tip_counter']
+      key = api_instance.prepare_tip_key counter
+      log UI.fmt "{{v}} Generated key: #{key[:private_key]}"
+
+      res = api_instance.update_pin old_pin: pin.to_s, pin: key[:public_key]
+
+      log({
+            pin: key[:private_key],
+            tip_key_base64: res['tip_key_base64']
+          })
+    rescue StandardError => e
+      log UI.fmt "{{x}} #{e.inspect}"
+    end
+
+    desc 'verifypin PIN', 'verify pin'
+    option :keystore, type: :string, aliases: '-k', required: true, desc: 'keystore or keystore.json file path'
+    def verifypin(pin)
+      res = api_instance.verify_pin pin.to_s
+
+      log res
+    rescue StandardError => e
+      log UI.fmt "{{x}} #{e.inspect}"
+    end
+
+    desc 'transfer USER_ID', 'transfer asset to USER_ID'
+    option :asset, type: :string, required: true, desc: 'Asset ID'
+    option :amount, type: :numeric, required: true, desc: 'Amount'
+    option :memo, type: :string, required: false, desc: 'memo'
+    option :keystore, type: :string, aliases: '-k', required: true, desc: 'keystore or keystore.json file path'
+    def transfer(user_id)
+      res = {}
+
+      CLI::UI::Spinner.spin "Try to transfer #{options[:amount]} #{options[:asset]} to #{user_id}" do |_spinner|
+        res = api_instance.create_transfer(
+          keystore['pin'],
+          {
+            asset_id: options[:asset],
+            opponent_id: user_id,
+            amount: options[:amount],
+            memo: options[:memo]
+          }
+        )
+      end
+
+      return unless res['snapshot_id'].present?
+
+      log UI.fmt "{{v}} Finished: https://mixin.one/snapshots/#{res['snapshot_id']}"
+    end
+
+    desc 'saferegister', 'register SAFE network'
+    option :spend_key, type: :string, required: true, desc: 'spend_key'
+    option :keystore, type: :string, aliases: '-k', required: true, desc: 'keystore or keystore.json file path'
+    def saferegister
+      res = api_instance.safe_register options[:spend_key]
+      log res
+    end
+
+    desc 'pay', 'generate payment url'
+    option :members, type: :array, required: true, desc: 'Reveivers, maybe multisig'
+    option :threshold, type: :numeric, required: false, default: 1, desc: 'Threshold of multisig'
+    option :asset, type: :string, required: true, desc: 'Asset ID'
+    option :amount, type: :numeric, required: true, desc: 'Amount'
+    option :trace, type: :string, required: false, desc: 'Trace ID'
+    option :memo, type: :string, required: false, desc: 'memo'
+    def pay
+      url = api_instance.safe_pay_url(
+        members: options[:members],
+        threshold: options[:threshold],
+        asset_id: options[:asset],
+        amount: options[:amount],
+        trace_id: options[:trace],
+        memo: options[:memo]
+      )
+
+      log UI.fmt "{{v}} #{url}"
+    end
+
+    desc 'safetransfer USER_ID', 'transfer asset to USER_ID with SAFE network'
+    option :asset, type: :string, required: true, desc: 'Asset ID'
+    option :amount, type: :numeric, required: true, desc: 'Amount'
+    option :trace, type: :string, required: false, desc: 'Trace ID'
+    option :memo, type: :string, required: false, desc: 'memo'
+    option :keystore, type: :string, aliases: '-k', required: true, desc: 'keystore or keystore.json file path'
+    def safetransfer(user_id)
+      amount = options[:amount].to_d
+      asset = options[:asset]
+      memo = options[:memo] || ''
+
+      # step 1: select inputs
+      outputs = api_instance.safe_outputs(state: 'unspent', asset_id: asset, limit: 500)['data'].sort_by { |o| o['amount'].to_d }
+      balance = outputs.sum(&->(output) { output['amount'].to_d })
+
+      utxos = []
+      outputs.each do |output|
+        break if utxos.sum { |o| o['amount'].to_d } >= amount
+
+        utxos.shift if utxos.size >= 255
+        utxos << output
+      end
+
+      log UI.fmt "Step 1/7: {{v}} Found #{outputs.count} unspent outputs, balance: #{balance}, selected #{utxos.count} outputs"
+
+      # step 2: build transaction
+      tx = api_instance.build_safe_transaction(
+        utxos:,
+        receivers: [
+          members: [user_id],
+          threshold: 1,
+          amount:
+        ],
+        extra: memo
+      )
+      raw = MixinBot::Utils.encode_raw_transaction tx
+      log UI.fmt "Step 2/5: {{v}} Built raw: #{raw}"
+
+      # step 3: verify transaction
+      request_id = SecureRandom.uuid
+      request = api_instance.create_safe_transaction_request(request_id, raw)['data']
+      log UI.fmt "Step 3/5: {{v}} Verified transaction, request_id: #{request[0]['request_id']}"
+
+      # step 4: sign transaction
+      signed_raw = api_instance.sign_safe_transaction(
+        raw:,
+        utxos:,
+        request: request[0]
+      )
+      log UI.fmt "Step 4/5: {{v}} Signed transaction: #{signed_raw}"
+
+      # step 5: submit transaction
+      r = api_instance.send_safe_transaction(
+        request_id,
+        signed_raw
+      )
+      log UI.fmt "Step 5/5: {{v}} Submit transaction, hash: #{r['data'].first['transaction_hash']}"
+    rescue StandardError => e
+      log UI.fmt "{{x}} #{e.inspect}"
+    end
   end
 end

data/lib/mixin_bot/cli/utils.rb

@@ -11,17 +11,17 @@ module MixinBot
 
     desc 'unique UUIDS', 'generate unique UUID for two or more UUIDs'
     def unique(*uuids)
-      log MixinBot::Utils.unique_uuid(*uuids)
+      log MixinBot.utils.unique_uuid(*uuids)
     end
 
     desc 'generatetrace HASH', 'generate trace ID from Tx hash'
     def generatetrace(hash)
-      log MixinBot::Utils.generate_trace_from_hash(hash)
+      log MixinBot.utils.generate_trace_from_hash(hash)
     end
 
     desc 'decodetx TRANSACTION', 'decode raw transaction'
     def decodetx(transaction)
-      log MixinBot::Utils.decode_raw_transaction(transaction)
+      log MixinBot.utils.decode_raw_transaction(transaction)
     end
 
     desc 'nftmemo', 'memo for mint NFT'
@@ -29,7 +29,17 @@ module MixinBot
     option :token, type: :numeric, required: true, aliases: '-t', desc: 'Token ID, Integer'
     option :hash, type: :string, required: true, aliases: '-h', desc: 'Hash of NFT metadata, 256-bit string'
     def nftmemo
-      log MixinBot::Utils.nft(options[:collection], options[:token], options[:hash])
+      log MixinBot.utils.nft(options[:collection], options[:token], options[:hash])
+    end
+
+    desc 'rsa', 'generate RSA key'
+    def rsa
+      log MixinBot.utils.generate_rsa_key
+    end
+
+    desc 'ed25519', 'generate Ed25519 key'
+    def ed25519
+      log MixinBot.utils.generate_ed25519_key
     end
   end
 end

data/lib/mixin_bot/cli.rb

@@ -5,9 +5,9 @@ require 'cli/ui'
 require 'thor'
 require 'yaml'
 require 'json'
-require_relative './cli/api'
-require_relative './cli/node'
-require_relative './cli/utils'
+require_relative 'cli/api'
+require_relative 'cli/node'
+require_relative 'cli/utils'
 
 module MixinBot
   class CLI < Thor
@@ -21,7 +21,10 @@ module MixinBot
 
     def initialize(*args)
       super
-      return if options[:keystore].blank?
+      if options[:keystore].blank?
+        @api_instance = MixinBot::API.new
+        return
+      end
 
       keystore =
         if File.file? options[:keystore]
@@ -33,7 +36,7 @@ module MixinBot
       @keystore =
         begin
           JSON.parse keystore
-        rescue JSON::ParserError => e
+        rescue JSON::ParserError
           log UI.fmt(
             format(
               '{{x}} falied to parse keystore.json: %<keystore>s',
@@ -44,17 +47,17 @@ module MixinBot
 
       return unless @keystore
 
-      MixinBot.api_host = options[:apihost]
+      MixinBot.config.api_host = options[:apihost]
       @api_instance ||=
         begin
           MixinBot::API.new(
-            client_id: @keystore['client_id'],
+            app_id: @keystore['app_id'] || @keystore['client_id'],
             session_id: @keystore['session_id'],
-            pin_token: @keystore['pin_token'],
-            private_key: @keystore['private_key']
+            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.'
+          log UI.fmt '{{x}}: Failed to initialize api, maybe your keystore is incorrect: %<error>s', error: e.message
         end
     end
 

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