mixin_bot 0.0.1.4 → 0.3.0

data/lib/mixin_bot/api/payment.rb

@@ -1,29 +1,29 @@
+# frozen_string_literal: true
+
 module MixinBot
   class API
     module Payment
       def pay_url(options)
-        options = options.with_indifferent_access
-        recipient_id = options.fetch('recipient_id')
-        asset_id = options.fetch('asset_id')
-        amount = options.fetch('amount')
-        memo = options.fetch('memo')
-        trace = options.fetch('trace')
-        url = format('https://mixin.one/pay?recipient=%s&asset=%s&amount=%s&trace=%s&memo=%s', recipient_id, asset_id, amount, trace, memo)
+        format(
+          'https://mixin.one/pay?recipient=%<recipient_id>s&asset=%<asset>s&amount=%<amount>s&trace=%<trace>s&memo=%<memo>s',
+          recipient_id: options[:recipient_id],
+          asset: options[:asset_id],
+          amount: options[:amount].to_s,
+          trace: options[:trace],
+          memo: options[:memo]
+        )
       end
 
+      # https://developers.mixin.one/api/alpha-mixin-network/verify-payment/
       def verify_payment(options)
-        options = options.with_indifferent_access
-        recipient_id = options.fetch('recipient_id')
-        asset_id = options.fetch('asset_id')
-        amount = options.fetch('amount')
-        trace = options.fetch('trace')
         path = 'payments'
         payload = {
-          asset_id: asset_id,
-          opponent_id: recipient_id,
-          amount: amount,
-          trace_id: trace,
+          asset_id: options[:asset_id],
+          opponent_id: options[:opponent_id],
+          amount: options[:amount].to_s,
+          trace_id: options[:trace]
         }
+
         client.post(path, json: payload)
       end
     end

data/lib/mixin_bot/api/pin.rb

@@ -1,56 +1,92 @@
+# frozen_string_literal: true
+
 module MixinBot
   class API
     module Pin
-      def verify_pin(pin_code, access_token=nil)
+      # https://developers.mixin.one/api/alpha-mixin-network/verify-pin/
+      def verify_pin(pin_code)
         path = '/pin/verify'
         payload = {
           pin: encrypt_pin(pin_code)
         }
 
-        access_token ||= self.access_token('POST', path, payload.to_json)
-        authorization = format('Bearer %s', access_token)
+        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)
+      end
+
+      # https://developers.mixin.one/api/alpha-mixin-network/create-pin/
+      def update_pin(old_pin:, pin:)
+        path = '/pin/update'
+        encrypted_old_pin = old_pin.nil? ? '' : encrypt_pin(old_pin, iterator: Time.now.utc.to_i)
+        encrypted_pin = encrypt_pin(pin, iterator: Time.now.utc.to_i + 1)
+        payload = {
+          old_pin: encrypted_old_pin,
+          pin: encrypted_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)
       end
 
+      # decrypt the encrpted pin, just for test
       def decrypt_pin(msg)
         msg = Base64.strict_decode64 msg
         iv = msg[0..15]
         cipher = msg[16..47]
-        aes_key = JOSE::JWA::PKCS1::rsaes_oaep_decrypt('SHA256', pin_token, private_key, session_id)
         alg = 'AES-256-CBC'
         decode_cipher = OpenSSL::Cipher.new(alg)
         decode_cipher.decrypt
         decode_cipher.iv = iv
-        decode_cipher.key = aes_key
-        plain = decode_cipher.update(cipher)
-        return plain
+        decode_cipher.key = _generate_aes_key
+        decoded = decode_cipher.update(cipher)
+        decoded[0..5]
       end
 
-      def encrypt_pin(pin_code)
-        aes_key = JOSE::JWA::PKCS1::rsaes_oaep_decrypt('SHA256', pin_token, private_key, session_id)
-        ts = Time.now.utc.to_i
-        tszero = ts % 0x100
-        tsone = (ts % 0x10000) >> 8
-        tstwo = (ts % 0x1000000) >> 16
-        tsthree = (ts % 0x100000000) >> 24
-        tsstring = tszero.chr + tsone.chr + tstwo.chr + tsthree.chr + "\0\0\0\0"
+      # https://developers.mixin.one/api/alpha-mixin-network/encrypted-pin/
+      # use timestamp(timestamp) for iterator as default: must be bigger than the previous, the first time must be greater than 0. After a new session created, it will be reset to 0.
+      def encrypt_pin(pin_code, iterator: nil)
+        iterator ||= Time.now.utc.to_i
+        tszero = iterator % 0x100
+        tsone = (iterator % 0x10000) >> 8
+        tstwo = (iterator % 0x1000000) >> 16
+        tsthree = (iterator % 0x100000000) >> 24
+        tsstring = "#{tszero.chr}#{tsone.chr}#{tstwo.chr}#{tsthree.chr}\u0000\u0000\u0000\u0000"
         encrypt_content = pin_code + tsstring + tsstring
         pad_count = 16 - encrypt_content.length % 16
-        if pad_count > 0
-          padded_content = encrypt_content + pad_count.chr * pad_count
-        else
-          padded_content = encrypt_content
-        end
+        padded_content =
+          if pad_count.positive?
+            encrypt_content + pad_count.chr * pad_count
+          else
+            encrypt_content
+          end
 
         alg = 'AES-256-CBC'
         aes = OpenSSL::Cipher.new(alg)
         iv = OpenSSL::Cipher.new(alg).random_iv
         aes.encrypt
-        aes.key = aes_key
+        aes.key = _generate_aes_key
         aes.iv = iv
         cipher = aes.update(padded_content)
         msg = iv + cipher
-        return Base64.strict_encode64 msg
+        Base64.strict_encode64 msg
+      end
+    end
+
+    def _generate_aes_key
+      if pin_token.size == 32
+        JOSE::JWA::X25519.x25519(
+          JOSE::JWA::Ed25519.secret_to_curve25519(private_key[0..31]),
+          pin_token
+        )
+      else
+        JOSE::JWA::PKCS1.rsaes_oaep_decrypt(
+          'SHA256',
+          pin_token,
+          OpenSSL::PKey::RSA.new(private_key),
+          session_id
+        )
       end
     end
   end

data/lib/mixin_bot/api/snapshot.rb

@@ -1,26 +1,41 @@
+# frozen_string_literal: true
+
 module MixinBot
   class API
     module Snapshot
-      def read_snapshots(options)
-        options = options.with_indifferent_access
-        limit = options['limit']
-        offset = options['offset']
-        asset = options['asset']
-        order = options['order']
+      def read_network_snapshots(options = {})
+        path = format(
+          '/network/snapshots?limit=%<limit>s&offset=%<offset>s&asset=%<asset>s&order=%<order>s',
+          limit: options[:limit],
+          offset: options[:offset],
+          asset: options[:asset],
+          order: options[:order]
+        )
 
-        path = 'network/snapshots'
-        payload = {
-          limit: limit,
-          offset: offset,
-          asset: asset,
-          order: order
-        }
-        client.get(path, params: payload)
+        access_token = options[:access_token] || access_token('GET', path)
+        authorization = format('Bearer %<access_token>s', access_token: access_token)
+        client.get(path, headers: { 'Authorization': authorization })
       end
 
-      def read_snapshot(snapshot_id)
-        path = format('network/snapshots/%s', snapshot_id)
-        client.get(path)
+      def read_snapshots(options = {})
+        path = format(
+          '/snapshots?limit=%<limit>s&offset=%<offset>s&asset=%<asset>s',
+          limit: options[:limit],
+          offset: options[:offset],
+          asset: options[:asset]
+        )
+
+        access_token = options[:access_token] || access_token('GET', path)
+        authorization = format('Bearer %<access_token>s', access_token: access_token)
+        client.get(path, headers: { 'Authorization': authorization })
+      end
+
+      def read_network_snapshot(snapshot_id, options = {})
+        path = format('/network/snapshots/%<snapshot_id>s', snapshot_id: snapshot_id)
+
+        access_token = options[:access_token] || access_token('GET', path)
+        authorization = format('Bearer %<access_token>s', access_token: access_token)
+        client.get(path, headers: { 'Authorization': authorization })
       end
     end
   end

data/lib/mixin_bot/api/transfer.rb

@@ -1,35 +1,35 @@
+# frozen_string_literal: true
+
 module MixinBot
   class API
     module Transfer
-      def create_transfer(pin, options)
-        options = options.with_indifferent_access
-
-        asset_id = options.fetch('asset_id')
-        opponent_id = options.fetch('opponent_id')
-        amount = options.fetch('amount')
-        memo = options.fetch('memo')
-        trace_id = options.fetch('trace_id')
-        trace_id ||= SecureRandom.uuid
+      def create_transfer(pin, options, access_token: nil)
+        asset_id = options[:asset_id]
+        opponent_id = options[:opponent_id]
+        amount = options[:amount]
+        memo = options[:memo]
+        trace_id = options[:trace_id] || SecureRandom.uuid
+        encrypted_pin = options[:encrypted_pin] || encrypt_pin(pin)
 
         path = '/transfers'
         payload = {
           asset_id: asset_id,
           opponent_id: opponent_id,
-          pin: pin,
-          amount: amount,
+          pin: encrypted_pin,
+          amount: amount.to_s,
           trace_id: trace_id,
           memo: memo
         }
 
-        access_token ||= self.access_token('POST', path, payload.to_json)
-        authorization = format('Bearer %s', access_token)
+        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)
       end
 
-      def read_transfer(trace_id)
-        path = format('/transfers/trace/%s', trace_id)
-        access_token ||= self.access_token('GET', path, '')
-        authorization = format('Bearer %s', access_token)
+      def read_transfer(trace_id, access_token: nil)
+        path = format('/transfers/trace/%<trace_id>s', trace_id: trace_id)
+        access_token ||= access_token('GET', path, '')
+        authorization = format('Bearer %<access_token>s', access_token: access_token)
         client.get(path, headers: { 'Authorization': authorization })
       end
     end

data/lib/mixin_bot/api/user.rb

@@ -1,29 +1,77 @@
+# frozen_string_literal: true
+
 module MixinBot
   class API
     module User
-      def read_user(user_id, access_token=nil)
-        # user_id: Mixin User Id
-        path = format('/users/%s', user_id)
-        access_token ||= self.access_token('GET', path, '')
-        authorization = format('Bearer %s', access_token)
+      # https://developers.mixin.one/api/beta-mixin-message/read-user/
+      def read_user(user_id)
+        # user_id: Mixin User UUID
+        path = format('/users/%<user_id>s', user_id: user_id)
+        access_token = access_token('GET', path, '')
+        authorization = format('Bearer %<access_token>s', access_token: access_token)
         client.get(path, headers: { 'Authorization': authorization })
       end
 
-      def search_user(q, access_token=nil)
-        # q: Mixin Id or Phone Number
-        path = format('/search/%s', q)
-        access_token ||= self.access_token('GET', path, '')
-        authorization = format('Bearer %s', access_token)
+      # https://developers.mixin.one/api/alpha-mixin-network/app-user/
+      # Create a new Mixin Network user (like a normal Mixin Messenger user). You should keep PrivateKey which is used to sign an AuthenticationToken and encrypted PIN for the user.
+      def create_user(full_name, key_type: 'RSA', rsa_key: nil, ed25519_key: nil)
+        case key_type
+        when 'RSA'
+          rsa_key ||= generate_rsa_key
+          session_secret = rsa_key[:public_key].gsub(/^-----.*PUBLIC KEY-----$/, '').strip
+        when 'Ed25519'
+          ed25519_key ||= generate_ed25519_key
+          session_secret = ed25519_key[:public_key]
+        else
+          raise 'Only RSA and Ed25519 are supported'
+        end
+
+        payload = {
+          full_name: full_name,
+          session_secret: session_secret
+        }
+        access_token = access_token('POST', '/users', payload.to_json)
+        authorization = format('Bearer %<access_token>s', access_token: access_token)
+        res = client.post('/users', headers: { 'Authorization': authorization }, json: payload)
+
+        res.merge(rsa_key: rsa_key, ed25519_key: ed25519_key)
+      end
+
+      def generate_rsa_key
+        rsa_key = OpenSSL::PKey::RSA.new 1024
+        {
+          private_key: rsa_key.to_pem,
+          public_key: rsa_key.public_key.to_pem
+        }
+      end
+
+      def generate_ed25519_key
+        ed25519_key = JOSE::JWA::Ed25519.keypair
+        {
+          private_key: Base64.strict_encode64(ed25519_key[1]),
+          public_key: Base64.strict_encode64(ed25519_key[0])
+        }
+      end
+
+      # https://developers.mixin.one/api/beta-mixin-message/search-user/
+      # search by Mixin Id or Phone Number
+      def search_user(query)
+        path = format('/search/%<query>s', query: query)
+
+        access_token = access_token('GET', path, '')
+        authorization = format('Bearer %<access_token>s', access_token: access_token)
         client.get(path, headers: { 'Authorization': authorization })
       end
 
-      def fetch_users(user_ids, access_token=nil)
+      # https://developers.mixin.one/api/beta-mixin-message/read-users/
+      def fetch_users(user_ids)
         # user_ids: a array of user_ids
         path = '/users/fetch'
         user_ids = [user_ids] if user_ids.is_a? String
         payload = user_ids
-        access_token ||= self.access_token('POST', path, payload.to_json)
-        authorization = format('Bearer %s', access_token)
+
+        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)
       end
     end

data/lib/mixin_bot/api/withdraw.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module MixinBot
+  class API
+    module Withdraw
+      # https://developers.mixin.one/api/alpha-mixin-network/create-address/
+      def create_withdraw_address(options, access_token: nil)
+        path = '/addresses'
+        encrypted_pin = encrypt_pin(options[: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
+
+        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)
+      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 })
+      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)
+        }
+
+        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)
+      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]
+
+        path = '/withdrawals'
+        payload = {
+          address_id: address_id,
+          amount: amount,
+          trace_id: trace_id,
+          memo: memo,
+          pin: encrypt_pin(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)
+      end
+    end
+  end
+end

data/lib/mixin_bot/cli.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require 'awesome_print'
+require 'cli/ui'
+require 'thor'
+require 'yaml'
+require 'json'
+require_relative './cli/node'
+require_relative './cli/me'
+require_relative './cli/multisig'
+
+module MixinBot
+  class CLI < Thor
+    # https://github.com/Shopify/cli-ui
+    UI = ::CLI::UI
+
+    class_option :apihost, type: :string, aliases: '-a', desc: 'Specify mixin api host, default as api.mixin.one'
+    class_option :pretty, type: :boolean, aliases: '-p', desc: 'Print output in pretty'
+
+    attr_reader :config, :api
+
+    def initialize(*args)
+      super
+      if File.exist? options[:config].to_s
+        @config =
+          begin
+            YAML.load_file options[:config]
+          rescue StandardError => e
+            log UI.fmt(
+              format(
+                '{{x}} %<file>s is not a valid .yml file',
+                file: options[:config]
+              )
+            )
+            UI::Frame.open('{{x}}', color: :red) do
+              log e
+            end
+          end
+      elsif options[:config]
+        @confg =
+          begin
+            JSON.parse options[:config]
+          rescue StandardError => e
+            log UI.fmt(
+              format(
+                '{{x}} Failed to parse %<config>s',
+                config: options[:config]
+              )
+            )
+            UI::Frame.open('{{x}}', color: :red) do
+              log e
+            end
+          end
+      end
+
+      return unless @config
+
+      MixinBot.api_host = options[:apihost]
+      @api ||=
+        begin
+          MixinBot::API.new(
+            client_id: @config['client_id'],
+            client_secret: @config['client_secret'],
+            session_id: @config['session_id'],
+            pin_token: @config['pin_token'],
+            private_key: @config['private_key'],
+            pin_code: @config['pin_code']
+          )
+        rescue StandardError => e
+          log UI.fmt '{{x}}: Failed to initialize api, maybe your config is incorrect.'
+          UI.Frame.open('{{x}}', color: :red) do
+            log e
+          end
+        end
+    end
+
+    desc 'node', 'mixin node commands helper'
+    subcommand 'node', MixinBot::NodeCLI
+
+    desc 'version', 'Distay MixinBot version'
+    def version
+      log MixinBot::VERSION
+    end
+
+    def self.exit_on_failure?
+      true
+    end
+
+    private
+
+    def api_method(method, *args, **params)
+      if api.nil?
+        log UI.fmt '{{x}} MixinBot api not initialized!'
+        return
+      end
+
+      res = if args.empty? && params.empty?
+              api&.public_send method
+            elsif args.empty? && !params.empty?
+              api&.public_send method params
+            elsif !args.empty? && params.empty?
+              api&.public_send method, args
+            else
+              args.push params
+              api&.public_send method, args
+            end
+      log res
+
+      [res, res && res['error'].nil?]
+    rescue MixinBot::Errors => e
+      UI::Frame.open('{{x}}', color: :red) do
+        log e
+      end
+    end
+
+    def log(obj)
+      if options[:pretty]
+        if obj.is_a? String
+          puts obj
+        else
+          ap obj
+        end
+      else
+        puts obj.inspect
+      end
+    end
+  end
+end