mixin_bot 0.12.0 → 1.0.0

data/lib/mixin_bot/api/withdraw.rb

@@ -3,75 +3,74 @@
 module MixinBot
   class API
     module Withdraw
-      # https://developers.mixin.one/api/alpha-mixin-network/create-address/
-      def create_withdraw_address(options, access_token: nil)
+      def create_withdraw_address(**kwargs)
         path = '/addresses'
-        encrypted_pin = encrypt_pin(options[:pin])
+        pin = kwargs[:pin]
         payload =
-          # for EOS withdraw, account_name & account_tag must be valid
-          if options[:public_key].nil?
-            {
-              asset_id: options[:asset_id],
-              account_name: options[:account_name],
-              account_tag: options[:account_tag],
-              label: options[:label],
-              pin: encrypted_pin
-            }
-          # for other withdraw
-          else
-            {
-              asset_id: options[:asset_id],
-              public_key: options[:public_key],
-              label: options[:label],
-              pin: encrypted_pin
-            }
-          end
+          {
+            asset_id: kwargs[:asset_id],
+            destination: kwargs[:destination],
+            tag: kwargs[:tag],
+            label: kwargs[:label]
+          }
+
+        if pin.length > 6
+          payload[:pin_base64] = encrypt_tip_pin pin, 'TIP:ADDRESS:ADD:', payload[:asset_id], payload[:destination], payload[:tag], payload[:label]
+        else
+          payload[:pin] = encrypt_pin pin
+        end
 
-        access_token ||= access_token('POST', path, payload.to_json)
-        authorization = format('Bearer %<access_token>s', access_token: access_token)
-        client.post(path, headers: { 'Authorization': authorization }, json: payload)
+        client.post path, **payload
       end
 
-      # https://developers.mixin.one/api/alpha-mixin-network/read-address/
       def get_withdraw_address(address, access_token: nil)
-        path = format('/addresses/%<address>s', address: address)
-        access_token ||= access_token('GET', path, '')
-        authorization = format('Bearer %<access_token>s', access_token: access_token)
-        client.get(path, headers: { 'Authorization': authorization })
+        path = format('/addresses/%<address>s', address:)
+
+        client.get path, access_token:
       end
 
-      # https://developers.mixin.one/api/alpha-mixin-network/delete-address/
-      def delete_withdraw_address(address, pin, access_token: nil)
-        path = format('/addresses/%<address>s/delete', address: address)
-        payload = {
-          pin: encrypt_pin(pin)
-        }
+      def delete_withdraw_address(address, **kwargs)
+        pin = kwargs[:pin]
 
-        access_token ||= access_token('POST', path, payload.to_json)
-        authorization = format('Bearer %<access_token>s', access_token: access_token)
-        client.post(path, headers: { 'Authorization': authorization }, json: payload)
+        path = format('/addresses/%<address>s/delete', address:)
+        payload =
+          if pin.length > 6
+            {
+              pin_base64: encrypt_tip_pin(pin, 'TIP:ADDRESS:REMOVE:', address)
+            }
+          else
+            {
+              pin: encrypt_pin(pin)
+            }
+          end
+
+        client.post path, **payload
       end
 
-      # https://developers.mixin.one/api/alpha-mixin-network/withdrawal-addresses/
-      def withdrawals(options, access_token: nil)
-        address_id = options[:address_id]
-        pin = options[:pin]
-        amount = options[:amount]
-        trace_id = options[:trace_id]
-        memo = options[:memo]
+      def withdrawals(**kwargs)
+        address_id = kwargs[:address_id]
+        pin = kwargs[:pin]
+        amount = format('%.8f', kwargs[:amount].to_d.to_r)
+        trace_id = kwargs[:trace_id]
+        memo = kwargs[:memo]
+        kwargs[:access_token]
 
         path = '/withdrawals'
         payload = {
-          address_id: address_id,
-          amount: amount,
-          trace_id: trace_id,
-          memo: memo,
-          pin: encrypt_pin(pin)
+          address_id:,
+          amount:,
+          trace_id:,
+          memo:
         }
 
-        access_token ||= access_token('POST', path, payload.to_json)
-        authorization = format('Bearer %<access_token>s', access_token: access_token)
-        client.post(path, headers: { 'Authorization': authorization }, json: payload)
+        if pin.length > 6
+          fee = '0'
+          payload[:pin_base64] = encrypt_tip_pin pin, 'TIP:WITHDRAW:', address_id, amount, fee, trace_id, memo
+        else
+          payload[:pin] = encrypt_pin pin
+        end
+
+        client.post path, **payload
       end
     end
   end

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,20 +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'
-    option :pin, type: :string, required: true, aliases: '-p', desc: 'pin'
     def authcode
       res = {}
-      CLI::UI::Spinner.spin("POST /oauth/authorize") do |_spinner|
+      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: options[:pin]
+            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