mixin_bot 0.5.6 → 0.6.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f65a69b3d924aecec8bde921fcc600f117937c25ad656dc0779db1db512b2570
-  data.tar.gz: 8cae0fb36dd2244cd97892f9410fdda8d86c775451496105bfeac65bfac2cfc8
+  metadata.gz: '0482fa8ed14e5435679aba1bd40e8f9d13a4db3c4f96f2b7fe97f2639d7d55d1'
+  data.tar.gz: 506032e530c347644b878d1f1ba7a520208ca9c5ee1450351657291af46c9153
 SHA512:
-  metadata.gz: 2217346a169bbb546e2a63d4c9b3c3116eddcfb2563ad90d294dc945cc8d9e5617b20d20d0fc8a50b0d95981e9a9d06817afd6f4788ceb06ee7459808ef7de41
-  data.tar.gz: e566c88279c8337ccc1c03f92ea6a3c41e9cdc1a6f854c76ef64432d65c11cc78a2c3f3fcba32a5d2f70f952d56538b90150de917ddcd11c478091f427eb098a
+  metadata.gz: b855af1cda16ae26a7b224593adabadc5f9636f364ad36bccbcba4117ad631a38ff70abc35c3cac05df81a6bf14235d923029699df8256c8f05b59a0c697d46a
+  data.tar.gz: 7cd57b5eabe7726b5fe4d751e85ad1a4a36754b8b547a0a27baad26ccffff16a7731dc0dd3151be011e872b79a34444a6bd74b22ec550d4e567231a0b85a8552

data/lib/mixin_bot/api/collectible.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module MixinBot
+  class API
+    module Collectible
+      NFT_ASSET_MIXIN_ID = '1700941284a95f31b25ec8c546008f208f88eee4419ccdcdbe6e3195e60128ca'
+
+      def collectible(id, access_token: nil)
+        path = "/collectibles/tokens/#{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 collectible_outputs(**kwargs)
+        limit = kwargs[:limit] || 100
+        offset = kwargs[:offset] || ''
+        state = kwargs[:state] || ''
+        members = kwargs[:members] || [client_id]
+        threshold = kwargs[:threshold] || 1
+        access_token = kwargs[:access_token]
+        members = SHA3::Digest::SHA256.hexdigest(members&.sort&.join)
+
+        path = format(
+          '/collectibles/outputs?limit=%<limit>s&offset=%<offset>s&state=%<state>s&members=%<members>s&threshold=%<threshold>s',
+          limit: limit,
+          offset: offset,
+          state: state,
+          members: members,
+          threshold: threshold
+        )
+        access_token ||= access_token('GET', path, '')
+        authorization = format('Bearer %<access_token>s', access_token: access_token)
+        client.get(path, headers: { 'Authorization': authorization })
+      end
+      alias collectibles collectible_outputs
+
+      COLLECTABLE_REQUEST_ACTIONS = %i[sign unlock].freeze
+      def create_collectible_request(action, raw, access_token: nil)
+        raise ArgumentError, "request action is limited in #{COLLECTABLE_REQUEST_ACTIONS.join(', ')}" unless COLLECTABLE_REQUEST_ACTIONS.include? action.to_sym
+        path = '/collectibles/requests'
+        payload = {
+          action: action,
+          raw: raw
+        }
+        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 create_sign_collectible_request(raw, access_token: nil)
+        create_collectible_request 'sign', raw, access_token: access_token
+      end
+
+      def create_unlock_collectible_request(raw, access_token: nil)
+        create_collectible_request 'unlock', raw, access_token: access_token
+      end
+
+      def sign_collectible_request(request_id, pin)
+        path = format('/collectibles/requests/%<request_id>s/sign', request_id: request_id)
+        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
+
+      def unlock_collectible_request(request_id, pin)
+        path = format('/collectibles/requests/%<request_id>s/unlock', request_id: request_id)
+        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
+
+      def cancel_collectible_request(request_id, pin)
+        path = format('/collectibles/requests/%<request_id>s/cancel', request_id: request_id)
+        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
+    end
+
+    # collectible = {
+    #   type: 'non_fungible_output',
+    #   user_id: '',
+    #   output_id: '',
+    #   token_id: '',
+    #   transaction_hash: '',
+    #   output_index: '',
+    #   amount: 1,
+    #   senders: [],
+    #   sender_threshold: 1,
+    #   receivers: [],
+    #   receivers_threshold: 1,
+    #   state: 'unspent'
+    # }
+    COLLECTIBLE_TRANSACTION_ARGUMENTS = %i[collectible nfo receivers threshold].freeze
+    def build_collectible_transaction(**kwargs)
+      raise ArgumentError, "#{COLLECTIBLE_TRANSACTION_ARGUMENTS.join(', ')} are needed for build collectible transaction" unless COLLECTIBLE_TRANSACTION_ARGUMENTS.all? { |param| kwargs.keys.include? param }
+
+      kwargs = kwargs.with_indifferent_access
+      collectible = kwargs['collectible']
+      raise "collectible is #{collectible['state']}" unless collectible['state'] == 'unspent'
+
+      build_raw_transaction(
+        utxos: [collectible],
+        senders: collectible['receivers'],
+        receivers: kwargs['receivers'],
+        threshold: kwargs['threshold'],
+        extra: kwargs["nfo"],
+        amount: 1,
+        asset_mixin_id: NFT_ASSET_MIXIN_ID
+      )
+    end
+
+    def nft_memo(collection, token_id, meta)
+      MixinBot::Utils.nft_memo collection, token_id, meta
+    end
+  end
+end

data/lib/mixin_bot/api/conversation.rb

@@ -123,24 +123,7 @@ module MixinBot
       end
 
       def unique_uuid(user_id, opponent_id = nil)
-        opponent_id ||= client_id
-        md5 = Digest::MD5.new
-        md5 << [user_id, opponent_id].min
-        md5 << [user_id, opponent_id].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..]
-        hex = cipher.unpack1('H*')
-
-        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..]
-        )
+        MixinBot::Utils.unique_uuid user_id, opponent_id
       end
       alias unique_conversation_id unique_uuid
     end

data/lib/mixin_bot/api/multisig.rb

@@ -3,31 +3,6 @@
 module MixinBot
   class API
     module Multisig
-      # https://w3c.group/c/1574309272319630
-
-      # {"data":[
-      #   {
-      #     "type":"multisig_utxo",
-      #     "user_id":"514ae2ff-c24e-4379-a482-e2c0f798ebb1",
-      #     "utxo_id":"94711ac9-5981-4fe3-8c0e-19622219ea72",
-      #     "asset_id":"965e5c6e-434c-3fa9-b780-c50f43cd955c",
-      #     "transaction_hash":"2e67f3e36ee4b3c13effcc8a9aaafeb8122cad98f72d9ccc04d65a5ada2aa39d",
-      #     "output_index":0,
-      #     "amount":"0.123456",
-      #     "threshold":2,
-      #     "members":[
-      #       "514ae2ff-c24e-4379-a482-e2c0f798ebb1",
-      #       "13ce6c86-307a-5187-98b0-76424cbc0fbf",
-      #       "2b9df368-8e3e-46ce-ac57-e6111e8ff50e",
-      #       "3cb87491-4fa0-4c2f-b387-262b63cbc412"
-      #     ],
-      #     "memo":"难道你是女生",
-      #     "state":"unspent",
-      #     "created_at":"2019-11-03T13:30:43.922655Z",
-      #     "signed_by":"",
-      #     "signed_tx":""
-      #   }
-      # ]}
       def outputs(**kwargs)
         limit = kwargs[:limit] || 100
         offset = kwargs[:offset] || ''
@@ -50,25 +25,27 @@ module MixinBot
         client.get(path, headers: { 'Authorization': authorization })
       end
       alias multisigs outputs
+      alias multisig_outputs outputs
 
-      def create_output(receivers:, index:, access_token: nil)
+      def create_output(receivers:, index:, hint: nil, access_token: nil)
         path = '/outputs'
         payload = {
           receivers: receivers,
-          index: index
+          index: index,
+          hint: hint
         }
         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
 
-      # transfer from the multisig address
-      # create a request for multi sign
-      # for now, raw(RAW-TRANSACTION-HEX) can only be generated by Mixin SDK of Golang or Javascript
-      def create_sign_multisig_request(raw, access_token: nil)
+      MULTISIG_REQUEST_ACTIONS = %i[sign unlock].freeze
+      def create_multisig_request(action, raw, access_token: nil)
+        raise ArgumentError, "request action is limited in #{MULTISIG_REQUEST_ACTIONS.join(', ')}" unless MULTISIG_REQUEST_ACTIONS.include? action.to_sym
+
         path = '/multisigs/requests'
         payload = {
-          action: 'sign',
+          action: action,
           raw: raw
         }
         access_token ||= access_token('POST', path, payload.to_json)
@@ -76,17 +53,15 @@ module MixinBot
         client.post(path, headers: { 'Authorization': authorization }, json: payload)
       end
 
+      # transfer from the multisig address
+      def create_sign_multisig_request(raw, access_token: nil)
+        create_multisig_request 'sign', raw, access_token: access_token
+      end
+
       # transfer from the multisig address
       # create a request for unlock a multi-sign
       def create_unlock_multisig_request(raw, access_token: nil)
-        path = '/multisigs/requests'
-        payload = {
-          action: 'unlock',
-          raw: raw
-        }
-        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)
+        create_multisig_request 'unlock', raw, access_token: access_token
       end
 
       def sign_multisig_request(request_id, pin)
@@ -121,7 +96,7 @@ module MixinBot
 
       # pay to the multisig address
       # used for create multisig payment code_id
-      def create_multisig_payment(**kwargs)
+      def create_payment(**kwargs)
         path = '/payments'
         payload = {
           asset_id: kwargs[:asset_id],
@@ -138,6 +113,7 @@ module MixinBot
         authorization = format('Bearer %<access_token>s', access_token: access_token)
         client.post(path, headers: { 'Authorization': authorization }, json: payload)
       end
+      alias create_multisig_payment create_payment
 
       def verify_multisig(code_id, access_token: nil)
         path = format('/codes/%<code_id>s', code_id: code_id)
@@ -176,33 +152,27 @@ module MixinBot
       #   amount: string / float,
       #   memo: string,
       # }
-      RAW_TRANSACTION_ARGUMENTS = %i[senders receivers amount threshold asset_id].freeze
+      RAW_TRANSACTION_ARGUMENTS = %i[utxos senders receivers amount threshold].freeze
       def build_raw_transaction(**kwargs)
         raise ArgumentError, "#{RAW_TRANSACTION_ARGUMENTS.join(', ')} are needed for build raw transaction" unless RAW_TRANSACTION_ARGUMENTS.all? { |param| kwargs.keys.include? param }
 
-        senders        = kwargs[:senders]
-        receivers      = kwargs[:receivers]
-        amount         = kwargs[:amount]
-        threshold      = kwargs[:threshold]
-        asset_id       = kwargs[:asset_id]
-        utxos          = kwargs[:utxos]
-        memo           = kwargs[:memo]
-        access_token   = kwargs[:access_token]
+        senders             = kwargs[:senders]
+        threshold           = kwargs[:threshold]
+        receivers           = kwargs[:receivers]
+        receivers_threshold = kwargs[:receivers_threshold]
+        amount              = kwargs[:amount]
+        threshold           = kwargs[:threshold]
+        asset_id            = kwargs[:asset_id]
+        asset_mixin_id      = kwargs[:asset_mixin_id]
+        utxos               = kwargs[:utxos]
+        memo                = kwargs[:memo]
+        extra               = kwargs[:extra]
+        access_token        = kwargs[:access_token]
+        outputs             = kwargs[:outputs] || []
+        hint                = kwargs[:hint]
 
         raise 'access_token required!' if access_token.nil? && !senders.include?(client_id)
 
-        # default to use all(first 100) unspent utxo
-        utxos ||= multisigs(
-          members: senders,
-          threshold: threshold,
-          state: 'unspent',
-          access_token: access_token
-        )['data'].filter(
-          &lambda { |utxo|
-            utxo['asset_id'] == kwargs[:asset_id]
-          }
-        )
-
         amount = amount.to_f.round(8)
         input_amount = utxos.map(
           &lambda { |utxo|
@@ -227,29 +197,34 @@ module MixinBot
           }
         )
 
-        outputs = []
-        output0 = create_output(receivers: receivers, index: 0)['data']
-        outputs << {
-          'amount': format('%<amount>.8f', amount: amount),
-          'script': build_threshold_script(receivers.length),
-          'mask': output0['mask'],
-          'keys': output0['keys']
-        }
-
-        if input_amount > amount
-          output1 = create_output(receivers: senders, index: 1)['data']
-          outputs << {
-            'amount': format('%<amount>.8f', amount: input_amount - amount),
-            'script': build_threshold_script(threshold.to_i),
-            'mask': output1['mask'],
-            'keys': output1['keys']
-          }
+        if outputs.empty?
+          receivers_threshold = 1 if receivers.size == 1
+          output0 = build_output(
+            receivers: receivers, 
+            index: 0, 
+            amount: amount, 
+            threshold: receivers_threshold,
+            hint: hint
+          )
+          outputs.push output0
+
+          if input_amount > amount
+            output1 = build_output(
+              receivers: senders, 
+              index: 1, 
+              amount: (input_amount - amount),
+              threshold: threshold,
+              hint: hint
+            )
+            outputs.push output1
+          end
         end
 
-        extra = Digest.hexencode memo.to_s.slice(0, 140)
+        extra = extra || Digest.hexencode(memo.to_s.slice(0, 140))
+        asset = asset_mixin_id || SHA3::Digest::SHA256.hexdigest(asset_id)
         tx = {
-          version: 1,
-          asset: SHA3::Digest::SHA256.hexdigest(asset_id),
+          version: 2,
+          asset: asset,
           inputs: inputs,
           outputs: outputs,
           extra: extra
@@ -258,63 +233,24 @@ module MixinBot
         tx.to_json
       end
 
-      def str_to_bin(str)
-        return if str.nil?
-
-        str.scan(/../).map(&:hex).pack('c*')
-      end
-
-      def build_inputs(inputs)
-        res = []
-        prototype = {
-          'Hash' => nil,
-          'Index' => nil,
-          'Genesis' => nil,
-          'Deposit' => nil,
-          'Mint' => nil
+      def build_output(receivers:, index:, amount:, threshold:, hint: nil)
+        _output = create_output receivers: receivers, index: index, hint: hint
+        {
+          amount: format('%.8f', amount.to_f),
+          script: build_threshold_script(threshold),
+          mask: _output['mask'],
+          keys: _output['keys']
         }
-        inputs.each do |input|
-          struc = prototype.dup
-          struc['Hash'] = str_to_bin input['hash']
-          struc['Index'] = input['index']
-          res << struc
-        end
-
-        res
       end
 
-      def build_outputs(outputs)
-        res = []
-        prototype = {
-          'Type' => 0,
-          'Amount' => nil,
-          'Keys' => nil,
-          'Script' => nil,
-          'Mask' => nil
-        }
-        outputs.each do |output|
-          struc = prototype.dup
-          struc['Type'] = str_to_bin output['type']
-          struc['Amount'] = str_to_bin output['amount']
-          struc['Keys'] = output['keys'].map(&->(key) { str_to_bin(key) })
-          struc['Script'] = str_to_bin output['script']
-          struc['Mask'] = str_to_bin output['mask']
-          res << struc
-        end
+      def str_to_bin(str)
+        return if str.nil?
 
-        res
+        str.scan(/../).map(&:hex).pack('c*')
       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
-        hex = digest.unpack1('H*')
-
-        [hex[0..7], hex[8..11], hex[12..15], hex[16..19], hex[20..]].join('-')
+        MixinBot::Utils.generate_trace_from_hash hash, output_index
       end
     end
   end

data/lib/mixin_bot/api.rb

@@ -6,6 +6,7 @@ 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/me'
 require_relative './api/message'
@@ -43,8 +44,16 @@ module MixinBot
         end
     end
 
+    def sign_raw_transaction(tx)
+      MixinBot::Utils.sign_raw_transaction tx
+    end
+
+    def decode_raw_transaction(raw)
+      MixinBot::Utils.decode_raw_transaction raw
+    end
+
     # Use a mixin software to implement transaction build
-    def sign_raw_transaction(json)
+    def sign_raw_transaction_native(json)
       ensure_mixin_command_exist
       command = format("mixin signrawtransaction --raw '%<arg>s'", arg: json)
 
@@ -54,11 +63,23 @@ module MixinBot
       output.chomp
     end
 
+    # Use a mixin software to implement transaction build
+    def decode_raw_transaction_native(raw)
+      ensure_mixin_command_exist
+      command = format("mixin decoderawtransaction --raw '%<arg>s'", arg: raw)
+
+      output, error = Open3.capture3(command)
+      raise error unless error.empty?
+
+      JSON.parse output.chomp
+    end
+
     include MixinBot::API::App
     include MixinBot::API::Asset
     include MixinBot::API::Attachment
     include MixinBot::API::Auth
     include MixinBot::API::Blaze
+    include MixinBot::API::Collectible
     include MixinBot::API::Conversation
     include MixinBot::API::Me
     include MixinBot::API::Message

data/lib/mixin_bot/utils.rb

@@ -0,0 +1,608 @@
+# frozen_string_literal: true
+
+module MixinBot
+  module Utils
+    class << self
+      MAGIC = [0x77, 0x77]
+      TX_VERSION = 2
+      MAX_ENCODE_INT = 0xFFFF
+      NULL_BYTES = [0x00, 0x00]
+      AGGREGATED_SIGNATURE_PREFIX = 0xFF01
+      AGGREGATED_SIGNATURE_ORDINAY_MASK = [0x00]
+      AGGREGATED_SIGNATURE_SPARSE_MASK = [0x01]
+      NFT_MEMO_PREFIX = 'NFO'
+      NFT_MEMO_VERSION = 0x00
+      NFT_MEMO_DEFAULT_CHAIN = '43d61dcd-e413-450d-80b8-101d5e903357'
+      NFT_MEMO_DEFAULT_CLASS = '3c8c161a18ae2c8b14fda1216fff7da88c419b5d'
+      NFT_MASK = 0x00
+      NULL_UUID = '00000000-0000-0000-0000-000000000000'
+
+      def unique_uuid(user_id, opponent_id = nil)
+        opponent_id ||= client_id
+        md5 = Digest::MD5.new
+        md5 << [user_id, opponent_id].min
+        md5 << [user_id, opponent_id].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..]
+        hex = cipher.unpack1('H*')
+
+        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
+
+      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
+        hex = digest.unpack1('H*')
+
+        hex_to_uuid hex
+      end
+
+      def hex_to_uuid(hex)
+        [hex[0..7], hex[8..11], hex[12..15], hex[16..19], hex[20..]].join('-')
+      end
+
+      def sign_raw_transaction(tx)
+        if tx.is_a? String
+          tx = JSON.parse tx
+        end
+        raise "#{tx} is not a valid json" unless tx.is_a? Hash
+
+        tx = tx.with_indifferent_access
+        bytes = []
+
+        # magic number
+        bytes += MAGIC
+
+        # version
+        bytes += [0, tx['version']]
+
+        # asset
+        bytes += [tx['asset']].pack('H*').bytes
+
+        # inputs
+        bytes += encode_inputs tx['inputs']
+
+        # output
+        bytes += encode_outputs tx['outputs']
+
+        # extra
+        extra_bytes = [tx['extra']].pack('H*').bytes
+        bytes += encode_int extra_bytes.size
+        bytes += extra_bytes
+
+        # aggregated
+        aggregated = tx['aggregated']
+        if aggregated.nil?
+          # signatures
+          bytes += encode_signatures tx['signatures']
+        else
+          bytes += encode_aggregated_signature aggregated
+        end
+
+        bytes.pack('C*').unpack1('H*')
+      end
+
+      def decode_raw_transaction(raw)
+        bytes = [raw].pack('H*').bytes
+        tx = {}
+
+        magic = bytes.shift(2)
+        raise 'Not valid raw' unless magic == MAGIC
+
+        version = bytes.shift(2)
+        tx['version'] = bytes_to_int version
+
+        asset = bytes.shift(32)
+        tx['asset'] = asset.pack('C*').unpack1('H*')
+
+        # read inputs
+        bytes, tx = decode_inputs bytes, tx
+
+        # read outputs
+        bytes, tx = decode_outputs bytes, tx
+
+        extra_size = bytes.shift(2).reverse.pack('C*').unpack1('S*')
+        tx['extra'] = bytes.shift(extra_size).pack('C*').unpack1('H*')
+
+        num = bytes.shift(2).reverse.pack('C*').unpack1('S*')
+        if num == MAX_ENCODE_INT
+          # aggregated
+          aggregated = {}
+
+          raise 'invalid aggregated' unless bytes.shift(2).reverse.pack('C*').unpack1('S*') == AGGREGATED_SIGNATURE_PREFIX
+
+          aggregated['signature'] = bytes.shift(64).pack('C*').unpack1('H*')
+
+          byte = bytes.shift
+          case byte
+          when AGGREGATED_SIGNATURE_ORDINAY_MASK.first
+            aggregated['signers'] = []
+            masks_size = bytes.shift(2).reverse.pack('C*').unpack1('S*')
+            masks = bytes.shift(masks_size)
+            masks = [masks] unless masks.is_a? Array
+
+            masks.each_with_index do |mask, i|
+              8.times do |j|
+                k = 1 << j
+                aggregated['signers'].push(i * 8 + j) if mask & k == k
+              end
+            end
+          when AGGREGATED_SIGNATURE_SPARSE_MASK.first
+            signers_size = bytes.shift(2).reverse.pack('C*').unpack1('S*')
+            return if signers_size == 0
+
+            aggregated['signers'] = []
+            signers_size.times do
+              aggregated['signers'].push bytes.shift(2).reverse.pack('C*').unpack1('S*')
+            end
+          end
+
+          tx['aggregated'] = aggregated
+        else
+          if !bytes.empty? && bytes[...2] != NULL_BYTES
+            signatures_size = bytes.shift(2).reverse.pack('C*').unpack1('S*')
+            tx['signatures'] = bytes.shift(signatures_size).pack('C*').unpack1('H*')
+          end
+        end
+        
+        tx
+      end
+
+      def nft_memo_hash(collection, token_id, meta)
+        collection = NULL_UUID if collection.empty?
+        meta = meta.to_json if meta.is_a?(Hash)
+
+        memo = {
+          prefix: NFT_MEMO_PREFIX,
+          version: NFT_MEMO_VERSION,
+          mask: 0,
+          chain: NFT_MEMO_DEFAULT_CHAIN,
+          class: NFT_MEMO_DEFAULT_CLASS,
+          collection: collection,
+          token: token_id,
+          extra: SHA3::Digest::SHA256.hexdigest(meta)
+        }
+
+        mark = [0]
+        mark.map do |index|
+          if index >= 64
+            raise "invalid NFO memo index #{index}"
+          end
+          memo[:mask] = memo[:mask] ^ (1 << index)
+        end
+
+        memo
+      end
+
+      def nft_memo(collection, token_id, meta)
+        encode_nft_memo nft_memo_hash(collection, token_id, meta)
+      end
+
+      def encode_nft_memo(memo)
+        bytes = []
+
+        bytes += NFT_MEMO_PREFIX.bytes 
+        bytes += [NFT_MEMO_VERSION]
+
+        if memo[:mask] != 0
+          bytes += [1]
+          bytes += encode_unit_64 memo[:mask]
+          bytes += memo[:chain].split('-').pack('H* H* H* H* H*').bytes
+
+          class_bytes = [memo[:class]].pack('H*').bytes
+          bytes += bytes_of class_bytes.size
+          bytes += class_bytes
+
+          collection_bytes = memo[:collection].split('-').pack('H* H* H* H* H*').bytes
+          bytes += bytes_of collection_bytes.size
+          bytes += collection_bytes
+
+          # token_bytes = memo[:token].split('-').pack('H* H* H* H* H*').bytes
+          token_bytes = bytes_of memo[:token]
+          bytes += bytes_of token_bytes.size
+          bytes += token_bytes
+        end
+
+        extra_bytes = [memo[:extra]].pack('H*').bytes
+        bytes += bytes_of extra_bytes.size
+        bytes += extra_bytes
+
+        Base64.urlsafe_encode64 bytes.pack('C*'), padding: false
+      end
+
+      def decode_nft_memo(encoded)
+        bytes = Base64.urlsafe_decode64(encoded).bytes
+        memo = {}
+        memo[:prefix] = bytes.shift(3).pack('C*')
+        memo[:version] = bytes.shift
+
+        hint = bytes.shift
+        if hint == 1
+          memo[:mask] = bytes.shift(8).reverse.pack('C*').unpack1('Q*')
+          memo[:chain] = hex_to_uuid bytes.shift(16).pack('C*').unpack1('H*')
+
+          class_length = bytes.shift
+          memo[:class] = bytes.shift(class_length).pack('C*').unpack1('H*')
+
+          collection_length = bytes.shift
+          memo[:collection] = hex_to_uuid bytes.shift(collection_length).pack('C*').unpack1('H*')
+
+          token_length = bytes.shift
+          memo[:token] = bytes_to_int bytes.shift(token_length)
+        end
+
+        extra_length = bytes.shift
+        memo[:extra] = bytes.shift(extra_length).pack('C*').unpack1('H*')
+
+        memo
+      end
+
+      private
+
+      def encode_int(int)
+        raise "only support int #{int}" unless int.is_a?(Integer)
+        raise "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 '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
+
+      def encode_inputs(inputs, bytes = [])
+        bytes += encode_int(inputs.size)
+        inputs.each do |input|
+          bytes += [input['hash']].pack('H*').bytes
+          bytes += encode_int(input['index'])
+
+          # genesis
+          genesis = input['genesis'] || ''
+          if genesis.empty?
+            bytes += NULL_BYTES
+          else
+            genesis_bytes = [genesis].pack('H*').bytes
+            bytes += encode_int genesis_bytes.size
+            bytes += genesis_bytes
+          end
+
+          # deposit
+          deposit = input['deposit']
+          if deposit.nil?
+            bytes += NULL_BYTES
+          else
+            bytes += MAGIC
+            bytes += [deposit['chain']].pack('H*').bytes
+
+            asset_bytes = [deposit['asset']].pack('H*')
+            bytes += encode_int asset_bytes.size
+            bytes += asset_bytes
+
+            transaction_bytes = [deposit['transaction']].pack('H*')
+            bytes += encode_int transaction_bytes.size
+            bytes += transaction_bytes
+
+            bytes += encode_unit_64 deposit['index']
+
+            amount_bytes = bytes_of deposit['amount']
+            bytes +=  encode_int amount_bytes.size
+            bytes +=  amount_bytes
+          end
+
+          # mint
+          mint = input['mint']
+          if mint.nil?
+            bytes += NULL_BYTES
+          else
+            bytes += MAGIC
+
+            # group
+            group = mint['group'] || ''
+            if group.empty?
+              bytes += encode_int NULL_BYTES
+            else
+              group_bytes = [group].pack('H*')
+              bytes += encode_int group_bytes.size
+              bytes += group_bytes
+            end
+
+            bytes += encode_unit_64 mint['batch']
+
+            amount_bytes = bytes_of mint['amount']
+            bytes +=  encode_int amount_bytes.size
+            bytes +=  amount_bytes
+          end
+        end
+
+        bytes
+      end
+
+      def encode_outputs(outputs, bytes = [])
+        bytes += encode_int(outputs.size)
+        outputs.each do |output|
+          type = output['type'] || 0
+          bytes += [0x00, type]
+
+          # amount
+          amount_bytes = bytes_of (output['amount'].to_f * 1e8).to_i
+          bytes +=  encode_int amount_bytes.size
+          bytes +=  amount_bytes
+
+          # keys
+          bytes +=  encode_int output['keys'].size
+          output['keys'].each do |key|
+            bytes += [key].pack('H*').bytes
+          end
+
+          # mask
+          bytes += [output['mask']].pack('H*').bytes
+
+          # script
+          script_bytes = [output['script']].pack('H*').bytes
+          bytes += encode_int script_bytes.size
+          bytes += script_bytes
+
+          # withdrawal
+          withdrawal = output['withdrawal']
+          if withdrawal.nil?
+            bytes += NULL_BYTES
+          else
+            bytes += MAGIC
+
+            # chain
+            bytes += [withdrawal['chain']].pack('H*').bytes
+
+            # asset
+            asset_bytes = [withdrawal['asset']].pack('H*')
+            bytes += encode_int asset_bytes.size
+            bytes += asset_bytes
+
+            # address
+            address = withdrawal['address'] || ''
+            if address.empty?
+              bytes += NULL_BYTES
+            else
+              address_bytes = [address].pack('H*').bytes
+              bytes += encode_int address.size
+              bytes += address_bytes
+            end
+
+            # tag
+            tag = withdrawal['tag'] || ''
+            if tag.empty?
+              bytes += NULL_BYTES
+            else
+              address_bytes = [tag].pack('H*').bytes
+              bytes += encode_int tag.size
+              bytes += address_bytes
+            end
+          end
+        end
+
+        bytes
+      end
+
+      def encode_aggregated_signature(aggregated, bytes = [])
+        bytes += encode_int MAX_ENCODE_INT
+        bytes += encode_int AGGREGATED_SIGNATURE_PREFIX
+        bytes += [aggregated['signature']].pack('H*').bytes
+
+        signers = aggregated['signers']
+        if signers.size == 0
+          bytes += AGGREGATED_SIGNATURE_ORDINAY_MASK
+          bytes += NULL_BYTES
+        else
+          signers.each do |sig, i|
+            raise 'signers not sorted' if i > 0 && sig <= signers[i - 1]
+            raise 'signers not sorted' if sig > MAX_ENCODE_INT
+          end
+
+          max = signers.last
+          if (((max / 8 | 0) + 1 | 0) > aggregated['signature'].size * 2)
+            bytes += AGGREGATED_SIGNATURE_SPARSE_MASK
+            bytes += encode_int aggregated['signers'].size
+            signers.map(&->(signer) { bytes += encode_int(signer) })
+          end
+
+          masks_bytes = Array.new(max / 8 + 1, 0)
+          signers.each do |signer|
+            masks[signer/8] = masks[signer/8] ^ (1 << (signer % 8))
+          end
+          bytes += AGGREGATED_SIGNATURE_ORDINAY_MASK
+          bytes += encode_int masks_bytes.size
+          bytes += masks_bytes
+        end
+
+        bytes
+      end
+
+      def encode_signatures(signatures, bytes = [])
+        sl =
+          if signatures.is_a? Hash
+            signatures.keys.size
+          else
+            0
+          end
+
+        raise 'signatures overflow' if sl == MAX_ENCODE_INT
+        bytes += encode_int sl
+
+        if sl > 0
+          bytes += encode_int signatures.keys.size
+          signatures.keys.sort.each do |key|
+            bytes += encode_int key
+            bytes += [signatures[key]].pack('H*').bytes
+          end
+        end
+
+        bytes
+      end
+
+      def decode_inputs(bytes, tx)
+        inputs_size = bytes.shift(2).reverse.pack('C*').unpack1('S*')
+        tx['inputs'] = []
+        inputs_size.times do
+          input = {}
+          hash = bytes.shift(32)
+          input['hash'] = hash.pack('C*').unpack1('H*')
+
+          index = bytes.shift(2)
+          input['index'] = index.reverse.pack('C*').unpack1('S*')
+
+          if bytes[...2] != NULL_BYTES
+            genesis_size = bytes.shift(2).reverse.pack('C*').unpack1('S*')
+            genesis = bytes.shift(genesis_size)
+            input['genesis'] = genesis.pack('C*').unpack1('H*')
+          else
+            bytes.shift 2
+          end
+
+          if bytes[...2] != NULL_BYTES
+            magic = bytes.shift(2)
+            raise 'Not valid input' unless magic == MAGIC
+
+            deposit = {}
+            deposit['chain'] = bytes.shift(32).pack('C*').unpack1('H*')
+
+            asset_size = bytes.shift(2).reverse.pack('C*').unpack1('S*')
+            deposit['asset'] = bytes.shift(asset_size).unpack1('H*')
+
+            transaction_size = bytes.shift(2).reverse.pack('C*').unpack1('S*')
+            deposit['transaction'] = bytes.shift(transaction_size).unpack1('H*')
+
+            deposit['index'] = bytes.shift(8).reverse.pack('C*').unpack1('Q*')
+
+            amount_size = bytes.shift(2).reverse.pack('C*').unpack1('S*')
+            deposit['amount'] = bytes_to_int bytes.shift(amount_size)
+
+            input['deposit'] = deposit
+          else
+            bytes.shift 2
+          end
+
+          if bytes[...2] != NULL_BYTES
+            magic = bytes.shift(2)
+            raise 'Not valid input' unless magic == MAGIC
+
+            mint = {}
+            if bytes[...2] != NULL_BYTES
+              group_size = bytes.shift(2).reverse.pack('C*').unpack1('S*')
+              mint['group'] = bytes.shift(group_size).unpack1('H*')
+            else
+              bytes.shift 2
+            end
+
+            mint['batch'] = bytes.shift(8).reverse.pack('C*').unpack1('Q*')
+            _amount_size = bytes.shift(2).reverse.pack('C*').unpack1('S*')
+            mint['amount'] = bytes_to_int bytes.shift(_amount_size)
+
+            input['mint'] = mint
+          else
+            bytes.shift 2
+          end
+
+          tx['inputs'].push input
+        end
+
+        [bytes, tx]
+      end
+
+      def decode_outputs(bytes, tx)
+        outputs_size = bytes.shift(2).reverse.pack('C*').unpack1('S*')
+        tx['outputs'] = []
+        outputs_size.times do
+          output = {}
+
+          bytes.shift
+          type = bytes.shift
+          output['type'] = type
+
+          amount_size = bytes.shift(2).reverse.pack('C*').unpack1('S*')
+          output['amount'] = format('%.8f', bytes_to_int(bytes.shift(amount_size)).to_f / 1e8)
+
+          output['keys'] = []
+          keys_size = bytes.shift(2).reverse.pack('C*').unpack1('S*')
+          keys_size.times do
+            output['keys'].push bytes.shift(32).pack('C*').unpack1('H*')
+          end
+
+          output['mask'] = bytes.shift(32).pack('C*').unpack1('H*')
+
+          script_size = bytes.shift(2).reverse.pack('C*').unpack1('S*')
+          output['script'] = bytes.shift(script_size).pack('C*').unpack1('H*')
+
+          if bytes[...2] != NULL_BYTES
+            magic = bytes.shift(2)
+            raise 'Not valid output' unless magic == MAGIC
+
+            withdraw = {}
+
+            output['chain'] = bytes.shift(32).pack('C*').unpack1('H*')
+
+            asset_size = bytes.shift(2).reverse.pack('C*').unpack1('S*')
+            output['asset'] = bytes.shift(asset_size).unpack1('H*')
+
+            if bytes[...2] != NULL_BYTES
+              address = {}
+
+              adderss_size = bytes.shift(2).reverse.pack('C*').unpack1('S*')
+              output['adderss'] = bytes.shift(adderss_size).pack('C*').unpack1('H*')
+            else
+              bytes.shift 2
+            end
+
+            if bytes[...2] != NULL_BYTES
+              tag = {}
+
+              tag_size = bytes.shift(2).reverse.pack('C*').unpack1('S*')
+              output['tag'] = bytes.shift(tag_size).pack('C*').unpack1('H*')
+            else
+              bytes.shift 2
+            end
+          else
+            bytes.shift 2
+          end
+
+          tx['outputs'].push output
+        end
+
+        [bytes, tx]
+      end
+    end
+  end
+end

data/lib/mixin_bot/version.rb

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

data/lib/mixin_bot.rb

@@ -2,6 +2,7 @@
 
 # third-party dependencies
 require 'English'
+require 'active_support/core_ext/hash'
 require 'base64'
 require 'digest'
 require 'faye/websocket'
@@ -15,6 +16,7 @@ require 'sha3'
 
 require_relative './mixin_bot/api'
 require_relative './mixin_bot/cli'
+require_relative './mixin_bot/utils'
 require_relative './mixin_bot/version'
 
 module MixinBot

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: mixin_bot
 version: !ruby/object:Gem::Version
-  version: 0.5.6
+  version: 0.6.3
 platform: ruby
 authors:
 - an-lee
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-09-30 00:00:00.000000000 Z
+date: 2021-10-29 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.1'
 - !ruby/object:Gem::Dependency
   name: awesome_print
   requirement: !ruby/object:Gem::Requirement
@@ -265,6 +279,7 @@ files:
 - lib/mixin_bot/api/attachment.rb
 - lib/mixin_bot/api/auth.rb
 - lib/mixin_bot/api/blaze.rb
+- lib/mixin_bot/api/collectible.rb
 - lib/mixin_bot/api/conversation.rb
 - lib/mixin_bot/api/me.rb
 - lib/mixin_bot/api/message.rb
@@ -281,6 +296,7 @@ files:
 - lib/mixin_bot/cli/multisig.rb
 - lib/mixin_bot/cli/node.rb
 - lib/mixin_bot/client.rb
+- lib/mixin_bot/utils.rb
 - lib/mixin_bot/version.rb
 homepage: https://github.com/an-lee/mixin_bot
 licenses: