mixin_bot 0.12.1 → 1.1.0

data/lib/mixin_bot/api/inscription.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module MixinBot
+  class API
+    module Inscription
+      def collection(hash)
+        path = "/safe/inscriptions/collections/#{hash}"
+
+        client.get path
+      end
+
+      def collectible(hash)
+        path = "/safe/inscriptions/items/#{hash}"
+
+        client.get path
+      end
+
+      def collectibles(members: [], access_token: nil)
+        unspent_outputs = safe_outputs(state: :unspent, members:, access_token:)['data']
+        unspent_outputs.select { |output| output['inscription_hash'].present? }
+      end
+
+      def create_collectible_transfer(utxo, **kwargs)
+        # verify collectible
+        utxo = utxo.with_indifferent_access
+        raise MixinBot::ArgumentError, 'not a valid collectible' unless utxo['inscription_hash'].present?
+
+        # verify members
+        members = [kwargs[:members]].flatten.compact
+        raise ArgumentError, 'members required' if members.blank?
+
+        threshold = kwargs[:threshold] || members.length
+        request_id = kwargs[:request_id] || kwargs[:trace_id] || SecureRandom.uuid
+
+        memo = kwargs[:memo] || ''
+
+        # build transaction
+        tx = build_safe_transaction(
+          utxos: [utxo],
+          receivers: [{
+            members:,
+            threshold:,
+            amount: utxo['amount']
+          }],
+          extra: memo
+        )
+
+        # encode transaction
+        raw = MixinBot.utils.encode_raw_transaction tx
+
+        # verify transaction
+        request = create_safe_transaction_request(request_id, raw)['data']
+
+        # sign transaction
+        spend_key = MixinBot.utils.decode_key(kwargs[:spend_key]) || config.spend_key
+        signed_raw = MixinBot.api.sign_safe_transaction(
+          raw:,
+          utxos: [utxo],
+          request: request[0],
+          spend_key:
+        )
+
+        # submit transaction
+        send_safe_transaction(
+          request_id,
+          signed_raw
+        )
+      end
+    end
+  end
+end

data/lib/mixin_bot/api/legacy_collectible.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module MixinBot
+  class API
+    module LegacyCollectible
+      NFT_ASSET_MIXIN_ID = '1700941284a95f31b25ec8c546008f208f88eee4419ccdcdbe6e3195e60128ca'
+
+      def legacy_collectible(id, access_token: nil)
+        path = "/collectibles/tokens/#{id}"
+        client.get path, access_token:
+      end
+
+      def legacy_collection(id, access_token: nil)
+        path = "/collectibles/collections/#{id}"
+        client.get path, access_token:
+      end
+
+      def legacy_collectibles(**kwargs)
+        limit = kwargs[:limit] || 100
+        offset = kwargs[:offset] || ''
+        state = kwargs[:state] || ''
+
+        members = kwargs[:members] || [config.app_id]
+        threshold = kwargs[:threshold] || members.length
+
+        members = SHA3::Digest::SHA256.hexdigest(members&.sort&.join)
+
+        access_token = kwargs[:access_token]
+
+        path = '/collectibles/outputs'
+        params = {
+          limit:,
+          offset:,
+          state:,
+          members:,
+          threshold:
+        }
+
+        client.get path, **params, access_token:
+      end
+
+      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:,
+          raw:
+        }
+        client.post path, **payload, access_token:
+      end
+
+      def create_sign_collectible_request(raw, access_token: nil)
+        create_collectible_request 'sign', raw, access_token:
+      end
+
+      def create_unlock_collectible_request(raw, access_token: nil)
+        create_collectible_request 'unlock', raw, access_token:
+      end
+
+      def sign_collectible_request(request_id, pin = nil)
+        pin ||= config.pin
+        raise ArgumentError, 'pin is needed for sign collectible request' if pin.blank?
+
+        path = format('/collectibles/requests/%<request_id>s/sign', request_id:)
+        payload =
+          if pin.length > 6
+            pin_base64 =  encrypt_tip_pin(pin, 'TIP:COLLECTIBLE:REQUEST:SIGN:', request_id)
+            {
+              pin_base64:
+            }
+          else
+            {
+              pin: encrypt_pin(pin)
+            }
+          end
+        client.post path, **payload
+      end
+
+      def unlock_collectible_request(request_id, pin = nil)
+        pin ||= config.pin
+        raise ArgumentError, 'pin is needed for sign collectible request' if pin.blank?
+
+        path = format('/collectibles/requests/%<request_id>s/unlock', request_id:)
+        payload =
+          if pin.length > 6
+            {
+              pin_base64: encrypt_tip_pin(pin, 'TIP:COLLECTIBLE:REQUEST:UNLOCK:', request_id)
+            }
+          else
+            {
+              pin: encrypt_pin(pin)
+            }
+          end
+
+        client.post path, **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 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 spent' if collectible['state'] == 'spent'
+
+      build_raw_transaction(
+        utxos: [collectible],
+        senders: collectible['receivers'],
+        senders_threshold: collectible['receivers_threshold'],
+        receivers: kwargs['receivers'],
+        receivers_threshold: kwargs['receivers_threshold'],
+        extra: [kwargs['nfo']].pack('H*'),
+        amount: 1,
+        asset_mixin_id: NFT_ASSET_MIXIN_ID,
+        hint: kwargs['hint']
+      )
+    end
+
+    def nft_memo(collection, token_id, meta)
+      MixinBot.utils.nft_memo collection, token_id, meta
+    end
+  end
+end

data/lib/mixin_bot/api/legacy_multisig.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module MixinBot
+  class API
+    module LegacyMultisig
+      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:,
+          raw:
+        }
+        client.post path, **payload, access_token:
+      end
+
+      # transfer from the multisig address
+      def create_sign_multisig_request(raw, access_token: nil)
+        create_multisig_request 'sign', raw, 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:
+      end
+
+      def sign_multisig_request(request_id, pin = nil)
+        pin ||= config.pin
+        path = format('/multisigs/requests/%<request_id>s/sign', request_id:)
+        payload =
+          if pin.length > 6
+            {
+              pin_base64: encrypt_tip_pin(pin, 'TIP:MULTISIG:REQUEST:SIGN:', request_id)
+            }
+          else
+            {
+              pin: encrypt_pin(pin)
+            }
+          end
+
+        client.post path, **payload
+      end
+
+      def unlock_multisig_request(request_id, pin = nil)
+        pin ||= config.pin
+
+        path = format('/multisigs/requests/%<request_id>s/unlock', request_id:)
+        payload =
+          if pin.length > 6
+            {
+              pin_base64: encrypt_tip_pin(pin, 'TIP:MULTISIG:REQUEST:UNLOCK:', request_id)
+            }
+          else
+            {
+              pin: encrypt_pin(pin)
+            }
+          end
+
+        client.post path, **payload
+      end
+
+      # pay to the multisig address
+      # used for create multisig payment code_id
+      def create_multisig_payment(**kwargs)
+        path = '/payments'
+        payload = {
+          asset_id: kwargs[:asset_id],
+          amount: format('%.8f', kwargs[:amount].to_d),
+          trace_id: kwargs[:trace_id] || SecureRandom.uuid,
+          memo: kwargs[:memo],
+          opponent_multisig: {
+            receivers: kwargs[:receivers],
+            threshold: kwargs[:threshold]
+          }
+        }
+        client.post path, **payload, access_token: kwargs[:access_token]
+      end
+
+      def verify_multisig(code_id, access_token: nil)
+        path = format('/codes/%<code_id>s', code_id:)
+        client.get path, access_token:
+      end
+    end
+  end
+end

data/lib/mixin_bot/api/legacy_output.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module MixinBot
+  class API
+    module LegacyOutput
+      def legacy_outputs(**kwargs)
+        limit = kwargs[:limit] || 100
+        offset = kwargs[:offset] || ''
+        state = kwargs[:state] || ''
+        members = kwargs[:members] || []
+        threshold = kwargs[:threshold] || ''
+        access_token = kwargs[:access_token]
+        members = SHA3::Digest::SHA256.hexdigest(members&.sort&.join)
+
+        path = '/multisigs/outputs'
+        params = {
+          limit:,
+          offset:,
+          state:,
+          members:,
+          threshold:
+        }.compact_blank
+
+        client.get path, **params, access_token:
+      end
+      alias multisigs legacy_outputs
+      alias multisig_outputs legacy_outputs
+
+      def create_output(receivers:, index:, hint: nil, access_token: nil)
+        path = '/outputs'
+        payload = {
+          receivers:,
+          index:,
+          hint:
+        }
+        client.post path, **payload, access_token:
+      end
+
+      def build_output(receivers:, index:, amount:, threshold:, hint: nil)
+        _output = create_output(receivers:, index:, hint:)
+        {
+          amount: format('%.8f', amount.to_d.to_r),
+          script: build_threshold_script(threshold),
+          mask: _output['mask'],
+          keys: _output['keys']
+        }
+      end
+    end
+  end
+end

data/lib/mixin_bot/api/legacy_payment.rb

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

data/lib/mixin_bot/api/legacy_snapshot.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module MixinBot
+  class API
+    module LegacySnapshot
+      def network_snapshots(**kwargs)
+        path = '/network/snapshots'
+        params = {
+          limit: kwargs[:limit],
+          offset: kwargs[:offset],
+          asset: kwargs[:asset],
+          order: kwargs[:order]
+        }
+
+        client.get path, **params, access_token: kwargs[:access_token]
+      end
+
+      def snapshots(**kwargs)
+        path = '/snapshots'
+
+        params = {
+          limit: kwargs[:limit],
+          offset: kwargs[:offset],
+          asset: kwargs[:asset],
+          opponent: kwargs[:opponent],
+          order: kwargs[:order]
+        }
+
+        client.get path, **params, access_token: kwargs[:access_token]
+      end
+
+      def network_snapshot(snapshot_id, **kwargs)
+        path = format('/network/snapshots/%<snapshot_id>s', snapshot_id:)
+
+        client.get path, access_token: kwargs[:access_token]
+      end
+    end
+  end
+end

data/lib/mixin_bot/api/legacy_transaction.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+module MixinBot
+  class API
+    module LegacyTransaction
+      LEGACY_TX_VERSION = 0x04
+
+      # use safe transaction protocol instead
+      # kwargs:
+      # {
+      #   senders: [ uuid ],
+      #   senders_threshold: integer,
+      #   receivers: [ uuid ],
+      #   receivers_threshold: integer,
+      #   asset_id: uuid,
+      #   amount: string / float,
+      #   memo: string,
+      # }
+      RAW_TRANSACTION_ARGUMENTS = %i[utxos senders senders_threshold receivers receivers_threshold amount].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]
+        senders_threshold   = kwargs[:senders_threshold]
+        receivers           = kwargs[:receivers]
+        receivers_threshold = kwargs[:receivers_threshold]
+        amount              = kwargs[:amount]
+        asset_id            = kwargs[:asset_id]
+        asset_mixin_id      = kwargs[:asset_mixin_id]
+        utxos               = kwargs[:utxos]
+        extra               = kwargs[:extra]
+        access_token        = kwargs[:access_token]
+        outputs             = kwargs[:outputs] || []
+        hint                = kwargs[:hint]
+        version             = kwargs[:version] || LEGACY_TX_VERSION
+
+        raise 'access_token required!' if access_token.nil? && !senders.include?(config.app_id)
+
+        amount = amount.to_d.round(8)
+        input_amount = utxos.map(
+          &lambda { |utxo|
+            utxo['amount'].to_d
+          }
+        ).sum
+
+        if input_amount < amount
+          raise format(
+            'not enough amount! %<input_amount>s < %<amount>s',
+            input_amount:,
+            amount:
+          )
+        end
+
+        inputs = utxos.map(
+          &lambda { |utx|
+            {
+              'hash' => utx['transaction_hash'],
+              'index' => utx['output_index']
+            }
+          }
+        )
+
+        if outputs.empty?
+          receivers_threshold = 1 if receivers.size == 1
+          output0 = build_output(
+            receivers:,
+            index: 0,
+            amount:,
+            threshold: receivers_threshold,
+            hint:
+          )
+          outputs.push output0
+
+          if input_amount > amount
+            output1 = build_output(
+              receivers: senders,
+              index: 1,
+              amount: input_amount - amount,
+              threshold: senders_threshold,
+              hint:
+            )
+            outputs.push output1
+          end
+        end
+
+        asset = asset_mixin_id || SHA3::Digest::SHA256.hexdigest(asset_id)
+        {
+          version:,
+          asset:,
+          inputs:,
+          outputs:,
+          extra:
+        }
+      end
+
+      # use safe transaction protocol instead
+      MULTISIG_TRANSACTION_ARGUMENTS = %i[asset_id receivers threshold amount].freeze
+      def create_multisig_transaction(pin, **options)
+        raise ArgumentError, "#{MULTISIG_TRANSACTION_ARGUMENTS.join(', ')} are needed for create multisig transaction" unless MULTISIG_TRANSACTION_ARGUMENTS.all? { |param| options.keys.include? param }
+
+        asset_id = options[:asset_id]
+        receivers = options[:receivers].sort
+        threshold = options[:threshold]
+        amount = format('%.8f', options[:amount].to_d.to_r)
+        memo = options[:memo]
+        trace_id = options[:trace_id] || SecureRandom.uuid
+
+        path = '/transactions'
+        payload = {
+          asset_id:,
+          opponent_multisig: {
+            receivers:,
+            threshold:
+          },
+          amount:,
+          trace_id:,
+          memo:
+        }
+
+        if pin.length > 6
+          payload[:pin_base64] = encrypt_tip_pin(pin, 'TIP:TRANSACTION:CREATE:', asset_id, receivers.join, threshold, amount, trace_id, memo)
+        else
+          payload[:pin] = encrypt_pin(pin)
+        end
+
+        client.post path, **payload
+      end
+
+      # use safe transaction protocol instead
+      MAINNET_TRANSACTION_ARGUMENTS = %i[asset_id opponent_id amount].freeze
+      def create_mainnet_transaction(pin, **options)
+        raise ArgumentError, "#{MAINNET_TRANSACTION_ARGUMENTS.join(', ')} are needed for create main net transactions" unless MAINNET_TRANSACTION_ARGUMENTS.all? { |param| options.keys.include? param }
+
+        asset_id = options[:asset_id]
+        opponent_id = options[:opponent_id]
+        amount = format('%.8f', options[:amount].to_d)
+        memo = options[:memo]
+        trace_id = options[:trace_id] || SecureRandom.uuid
+
+        path = '/transactions'
+        payload = {
+          asset_id:,
+          opponent_id:,
+          amount:,
+          trace_id:,
+          memo:
+        }
+
+        if pin.length > 6
+          payload[:pin_base64] = encrypt_tip_pin(pin, 'TIP:TRANSACTION:CREATE:', asset_id, opponent_id, amount, trace_id, memo)
+        else
+          payload[:pin] = encrypt_pin(pin)
+        end
+
+        client.post path, **payload
+      end
+
+      # use safe transaction protocol instead
+      def transactions(**options)
+        path = '/external/transactions'
+        params = {
+          limit: options[:limit],
+          offset: options[:offset],
+          asset: options[:asset],
+          destination: options[:destination],
+          tag: options[:tag]
+        }
+
+        client.get path, **params
+      end
+    end
+  end
+end

data/lib/mixin_bot/api/legacy_transfer.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module MixinBot
+  class API
+    module LegacyTransfer
+      TRANSFER_ARGUMENTS = %i[asset_id opponent_id amount].freeze
+      def create_transfer(pin, **kwargs)
+        raise ArgumentError, "#{TRANSFER_ARGUMENTS.join(', ')} are needed for create transfer" unless TRANSFER_ARGUMENTS.all? { |param| kwargs.keys.include? param }
+
+        asset_id = kwargs[:asset_id]
+        opponent_id = kwargs[:opponent_id]
+        amount = format('%.8f', kwargs[:amount].to_d.to_r).gsub(/\.?0+$/, '')
+        trace_id = kwargs[:trace_id] || SecureRandom.uuid
+        memo = kwargs[:memo] || ''
+
+        payload = {
+          asset_id:,
+          opponent_id:,
+          amount:,
+          trace_id:,
+          memo:
+        }
+
+        if pin.length > 6
+          pin_base64 = encrypt_tip_pin pin, 'TIP:TRANSFER:CREATE:', asset_id, opponent_id, amount, trace_id, memo
+          payload[:pin_base64] = pin_base64
+        else
+          encrypted_pin = encrypt_pin pin
+          payload[:pin] = encrypted_pin
+        end
+
+        path = '/transfers'
+        client.post path, **payload
+      end
+
+      def transfer(trace_id, access_token: nil)
+        path = format('/transfers/trace/%<trace_id>s', trace_id:)
+        client.get path, access_token:
+      end
+    end
+  end
+end

data/lib/mixin_bot/api/me.rb

@@ -3,37 +3,33 @@
 module MixinBot
   class API
     module Me
-      # https://developers.mixin.one/api/beta-mixin-message/read-profile/
       def me(access_token: nil)
         path = '/me'
-        access_token ||= access_token('GET', path, '')
-        authorization = format('Bearer %<access_token>s', access_token: access_token)
-        client.get(path, headers: { 'Authorization': authorization })
+        client.get path, access_token:
       end
-      alias read_me me
 
-      # https://developers.mixin.one/api/beta-mixin-message/update-profile/
       # avatar_base64:
-      # String: Base64 of image, supports format png, jpeg and gif, base64 image size > 1024.
-      def update_me(full_name:, avatar_base64: nil, access_token: nil)
+      #   String: Base64 of image, supports format png, jpeg and gif, base64 image size > 1024.
+      def update_me(**kwargs)
         path = '/me'
         payload = {
-          full_name: full_name,
-          avatar_base64: avatar_base64
+          full_name: kwargs[:full_name],
+          avatar_base64: kwargs[:avatar_base64],
+          access_token: kwargs[:access_token]
         }
-        access_token ||= access_token('POST', path, payload.to_json)
-        authorization = format('Bearer %<access_token>s', access_token: access_token)
-        client.post(path, headers: { 'Authorization': authorization }, json: payload)
+        client.post path, **payload
       end
 
       # https://developers.mixin.one/api/beta-mixin-message/friends/
       def friends(access_token: nil)
         path = '/friends'
-        access_token ||= access_token('GET', path, '')
-        authorization = format('Bearer %<access_token>s', access_token: access_token)
-        client.get(path, headers: { 'Authorization': authorization })
+        client.get path, access_token:
+      end
+
+      def safe_me(access_token: nil)
+        path = '/safe/me'
+        client.get path, access_token:
       end
-      alias read_friends friends
     end
   end
 end