mixin_bot 0.6.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4534f4c2ea6ed1928f5c2a32b5221737ba94ff70cffdaa26a95ae03c710e5186
-  data.tar.gz: dd4a3901a081d50f2c0d3ab751516956e4065c21acaadb980e836b25b099b90a
+  metadata.gz: fea4c2a8e738f32bcadb126f775042eb9c0a57d9fcfd168948127e8332e58a9a
+  data.tar.gz: 9f0699d3a105c499530230b565b6c22a8cd74dcda857a220fb6de73a899f1ffe
 SHA512:
-  metadata.gz: 1a729cad7c8086ebfaae941b6ea4ba93318376e3effb469e42979317f048fb89c34b1b53425389c7da7138dddf6ebed80a643360c9a377c9c4c22d4834c02027
-  data.tar.gz: 44d76715c4721f2db56a7fee621e3454f18556f94b41d225821bc352cb1fd8ddaa61c38f2c5fbc4380099ddd995e94bca841e743eedb1675b555bf5a79a8bf58
+  metadata.gz: 774bf51ca38c7e507e4e6da343e139500715d7c150fb04083f4418e9a3a8fe6627383230953807f7463cc041391e8649c01290e634783b6e04b47f150eb01fe6
+  data.tar.gz: 69732a0f23244b8c62aa4fd553af66239df418427c9f7b0afd1437cd8821a9d05df3ac8c1ad4d60c66559b613fce5dc4268e67b5122bae7d7aeff20273a301ce

data/lib/mixin_bot/api/collectible.rb

@@ -3,6 +3,8 @@
 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, '')
@@ -35,7 +37,7 @@ module MixinBot
 
       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 action.to_sym.in? COLLECTABLE_REQUEST_ACTIONS
+        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,
@@ -47,11 +49,11 @@ module MixinBot
       end
 
       def create_sign_collectible_request(raw, access_token: nil)
-        create_collectible_output 'sign', raw, access_token
+        create_collectible_request 'sign', raw, access_token: access_token
       end
 
       def create_unlock_collectible_request(raw, access_token: nil)
-        create_collectible_output 'unlock', raw, access_token
+        create_collectible_request 'unlock', raw, access_token: access_token
       end
 
       def sign_collectible_request(request_id, pin)
@@ -85,6 +87,39 @@ module MixinBot
       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

data/lib/mixin_bot/api/multisig.rb

@@ -40,7 +40,7 @@ module MixinBot
 
       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 action.to_sym.in? MULTISIG_REQUEST_ACTIONS
+        raise ArgumentError, "request action is limited in #{MULTISIG_REQUEST_ACTIONS.join(', ')}" unless MULTISIG_REQUEST_ACTIONS.include? action.to_sym
 
         path = '/multisigs/requests'
         payload = {
@@ -54,13 +54,13 @@ module MixinBot
 
       # transfer from the multisig address
       def create_sign_multisig_request(raw, access_token: nil)
-        create_multisig_request 'sign', raw, access_token
+        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)
-        create_multisig_request 'unlock', raw, access_token
+        create_multisig_request 'unlock', raw, access_token: access_token
       end
 
       def sign_multisig_request(request_id, pin)
@@ -151,7 +151,7 @@ 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 }
 
@@ -160,24 +160,14 @@ module MixinBot
         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]
 
         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|
@@ -221,10 +211,11 @@ module MixinBot
           }
         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: 2,
-          asset: SHA3::Digest::SHA256.hexdigest(asset_id),
+          asset: asset,
           inputs: inputs,
           outputs: outputs,
           extra: extra

data/lib/mixin_bot/api.rb

@@ -48,6 +48,10 @@ module MixinBot
       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_native(json)
       ensure_mixin_command_exist
@@ -59,6 +63,17 @@ 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

data/lib/mixin_bot/utils.rb

@@ -58,6 +58,7 @@ module MixinBot
         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 = []
@@ -67,6 +68,8 @@ module MixinBot
 
         # version
         bytes += [0, tx['version']]
+
+        # asset
         bytes += [tx['asset']].pack('H*').bytes
 
         # inputs
@@ -92,6 +95,72 @@ module MixinBot
         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)
@@ -225,9 +294,9 @@ module MixinBot
           # genesis
           genesis = input['genesis'] || ''
           if genesis.empty?
-            bytes += encode_int 0
+            bytes += NULL_BYTES
           else
-            genesis_bytes = [genesis].pack('H*')
+            genesis_bytes = [genesis].pack('H*').bytes
             bytes += encode_int genesis_bytes.size
             bytes += genesis_bytes
           end
@@ -265,7 +334,7 @@ module MixinBot
             # group
             group = mint['group'] || ''
             if group.empty?
-              bytes += encode_int 0
+              bytes += encode_int NULL_BYTES
             else
               group_bytes = [group].pack('H*')
               bytes += encode_int group_bytes.size
@@ -349,14 +418,14 @@ module MixinBot
       end
 
       def encode_aggregated_signature(aggregated, bytes = [])
-        bytes += MAX_ENCODE_INT
+        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 += encode_int 0
+          bytes += NULL_BYTES
         else
           signers.each do |sig, i|
             raise 'signers not sorted' if i > 0 && sig <= signers[i - 1]
@@ -366,7 +435,7 @@ module MixinBot
           max = signers.last
           if (((max / 8 | 0) + 1 | 0) > aggregated['signature'].size * 2)
             bytes += AGGREGATED_SIGNATURE_SPARSE_MASK
-            bytes += encode_int aggregated['signature'].size
+            bytes += encode_int aggregated['signers'].size
             signers.map(&->(signer) { bytes += encode_int(signer) })
           end
 
@@ -403,6 +472,137 @@ module MixinBot
 
         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.6.0'
+  VERSION = '0.6.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mixin_bot
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.6.1
 platform: ruby
 authors:
 - an-lee
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-10-27 00:00:00.000000000 Z
+date: 2021-10-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport