mixin_bot 0.12.1 → 1.1.0

data/lib/mixin_bot/utils/crypto.rb

@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+
+module MixinBot
+  module Utils
+    module Crypto
+      def access_token(method, uri, body = '', **kwargs)
+        sig = Digest::SHA256.hexdigest(method + uri + body.to_s)
+        iat = Time.now.utc.to_i
+        exp = (Time.now.utc + (kwargs[:exp_in] || 600)).to_i
+        scp = kwargs[:scp] || 'FULL'
+        jti = SecureRandom.uuid
+        uid = kwargs[:app_id] || MixinBot.config.app_id
+        sid = kwargs[:session_id] || MixinBot.config.session_id
+        private_key = kwargs[:private_key] || MixinBot.config.session_private_key
+
+        payload = {
+          uid:,
+          sid:,
+          iat:,
+          exp:,
+          jti:,
+          sig:,
+          scp:
+        }
+
+        if private_key.blank?
+          raise ConfigurationNotValidError, 'private_key is required'
+        elsif private_key.size == 64
+          jwk = JOSE::JWK.from_okp [:Ed25519, private_key]
+          jws = JOSE::JWS.from({ 'alg' => 'EdDSA' })
+        else
+          jwk = JOSE::JWK.from_pem private_key
+          jws = JOSE::JWS.from({ 'alg' => 'RS512' })
+        end
+
+        jwt = JOSE::JWT.from payload
+        JOSE::JWT.sign(jwk, jws, jwt).compact
+      end
+
+      def generate_ed25519_key
+        ed25519_key = JOSE::JWA::Ed25519.keypair
+        {
+          private_key: Base64.urlsafe_encode64(ed25519_key[1], padding: false),
+          public_key: Base64.urlsafe_encode64(ed25519_key[0], padding: false)
+        }
+      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 shared_public_key(key)
+        (JOSE::JWA::Edwards25519Point.stdbase * scalar_from_bytes(key[...64]).x.to_i).encode
+      end
+
+      def scalar_from_bytes(raw)
+        JOSE::JWA::FieldElement.new(
+          # https://github.com/potatosalad/ruby-jose/blob/e1be589b889f1e59ac233a5d19a3fa13f1e4b8a0/lib/jose/jwa/x25519.rb#L122C14-L122C48
+          OpenSSL::BN.new(raw.reverse, 2),
+          JOSE::JWA::Edwards25519Point::L
+        )
+      end
+
+      def sign(msg, key:)
+        msg = Digest::Blake3.digest msg
+
+        pub = shared_public_key key
+
+        y_scalar = scalar_from_bytes key
+
+        key_digest = Digest::SHA512.digest key
+        msg_digest = Digest::SHA512.digest(key_digest[-32...] + msg)
+
+        z_scalar = scalar_from_bytes msg_digest[...64]
+
+        r_point = JOSE::JWA::Edwards25519Point.stdbase * z_scalar.x.to_i
+
+        hram_digest = Digest::SHA512.digest(r_point.encode + pub + msg)
+
+        x_scalar = scalar_from_bytes hram_digest[...64]
+
+        s_scalar = (x_scalar * y_scalar) + z_scalar
+
+        r_point.encode + s_scalar.to_bytes(36)
+      end
+
+      def generate_unique_uuid(uuid1, uuid2)
+        md5 = Digest::MD5.new
+        md5 << [uuid1, uuid2].min
+        md5 << [uuid1, uuid2].max
+        digest = md5.digest
+        digest6 = ((digest[6].ord & 0x0f) | 0x30).chr
+        digest8 = ((digest[8].ord & 0x3f) | 0x80).chr
+        cipher = digest[0...6] + digest6 + digest[7] + digest8 + digest[9..]
+
+        MixinBot::UUID.new(raw: cipher).unpacked
+      end
+
+      def unique_uuid(*uuids)
+        uuids = uuids.flatten.compact
+        uuids.sort
+        r = uuids.first
+        uuids.each_with_index do |uuid, i|
+          r = generate_unique_uuid(r, uuid) if i.positive?
+        end
+
+        r
+      end
+
+      def generate_trace_from_hash(hash, output_index = 0)
+        md5 = Digest::MD5.new
+        md5 << hash
+        md5 << [output_index].pack('c*') if output_index.positive? && output_index < 256
+        digest = md5.digest
+        digest[6] = ((digest[6].ord & 0x0f) | 0x30).chr
+        digest[8] = ((digest[8].ord & 0x3f) | 0x80).chr
+
+        MixinBot::UUID.new(raw: digest).unpacked
+      end
+
+      # decrypt the encrpted pin, just for test
+      def decrypt_pin(msg, shared_key:)
+        msg = Base64.urlsafe_decode64 msg
+        iv = msg[0..15]
+        cipher = msg[16..47]
+        alg = 'AES-256-CBC'
+        decode_cipher = OpenSSL::Cipher.new(alg)
+        decode_cipher.decrypt
+        decode_cipher.iv = iv
+        decode_cipher.key = shared_key
+        decode_cipher.update(cipher)
+      end
+
+      # 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, **kwargs)
+        pin = MixinBot.utils.decode_key pin
+
+        shared_key = kwargs[:shared_key]
+        raise ArgumentError, 'shared_key is required' if shared_key.blank?
+
+        iterator ||= kwargs[: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 + tsstring + tsstring
+        pad_count = 16 - (encrypt_content.length % 16)
+        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 = shared_key
+        aes.iv = iv
+        cipher = aes.update(padded_content)
+        msg = iv + cipher
+        Base64.urlsafe_encode64 msg, padding: false
+      end
+
+      def tip_public_key(key, counter: 0)
+        raise ArgumentError, 'invalid key' if key.size < 32
+
+        (key[0...32].bytes + MixinBot::Utils.encode_uint64(counter + 1)).pack('c*').unpack1('H*')
+      end
+
+      def hash_scalar(pkey, output_index)
+        tmp = [output_index].pack('Q<').reverse
+
+        hash1 = Digest::Blake3.digest(pkey + tmp)
+        hash2 = Digest::Blake3.digest hash1
+
+        hash3 = Digest::Blake3.digest(hash1 + hash2)
+        hash4 = Digest::Blake3.digest hash3
+
+        hash3 + hash4
+      end
+
+      def multiply_keys(public_key:, private_key:)
+        public_point = JOSE::JWA::Edwards25519Point.stdbase.decode public_key
+        private_scalar = scalar_from_bytes private_key
+        (public_point * private_scalar.x.to_i).encode
+      end
+
+      def derive_ghost_public_key(private_key, view_key, spend_key, index)
+        mult_value = multiply_keys(public_key: view_key, private_key:)
+
+        x = hash_scalar mult_value, index
+
+        p1 = JOSE::JWA::Edwards25519Point.stdbase.decode spend_key
+        p2 = JOSE::JWA::Edwards25519Point.stdbase * scalar_from_bytes(x).x.to_i
+
+        (p1 + p2).encode
+      end
+
+      def derive_ghost_private_key(public_key, view_key, spend_key, index)
+        mult_value = multiply_keys(public_key:, private_key: view_key)
+
+        x = hash_scalar mult_value, index
+
+        x_scalar = scalar_from_bytes x
+        y_scalar = scalar_from_bytes spend_key
+
+        (x_scalar + y_scalar).to_bytes(36)
+      end
+    end
+  end
+end

data/lib/mixin_bot/utils/decoder.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module MixinBot
+  module Utils
+    module Decoder
+      def decode_key(key)
+        return if key.blank?
+
+        if key.match?(/\A[\h]{64,}\z/i)
+          [key].pack('H*')
+        elsif key.match?(/^-----BEGIN RSA PRIVATE KEY-----/)
+          key.gsub('\\r\\n', "\n").gsub("\r\n", "\n")
+        elsif key.match?(/\d{6}/) || (key.size % 32).zero?
+          key
+        else
+          Base64.urlsafe_decode64 key
+        end
+      end
+
+      def decode_raw_transaction(hex)
+        MixinBot::Transaction.new(hex:).decode.to_h
+      end
+
+      def decode_uint16(bytes)
+        raise ArgumentError, "only support bytes #{bytes}" unless bytes.is_a?(Array)
+
+        bytes.reverse.pack('C*').unpack1('S*')
+      end
+
+      def decode_uint32(bytes)
+        raise ArgumentError, "only support bytes #{bytes}" unless bytes.is_a?(Array)
+
+        bytes.reverse.pack('C*').unpack1('L*')
+      end
+
+      def decode_uint64(bytes)
+        raise ArgumentError, "only support bytes #{bytes}" unless bytes.is_a?(Array)
+
+        bytes.reverse.pack('C*').unpack1('Q*')
+      end
+
+      def decode_int(bytes)
+        int = 0
+        bytes.each do |byte|
+          int = (int * (2**8)) + byte
+        end
+
+        int
+      end
+
+      def hex_to_uuid(hex)
+        MixinBot::UUID.new(hex:).unpacked
+      end
+    end
+  end
+end

data/lib/mixin_bot/utils/encoder.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module MixinBot
+  module Utils
+    module Encoder
+      def encode_raw_transaction(txn)
+        if txn.is_a? String
+          begin
+            txn = JSON.parse txn
+          rescue JSON::ParserError
+            txn
+          end
+        end
+
+        raise ArgumentError, "#{txn} is not a valid json" unless txn.is_a? Hash
+
+        txn = txn.with_indifferent_access
+
+        MixinBot::Transaction.new(**txn).encode.hex
+      end
+
+      def encode_uint16(int)
+        raise ArgumentError, "only support int #{int}" unless int.is_a?(Integer)
+
+        [int].pack('S*').bytes.reverse
+      end
+
+      def encode_uint32(int)
+        raise ArgumentError, "only support int #{int}" unless int.is_a?(Integer)
+
+        [int].pack('L*').bytes.reverse
+      end
+
+      def encode_uint64(int)
+        raise ArgumentError, "only support int #{int}" unless int.is_a?(Integer)
+
+        [int].pack('Q*').bytes.reverse
+      end
+
+      def encode_int(int)
+        raise ArgumentError, 'not integer' unless int.is_a?(Integer)
+
+        bytes = []
+        loop do
+          break if int.zero?
+
+          bytes.push int & 255
+          int = (int / (2**8)) | 0
+        end
+
+        bytes.reverse
+      end
+
+      def nft_memo(collection, token, extra)
+        MixinBot::Nfo.new(
+          collection:,
+          token:,
+          extra:
+        ).mint_memo
+      end
+    end
+  end
+end

data/lib/mixin_bot/utils.rb

@@ -1,116 +1,15 @@
 # frozen_string_literal: true
 
-require_relative './utils/nfo'
-require_relative './utils/uuid'
-require_relative './utils/transaction'
+require_relative 'utils/address'
+require_relative 'utils/crypto'
+require_relative 'utils/decoder'
+require_relative 'utils/encoder'
 
 module MixinBot
   module Utils
-    class << self
-      MAGIC = [0x77, 0x77].freeze
-      TX_VERSION = 2
-      MAX_ENCODE_INT = 0xFFFF
-      NULL_BYTES = [0x00, 0x00].freeze
-      AGGREGATED_SIGNATURE_PREFIX = 0xFF01
-      AGGREGATED_SIGNATURE_ORDINAY_MASK = [0x00].freeze
-      AGGREGATED_SIGNATURE_SPARSE_MASK = [0x01].freeze
-
-      def generate_unique_uuid(uuid_1, uuid_2)
-        md5 = Digest::MD5.new
-        md5 << [uuid_1, uuid_2].min
-        md5 << [uuid_1, uuid_2].max
-        digest = md5.digest
-        digest6 = (digest[6].ord & 0x0f | 0x30).chr
-        digest8 = (digest[8].ord & 0x3f | 0x80).chr
-        cipher = digest[0...6] + digest6 + digest[7] + digest8 + digest[9..]
-
-        UUID.new(raw: cipher).unpacked
-      end
-
-      def unique_uuid(*uuids)
-        uuids.sort
-        r = uuids.first
-        uuids.each_with_index do |uuid, i|
-          r = MixinBot::Utils.generate_unique_uuid(r, uuid) if i.positive?
-        end
-
-        r
-      end
-
-      def generate_trace_from_hash(hash, output_index = 0)
-        md5 = Digest::MD5.new
-        md5 << hash
-        md5 << [output_index].pack('c*') if output_index.positive? && output_index < 256
-        digest = md5.digest
-        digest[6] = ((digest[6].ord & 0x0f) | 0x30).chr
-        digest[8] = ((digest[8].ord & 0x3f) | 0x80).chr
-
-        UUID.new(raw: digest).unpacked
-      end
-
-      def hex_to_uuid(hex)
-        UUID.new(hex: hex).unpacked
-      end
-
-      def sign_raw_transaction(tx)
-        tx = JSON.parse tx if tx.is_a? String
-        raise ArgumentError, "#{tx} is not a valid json" unless tx.is_a? Hash
-
-        tx = tx.with_indifferent_access
-
-        Transaction.new(
-          asset: tx[:asset],
-          inputs: tx[:inputs],
-          outputs: tx[:outputs],
-          extra: tx[:extra]
-        ).encode.hex
-      end
-
-      def decode_raw_transaction(hex)
-        Transaction.new(hex: hex).decode.to_h
-      end
-
-      def nft_memo(collection, token, extra)
-        MixinBot::Utils::Nfo.new(
-          collection: collection,
-          token: token,
-          extra: extra
-        ).mint_memo
-      end
-
-      def encode_int(int)
-        raise ArgumentError, "only support int #{int}" unless int.is_a?(Integer)
-        raise ArgumentError, "int #{int} is larger than MAX_ENCODE_INT #{MAX_ENCODE_INT}" if int > MAX_ENCODE_INT
-
-        [int].pack('S*').bytes.reverse
-      end
-
-      def encode_unit_64(int)
-        [int].pack('Q*').bytes.reverse
-      end
-
-      def bytes_of(int)
-        raise ArgumentError, 'not integer' unless int.is_a?(Integer)
-
-        bytes = []
-        loop do
-          break if int === 0
-
-          bytes.push int & 255
-          int = int / (2**8) | 0
-        end
-
-        bytes.reverse
-      end
-
-      def bytes_to_int(bytes)
-        int = 0
-        bytes.each do |byte|
-          int = int * (2**8) + byte
-        end
-
-        int
-      end
-    end
+    extend MixinBot::Utils::Address
+    extend MixinBot::Utils::Crypto
+    extend MixinBot::Utils::Decoder
+    extend MixinBot::Utils::Encoder
   end
 end

data/lib/mixin_bot/uuid.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module MixinBot
+  class UUID
+    attr_accessor :hex, :raw
+
+    def initialize(**args)
+      @hex = args[:hex]
+      @raw = args[:raw]
+
+      raise MixinBot::InvalidUuidFormatError if raw.present? && raw.size != 16
+      raise MixinBot::InvalidUuidFormatError if hex.present? && hex.gsub('-', '').size != 32
+    end
+
+    def packed
+      if raw.present?
+        raw
+      elsif hex.present?
+        [hex.gsub('-', '')].pack('H*')
+      end
+    end
+
+    def unpacked
+      _hex =
+        if hex.present?
+          hex.gsub('-', '')
+        elsif raw.present?
+          _hex = raw.unpack1('H*')
+        end
+
+      format(
+        '%<first>s-%<second>s-%<third>s-%<forth>s-%<fifth>s',
+        first: _hex[0..7],
+        second: _hex[8..11],
+        third: _hex[12..15],
+        forth: _hex[16..19],
+        fifth: _hex[20..]
+      )
+    end
+  end
+end

data/lib/mixin_bot/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MixinBot
-  VERSION = '0.12.1'
+  VERSION = '1.1.0'
 end

data/lib/mixin_bot.rb

@@ -3,12 +3,16 @@
 # third-party dependencies
 require 'English'
 require 'active_support/all'
+require 'base58'
 require 'base64'
 require 'bigdecimal'
 require 'bigdecimal/util'
 require 'digest'
+require 'digest/blake3'
 require 'faye/websocket'
-require 'http'
+require 'faraday'
+require 'faraday/multipart'
+require 'faraday/retry'
 require 'jose'
 require 'msgpack'
 require 'open3'
@@ -16,19 +20,38 @@ require 'openssl'
 require 'rbnacl'
 require 'sha3'
 
-require_relative './mixin_bot/api'
-require_relative './mixin_bot/cli'
-require_relative './mixin_bot/utils'
-require_relative './mixin_bot/version'
-require_relative './mvm'
+require_relative 'mixin_bot/api'
+require_relative 'mixin_bot/cli'
+require_relative 'mixin_bot/utils'
+require_relative 'mixin_bot/nfo'
+require_relative 'mixin_bot/uuid'
+require_relative 'mixin_bot/transaction'
+require_relative 'mixin_bot/version'
+require_relative 'mvm'
 
 module MixinBot
-  class<< self
-    attr_accessor :client_id, :client_secret, :session_id, :pin_token, :private_key, :scope, :api_host, :blaze_host
-  end
+  class << self
+    def api
+      return @api if defined?(@api)
+
+      @api = MixinBot::API.new
+      @api
+    end
+
+    def config
+      return @config if defined?(@config)
+
+      @config = MixinBot::Configuration.new
+      @config
+    end
+
+    def configure(&)
+      config.instance_exec(&)
+    end
 
-  def self.api
-    @api ||= MixinBot::API.new
+    def utils
+      MixinBot::Utils
+    end
   end
 
   class Error < StandardError; end
@@ -37,12 +60,14 @@ module MixinBot
   class RequestError < Error; end
   class ResponseError < Error; end
   class NotFoundError < Error; end
+  class UserNotFoundError < Error; end
   class UnauthorizedError < Error; end
   class ForbiddenError < Error; end
   class InsufficientBalanceError < Error; end
   class InsufficientPoolError < Error; end
   class PinError < Error; end
-  class InvalidNfoFormatError < MixinBot::Error; end
-  class InvalidUuidFormatError < MixinBot::Error; end
-  class InvalidTransactionFormatError < MixinBot::Error; end
+  class InvalidNfoFormatError < Error; end
+  class InvalidUuidFormatError < Error; end
+  class InvalidTransactionFormatError < Error; end
+  class ConfigurationNotValidError < Error; end
 end

data/lib/mvm/bridge.rb

@@ -16,27 +16,10 @@ module MVM
       path = '/users'
 
       payload = {
-        public_key: public_key
+        public_key:
       }
 
-      client.post path, json: payload
-    end
-
-    def extra(receivers: [], threshold: 1, extra: '')
-      return if receivers.blank?
-
-      path = '/extra'
-
-      payload = {
-        receivers: receivers,
-        threshold: threshold,
-        extra: extra
-      }
-
-      client.post path, json: payload
-    end
-
-    def mirror
+      client.post path, **payload
     end
   end
 end

data/lib/mvm/client.rb

@@ -8,43 +8,21 @@ module MVM
 
     def initialize(host)
       @host = host
-    end
-
-    def get(path, options = {})
-      request(:get, path, options)
-    end
-
-    def post(path, options = {})
-      request(:post, path, options)
-    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
+      @conn = Faraday.new(url: "#{SERVER_SCHEME}://#{host}") do |f|
+        f.request :json
+        f.request :retry
+        f.response :raise_error
+        f.response :logger
+        f.response :json
       end
+    end
 
-      raise ResponseError, response.to_s if response.status.server_error?
-      return response.status.to_s unless response.status.success?
-
-      JSON.parse(response.body.to_s)
+    def get(path, **)
+      @conn.get(path, **).body
     end
 
-    def uri_for(path)
-      uri_options = {
-        scheme: SERVER_SCHEME,
-        host: host,
-        path: path
-      }
-      Addressable::URI.new(uri_options)
+    def post(path, **)
+      @conn.post(path, **).body
     end
   end
 end