mixin_bot 0.7.11 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3b4b77d94221e1120da8c18fadd70bcf5898d083e2bd95c469cee8c96084c76f
-  data.tar.gz: '039f44131a984c10b1f527b6c45766a3660af6efc40e2e66e132b46e1cbc8428'
+  metadata.gz: a76c8b7d2c5d8cebc963a56d350e3fd5e4bbc1e18ad3e037b65cfb6e1d77b0d1
+  data.tar.gz: 8c9813a57cb33f256c695a88e42f53feffb33a45979f5fbf788916f332a52d26
 SHA512:
-  metadata.gz: 22470467c1b5955e2e2352788fecbf14bf307abdba0283796a2b86525660a8f479670135bd9d594b59462a2058956214036025f9881833b57b21f59f28644876
-  data.tar.gz: e88226bd6042e3ff224ff5805d1982df1ee4a6b17186440d3edeae820c9f804e1952b3da83dc2b29258a97f5be7685b6d3e163bbab242d83752e468a0d1a4908
+  metadata.gz: 999325d7c1b73c54b80a6a7a2e432e83aaff341997db01211fb43cddffa32448451aaf5c1d92852dfcda872d92b4724d938bacde83621650c20594aaa034ff32
+  data.tar.gz: 7b49bda1bb1026823ca51301a7f61380db7714f9d9441c466ff0a0c2bb50be52e199900e13b0d7c5e8e6782f938c57f38562e9d56439346c62b7abb364d928e5

data/lib/mixin_bot/api/snapshot.rb

@@ -20,11 +20,12 @@ module MixinBot
 
       def snapshots(**options)
         path = format(
-          '/snapshots?limit=%<limit>s&offset=%<offset>s&asset=%<asset>s&opponent=%<opponent>s',
+          '/snapshots?limit=%<limit>s&offset=%<offset>s&asset=%<asset>s&opponent=%<opponent>s&order=%<order>s',
           limit: options[:limit],
           offset: options[:offset],
           asset: options[:asset],
-          opponent: options[:opponent]
+          opponent: options[:opponent],
+          order: options[:order],
         )
 
         access_token = options[:access_token] || access_token('GET', path)

data/lib/mixin_bot/cli/utils.rb

@@ -11,13 +11,7 @@ module MixinBot
 
     desc 'unique UUIDS', 'generate unique UUID for two or more UUIDs'
     def unique(*uuids)
-      uuids.sort
-      r = uuids.first
-      uuids.each_with_index do |uuid, i|
-        r = MixinBot::Utils.unique_uuid(r, uuid) if i.positive?
-      end
-
-      log r
+      log MixinBot::Utils.unique_uuid *uuids
     end
 
     desc 'generatetrace HASH', 'generate trace ID from Tx hash'

data/lib/mixin_bot/utils/nfo.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+module MixinBot
+  module Utils
+    class Nfo
+      NFT_MEMO_PREFIX = 'NFO'
+      NFT_MEMO_VERSION = 0x00
+      NFT_MEMO_DEFAULT_CHAIN = '43d61dcd-e413-450d-80b8-101d5e903357'
+      NFT_MEMO_DEFAULT_CLASS = '3c8c161a18ae2c8b14fda1216fff7da88c419b5d'
+      NULL_UUID = '00000000-0000-0000-0000-000000000000'
+
+      attr_reader :prefix, :version, :raw
+      attr_accessor :mask, :chain, :nm_class, :collection, :token, :extra, :memo, :hex
+
+      def initialize(**kwargs)
+        @prefix = NFT_MEMO_PREFIX
+        @version = NFT_MEMO_VERSION
+        @mask = kwargs[:mask] || 0
+        @chain = kwargs[:chain]
+        @nm_class = kwargs[:nm_class]
+        @collection = kwargs[:collection]
+        @token = kwargs[:token]
+        @extra = kwargs[:extra]
+        @memo = kwargs[:memo]
+        @hex = kwargs[:hex]
+      end
+
+      def mint_memo
+        raise MixinBot::InvalidNfoFormatError, 'token is required' if token.blank?
+        raise MixinBot::InvalidNfoFormatError, 'extra must be 256-bit string' if extra.blank? || extra.size != 64
+
+        @collection = NULL_UUID if collection.blank?
+        @chain = NFT_MEMO_DEFAULT_CHAIN
+        @nm_class= NFT_MEMO_DEFAULT_CLASS
+        mark 0
+        encode
+
+        memo
+      end
+
+      def mark(*indexes)
+        indexes.map do |index|
+          if index >= 64 || index < 0
+            raise ArgumentError, "invalid NFO memo index #{index}"
+          end
+          @mask = mask ^ (1 << index)
+        end
+      end
+
+      def encode
+        bytes = []
+
+        bytes += prefix.bytes 
+        bytes += [version]
+
+        if mask != 0
+          bytes += [1]
+          bytes += MixinBot::Utils.encode_unit_64 mask
+          bytes += MixinBot::Utils::UUID.new(hex: chain).packed.bytes
+
+          class_bytes = [nm_class].pack('H*').bytes
+          bytes += MixinBot::Utils.bytes_of class_bytes.size
+          bytes += class_bytes
+
+          collection_bytes = collection.split('-').pack('H* H* H* H* H*').bytes
+          bytes += MixinBot::Utils.bytes_of collection_bytes.size
+          bytes += collection_bytes
+
+          # token_bytes = memo[:token].split('-').pack('H* H* H* H* H*').bytes
+          token_bytes = MixinBot::Utils.bytes_of token
+          bytes += MixinBot::Utils.bytes_of token_bytes.size
+          bytes += token_bytes
+        end
+
+        extra_bytes = [extra].pack('H*').bytes
+        bytes += MixinBot::Utils.bytes_of extra_bytes.size
+        bytes += extra_bytes
+
+        @raw = bytes.pack('C*')
+        @hex = raw.unpack1('H*')
+        @memo = Base64.urlsafe_encode64 raw, padding: false
+
+        self
+      end
+
+      def decode
+        @raw =
+          if memo.present?
+            Base64.urlsafe_decode64 memo
+          elsif hex.present?
+            [hex].pack('H*')
+          else
+            raise InvalidNfoFormatError, 'memo or hex is required'
+          end
+
+        @hex = raw.unpack1('H*') if hex.blank?
+        @memo = Base64.urlsafe_encode64 raw, padding: false if memo.blank?
+
+        decode_bytes
+        self
+      end
+
+      def decode_bytes
+        bytes = raw.bytes
+
+        _prefix = bytes.shift(3).pack('C*')
+        raise MixinBot::InvalidNfoFormatError, "NFO prefix #{_prefix}" if _prefix != prefix
+
+        _version = bytes.shift
+        raise MixinBot::InvalidNfoFormatError, "NFO version #{prefix}" if _version != version
+
+        hint = bytes.shift
+        if hint == 1
+          @mask = bytes.shift(8).reverse.pack('C*').unpack1('Q*')
+
+          @chain = MixinBot::Utils::UUID.new(hex: bytes.shift(16).pack('C*').unpack1('H*')).unpacked
+
+          class_length = bytes.shift
+          @nm_class = bytes.shift(class_length).pack('C*').unpack1('H*')
+
+          collection_length = bytes.shift
+          @collection = MixinBot::Utils::UUID.new(hex: bytes.shift(collection_length).pack('C*').unpack1('H*')).unpacked
+
+          token_length = bytes.shift
+          @token = MixinBot::Utils.bytes_to_int bytes.shift(token_length)
+        end
+
+        extra_length = bytes.shift
+        @extra = bytes.shift(extra_length).pack('C*').unpack1('H*')
+      end
+
+      def to_h
+        hash = {
+          prefix: prefix,
+          version: version,
+          mask: mask,
+          chain: chain,
+          class: nm_class,
+          collection: collection,
+          token: token,
+          extra: extra,
+          memo: memo,
+          hex: hex
+        }
+
+        hash.each do |key, value|
+          hash.delete key if value.blank?
+        end
+
+        hash
+      end
+    end
+  end
+end

data/lib/mixin_bot/utils/transaction.rb

@@ -0,0 +1,478 @@
+# frozen_string_literal: true
+
+module MixinBot
+  module Utils
+    class Transaction
+      DEAULT_VERSION = 2
+      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]
+
+      attr_accessor :version, :asset, :inputs, :outputs, :extra, :signatures, :aggregated, :hex, :hash
+
+      def initialize(**kwargs)
+        @version = kwargs[:version] || DEAULT_VERSION
+        @asset = kwargs[:asset]
+        @inputs = kwargs[:inputs]
+        @outputs = kwargs[:outputs]
+        @extra = kwargs[:extra]
+        @hex = kwargs[:hex]
+        @signatures = kwargs[:signatures]
+        @aggregated = kwargs[:aggregated]
+      end
+
+      def encode
+        raise InvalidTransactionFormatError, 'asset is required' if asset.blank?
+        raise InvalidTransactionFormatError, 'inputs is required' if inputs.blank?
+        raise InvalidTransactionFormatError, 'outputs is required' if outputs.blank?
+
+        bytes = []
+
+        # magic number
+        bytes += MAGIC
+
+        # version
+        bytes += [0, version]
+
+        # asset
+        bytes += [asset].pack('H*').bytes
+
+        # inputs
+        bytes += encode_inputs
+
+        # output
+        bytes += encode_outputs
+
+        # extra
+        extra_bytes = [extra].pack('H*').bytes
+        bytes += MixinBot::Utils.encode_int extra_bytes.size
+        bytes += extra_bytes
+
+        # aggregated
+        if aggregated.nil?
+          # signatures
+          bytes += encode_signatures
+        else
+          bytes += encode_aggregated_signature
+        end
+
+        @hash = SHA3::Digest::SHA256.hexdigest bytes.pack('C*')
+        @hex = bytes.pack('C*').unpack1('H*')
+
+        self
+      end
+
+      def decode
+        @bytes = [hex].pack('H*').bytes
+        @hash = SHA3::Digest::SHA256.hexdigest @bytes.pack('C*')
+
+        magic = @bytes.shift(2)
+        raise ArgumentError, 'Not valid raw' unless magic == MAGIC
+
+        version = @bytes.shift(2)
+        @version = MixinBot::Utils.bytes_to_int version
+
+        asset = @bytes.shift(32)
+        @asset = asset.pack('C*').unpack1('H*')
+
+        # read inputs
+        decode_inputs
+
+        # read outputs
+        decode_outputs
+
+        extra_size = @bytes.shift(2).reverse.pack('C*').unpack1('S*')
+        @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 ArgumentError, '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
+        else
+          if !@bytes.empty? && @bytes[...2] != NULL_BYTES
+            signatures_size = @bytes.shift(2).reverse.pack('C*').unpack1('S*')
+            @signatures = @bytes.shift(signatures_size).pack('C*').unpack1('H*')
+          end
+        end
+
+        self
+      end
+
+      def to_h
+        {
+          version: version,
+          asset: asset,
+          inputs: inputs,
+          outputs: outputs,
+          extra: extra,
+          signatures: signatures,
+          aggregated: aggregated,
+          hash: hash
+        }.compact
+      end
+
+      private
+
+      def encode_inputs
+        bytes = []
+
+        bytes += MixinBot::Utils.encode_int(inputs.size)
+
+        inputs.each do |input|
+          bytes += [input['hash']].pack('H*').bytes
+          bytes += MixinBot::Utils.encode_int(input['index'])
+
+          # genesis
+          genesis = input['genesis'] || ''
+          if genesis.empty?
+            bytes += NULL_BYTES
+          else
+            genesis_bytes = [genesis].pack('H*').bytes
+            bytes += MixinBot::Utils.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 += MixinBot::Utils.encode_int asset_bytes.size
+            bytes += asset_bytes
+
+            transaction_bytes = [deposit['transaction']].pack('H*')
+            bytes += MixinBot::Utils.encode_int transaction_bytes.size
+            bytes += transaction_bytes
+
+            bytes += MixinBot::Utils.encode_unit_64 deposit['index']
+
+            amount_bytes = MixinBot::Utils.bytes_of deposit['amount']
+            bytes +=  MixinBot::Utils.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 += MixinBot::Utils.encode_int NULL_BYTES
+            else
+              group_bytes = [group].pack('H*')
+              bytes += MixinBot::Utils.encode_int group_bytes.size
+              bytes += group_bytes
+            end
+
+            bytes += MixinBot::Utils.encode_unit_64 mint['batch']
+
+            amount_bytes = MixinBot::Utils.bytes_of mint['amount']
+            bytes +=  MixinBot::Utils.encode_int amount_bytes.size
+            bytes +=  amount_bytes
+          end
+        end
+
+        bytes
+      end
+
+      def encode_outputs
+        bytes = []
+
+        bytes += MixinBot::Utils.encode_int outputs.size
+
+        outputs.each do |output|
+          type = output['type'] || 0
+          bytes += [0x00, type]
+
+          # amount
+          amount_bytes = MixinBot::Utils.bytes_of (output['amount'].to_d * 1e8).round
+          bytes +=  MixinBot::Utils.encode_int amount_bytes.size
+          bytes +=  amount_bytes
+
+          # keys
+          bytes +=  MixinBot::Utils.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 += MixinBot::Utils.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 += MixinBot::Utils.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 += MixinBot::Utils.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 += MixinBot::Utils.encode_int tag.size
+              bytes += address_bytes
+            end
+          end
+        end
+
+        bytes
+      end
+
+      def encode_aggregated_signature
+        bytes = []
+
+        bytes += MixinBot::Utils.encode_int MAX_ENCODE_INT
+        bytes += MixinBot::Utils.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 ArgumentError, 'signers not sorted' if i > 0 && sig <= signers[i - 1]
+            raise ArgumentError, '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 += MixinBot::Utils.encode_int aggregated['signers'].size
+            signers.map(&->(signer) { bytes += MixinBot::Utils.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 += MixinBot::Utils.encode_int masks_bytes.size
+          bytes += masks_bytes
+        end
+
+        bytes
+      end
+
+      def encode_signatures
+        bytes = []
+
+        sl =
+          if signatures.is_a? Hash
+            signatures.keys.size
+          else
+            0
+          end
+
+        raise ArgumentError, 'signatures overflow' if sl == MAX_ENCODE_INT
+        bytes += MixinBot::Utils.encode_int sl
+
+        if sl > 0
+          bytes += MixinBot::Utils.encode_int signatures.keys.size
+          signatures.keys.sort.each do |key|
+            bytes += MixinBot::Utils.encode_int key
+            bytes += [signatures[key]].pack('H*').bytes
+          end
+        end
+
+        bytes
+      end
+
+      def decode_inputs
+        inputs_size = @bytes.shift(2).reverse.pack('C*').unpack1('S*')
+        @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 ArgumentError, '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'] = MixinBot::Utils.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 ArgumentError, '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'] = MixinBot::Utils.bytes_to_int bytes.shift(_amount_size)
+
+            input['mint'] = mint
+          else
+            @bytes.shift 2
+          end
+
+          @inputs.push input
+        end
+
+        self
+      end
+
+      def decode_outputs
+        outputs_size = @bytes.shift(2).reverse.pack('C*').unpack1('S*')
+        @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', MixinBot::Utils.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 ArgumentError, '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
+
+          @outputs.push output
+        end
+
+        self
+      end
+    end
+  end
+end

data/lib/mixin_bot/utils/uuid.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module MixinBot
+  module Utils
+    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
+end

data/lib/mixin_bot/utils.rb

@@ -1,5 +1,9 @@
 # frozen_string_literal: true
 
+require_relative './utils/nfo'
+require_relative './utils/uuid'
+require_relative './utils/transaction'
+
 module MixinBot
   module Utils
     class << self
@@ -10,14 +14,8 @@ module MixinBot
       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(uuid_1, uuid_2)
+      def generate_unique_uuid(uuid_1, uuid_2)
         md5 = Digest::MD5.new
         md5 << [uuid_1, uuid_2].min
         md5 << [uuid_1, uuid_2].max
@@ -25,16 +23,18 @@ module MixinBot
         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..]
-        )
+        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)
@@ -44,13 +44,12 @@ module MixinBot
         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
+        UUID.new(raw: digest).unpacked
       end
 
       def hex_to_uuid(hex)
-        [hex[0..7], hex[8..11], hex[12..15], hex[16..19], hex[20..]].join('-')
+        UUID.new(hex: hex).unpacked
       end
 
       def sign_raw_transaction(tx)
@@ -60,197 +59,27 @@ module MixinBot
         raise ArgumentError, "#{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 ArgumentError, '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 ArgumentError, '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, hash)
-        collection = NULL_UUID if collection.empty?
-        raise ArgumentError, 'hash must be 256-bit string' unless hash.is_a?(String) && hash.size == 64
 
-        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.to_i,
-          extra: hash
-        }
-
-        mark = [0]
-        mark.map do |index|
-          if index >= 64
-            raise ArgumentError, "invalid NFO memo index #{index}"
-          end
-          memo[:mask] = memo[:mask] ^ (1 << index)
-        end
-
-        memo
+        Transaction.new(
+          asset: tx[:asset],
+          inputs: tx[:inputs],
+          outputs: tx[:outputs],
+          extra: tx[:extra],
+        ).encode.hex
       end
 
-      def nft_memo(collection, token_id, hash)
-        encode_nft_memo nft_memo_hash(collection, token_id, hash)
+      def decode_raw_transaction(hex)
+        Transaction.new(hex: hex).decode.to_h
       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
+      def nft_memo(collection, token, extra)
+        MixinBot::Utils::Nfo.new(
+          collection: collection, 
+          token: token, 
+          extra: extra
+        ).mint_memo
       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 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
@@ -283,325 +112,6 @@ module MixinBot
 
         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).round
-          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 ArgumentError, 'signers not sorted' if i > 0 && sig <= signers[i - 1]
-            raise ArgumentError, '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 ArgumentError, '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 ArgumentError, '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 ArgumentError, '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 ArgumentError, '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.7.11'
+  VERSION = '0.8.0'
 end

data/lib/mixin_bot.rb

@@ -2,7 +2,7 @@
 
 # third-party dependencies
 require 'English'
-require 'active_support'
+require 'active_support/all'
 require 'base64'
 require 'bigdecimal'
 require 'bigdecimal/util'
@@ -41,4 +41,7 @@ module MixinBot
   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
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mixin_bot
 version: !ruby/object:Gem::Version
-  version: 0.7.11
+  version: 0.8.0
 platform: ruby
 authors:
 - an-lee
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-03-07 00:00:00.000000000 Z
+date: 2022-03-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -298,6 +298,9 @@ files:
 - lib/mixin_bot/cli/utils.rb
 - lib/mixin_bot/client.rb
 - lib/mixin_bot/utils.rb
+- lib/mixin_bot/utils/nfo.rb
+- lib/mixin_bot/utils/transaction.rb
+- lib/mixin_bot/utils/uuid.rb
 - lib/mixin_bot/version.rb
 homepage: https://github.com/an-lee/mixin_bot
 licenses: