mixin_bot 1.4.0 → 2.0.0

data/lib/mixin_bot/api/message.rb

@@ -1,4 +1,4 @@
-# frozen_string_literal: false
+# frozen_string_literal: true
 
 module MixinBot
   class API
@@ -17,65 +17,56 @@ module MixinBot
       end
 
       def plain_text(options)
-        options.merge!(category: 'PLAIN_TEXT')
-        base_message_params(options)
+        base_message_params(options.merge(category: 'PLAIN_TEXT'))
       end
 
       def plain_post(options)
-        options.merge!(category: 'PLAIN_POST')
-        base_message_params(options)
+        base_message_params(options.merge(category: 'PLAIN_POST'))
       end
 
       def plain_image(options)
-        options.merge!(category: 'PLAIN_IMAGE')
-        base_message_params(options)
+        base_message_params(options.merge(category: 'PLAIN_IMAGE'))
       end
 
       def plain_data(options)
-        options.merge!(category: 'PLAIN_DATA')
-        base_message_params(options)
+        base_message_params(options.merge(category: 'PLAIN_DATA'))
       end
 
       def plain_sticker(options)
-        options.merge!(category: 'PLAIN_STICKER')
-        base_message_params(options)
+        base_message_params(options.merge(category: 'PLAIN_STICKER'))
       end
 
       def plain_contact(options)
-        options.merge!(category: 'PLAIN_CONTACT')
-        base_message_params(options)
+        base_message_params(options.merge(category: 'PLAIN_CONTACT'))
       end
 
       def plain_audio(options)
-        options.merge!(category: 'PLAIN_AUDIO')
-        base_message_params(options)
+        base_message_params(options.merge(category: 'PLAIN_AUDIO'))
       end
 
       def plain_video(options)
-        options.merge!(category: 'PLAIN_VIDEO')
-        base_message_params(options)
+        base_message_params(options.merge(category: 'PLAIN_VIDEO'))
       end
 
       def app_card(options)
-        options.merge!(category: 'APP_CARD')
-        base_message_params(options)
+        base_message_params(options.merge(category: 'APP_CARD'))
       end
 
       def app_button_group(options)
-        options.merge!(category: 'APP_BUTTON_GROUP')
-        base_message_params(options)
+        base_message_params(options.merge(category: 'APP_BUTTON_GROUP'))
       end
 
       def recall_message_params(message_id, options)
         raise 'recipient_id is required!' if options[:recipient_id].nil?
 
-        options.merge!(
-          category: 'MESSAGE_RECALL',
-          data: {
-            message_id:
-          }
+        base_message_params(
+          options.merge(
+            category: 'MESSAGE_RECALL',
+            data: {
+              message_id:
+            }
+          )
         )
-        base_message_params(options)
       end
 
       # base format of message params

data/lib/mixin_bot/api/multisig.rb

@@ -34,6 +34,25 @@ module MixinBot
 
         client.get path, access_token:
       end
+      alias fetch_safe_multisig_request safe_multisig_request
+
+      def create_multisig_raw_tx(_asset_id:, senders:, receivers:, threshold:, inputs:, amount:, trace_id:,
+                                 extra: '')
+        out_hint = MixinBot.utils.unique_object_id(trace_id, 'OUTPUT', '0')
+        change_hint = MixinBot.utils.unique_object_id(trace_id, 'OUTPUT', '1')
+        keys = create_safe_keys(
+          { receivers:, index: 0, hint: out_hint },
+          { receivers: senders, index: 1, hint: change_hint }
+        )['data']
+
+        receivers_list = [
+          { members: receivers, threshold: 1, amount: amount.to_s, ghosts: [keys[0]] },
+          { members: senders, threshold:, amount: nil, ghosts: [keys[1]] }
+        ].compact
+
+        tx = build_safe_transaction(utxos: inputs, receivers: receivers_list, extra:)
+        MixinBot.utils.encode_raw_transaction(tx)
+      end
     end
   end
 end

data/lib/mixin_bot/api/network.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module MixinBot
+  class API
+    module Network
+      def network_assets
+        client.get '/network', access_token: ''
+      end
+      alias read_network_assets network_assets
+
+      def network_assets_top
+        client.get '/network/assets/top', access_token: ''
+      end
+      alias read_network_assets_top network_assets_top
+    end
+  end
+end

data/lib/mixin_bot/api/network_asset.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'cgi'
+
+module MixinBot
+  class API
+    module NetworkAsset
+      def network_asset(asset_id)
+        path = format('/network/assets/%<asset_id>s', asset_id:)
+        client.get path, access_token: ''
+      end
+      alias read_asset network_asset
+
+      def network_ticker(asset_id, offset: nil, access_token: nil)
+        params = { asset: asset_id, offset: }.compact
+        client.get '/network/ticker', **params, access_token: access_token || ''
+      end
+      alias read_asset_ticker network_ticker
+
+      def network_asset_search(name)
+        path = "/network/assets/search/#{CGI.escape(name.to_s)}"
+        client.get path, access_token: ''
+      end
+      alias asset_search network_asset_search
+    end
+  end
+end

data/lib/mixin_bot/api/output.rb

@@ -21,7 +21,7 @@ module MixinBot
         members = kwargs[:members].presence || [config.app_id]
         threshold = kwargs[:threshold] || members.length
 
-        members_hash = SHA3::Digest::SHA256.hexdigest(members&.sort&.join)
+        members_hash = MixinBot.utils.hash_members(members)
 
         path = '/safe/outputs'
         params = {

data/lib/mixin_bot/api/pin.rb

@@ -21,12 +21,13 @@ module MixinBot
             }
           else
             {
-              pin: MixinBot.utils.encrypt_pin(pin)
+              pin: encrypt_pin(pin)
             }
           end
 
         client.post path, **payload
       end
+      alias verify_pin_tip verify_pin
 
       # https://developers.mixin.one/api/alpha-mixin-network/create-pin/
       def update_pin(pin:, old_pin: nil)
@@ -45,6 +46,17 @@ module MixinBot
         client.post path, **payload
       end
 
+      def update_tip_pin(pin, pub_tip)
+        old_encrypted = encrypt_pin(pin, iterator: (Time.now.utc.to_f * 1e9).to_i)
+        pub_buf = [pub_tip].pack('H*')
+        raise ArgumentError, 'invalid public key' unless pub_buf.bytesize == 32
+
+        pub_tip_buf = pub_buf + [1].pack('Q>')
+        encrypted_pin = encrypt_pin(pub_tip_buf.unpack1('H*'), iterator: (Time.now.utc.to_f * 1e9).to_i + 1)
+        path = '/pin/update'
+        client.post path, old_pin_base64: old_encrypted, pin_base64: encrypted_pin
+      end
+
       def prepare_tip_key(counter = 0)
         ed25519_key = JOSE::JWA::Ed25519.keypair
 
@@ -57,8 +69,9 @@ module MixinBot
         }
       end
 
-      def encrypt_pin(pin, iterator: nil)
-        MixinBot.utils.encrypt_pin(pin, iterator:, shared_key: generate_shared_key_with_server)
+      def encrypt_pin(pin, iterator: nil, shared_key: nil)
+        sk = shared_key.presence || generate_shared_key_with_server
+        MixinBot.utils.encrypt_pin(pin, iterator:, shared_key: sk)
       end
 
       def decrypt_pin(msg)

data/lib/mixin_bot/api/pin_payload.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module MixinBot
+  class API
+    ##
+    # Shared helpers for legacy 6-digit PIN vs TIP (+pin_base64+) payloads.
+    #
+    module PinPayload
+      private
+
+      ##
+      # @return [Hash] either +{ pin: ... }+ or +{ pin_base64: ... }+
+      #
+      def tip_or_legacy_pin_payload(pin, tip_action, *tip_params)
+        p = pin
+        raise ArgumentError, 'pin is required' if p.blank?
+
+        if p.to_s.length > 6
+          { pin_base64: encrypt_tip_pin(p, tip_action, *tip_params) }
+        else
+          { pin: encrypt_pin(p) }
+        end
+      end
+    end
+  end
+end

data/lib/mixin_bot/api/session.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module MixinBot
+  class API
+    module Session
+      def fetch_user_sessions(user_ids, access_token: nil)
+        raise ArgumentError, 'user_ids required' if user_ids.blank?
+
+        client.fetch_post_array '/sessions/fetch', Array(user_ids), access_token:
+      end
+      alias fetch_user_session fetch_user_sessions
+    end
+  end
+end

data/lib/mixin_bot/api/snapshot.rb

@@ -17,6 +17,12 @@ module MixinBot
         client.get path, **params
       end
 
+      def safe_snapshot(snapshot_id, access_token: nil)
+        path = format('/safe/snapshots/%<snapshot_id>s', snapshot_id:)
+        client.get path, access_token:
+      end
+      alias safe_snapshot_by_id safe_snapshot
+
       def create_safe_snapshot_notification(**kwargs)
         path = '/safe/snapshots/notifications'
 

data/lib/mixin_bot/api/tip.rb

@@ -17,6 +17,7 @@ module MixinBot
         TIP:COLLECTIBLE:REQUEST:SIGN:
         TIP:COLLECTIBLE:REQUEST:UNLOCK:
         TIP:TRANSFER:CREATE:
+        TIP:WITHDRAW:
         TIP:WITHDRAWAL:CREATE:
         TIP:TRANSACTION:CREATE:
         TIP:OAUTH:APPROVE:
@@ -30,7 +31,7 @@ module MixinBot
 
         pin_key = MixinBot.utils.decode_key pin
 
-        msg = action + params.flatten.map(&:to_s).join
+        msg = action + params.join
 
         msg = Digest::SHA256.digest(msg) unless action == 'TIP:VERIFY:'
 
@@ -38,6 +39,78 @@ module MixinBot
 
         encrypt_pin signature
       end
+
+      def get_tip_node(path, request_id: nil, access_token: nil)
+        url = format('/external/tip/%<path>s', path:)
+        if request_id.present?
+          client.fetch_get url, access_token: access_token || ''
+        else
+          client.get url, access_token: access_token || ''
+        end
+      end
+      alias get_tip_node_by_path get_tip_node
+
+      def tip_migrate_body(pub_hex)
+        "TIP:MIGRATE:#{pub_hex}"
+      end
+
+      def tip_body_for_verify(timestamp = (Time.now.to_f * 1e9).to_i)
+        format('TIP:VERIFY:%032d', timestamp)
+      end
+
+      def tip_body_for_raw_transaction_create(asset_id, opponent_key, opponent_receivers, opponent_threshold, amount,
+                                              trace_id, memo)
+        receivers = Array(opponent_receivers).join
+        format(
+          'TIP:TRANSACTION:CREATE:%<asset_id>s%<opponent_key>s%<receivers>s%<opponent_threshold>s%<amount>s%<trace_id>s%<memo>s',
+          asset_id:, opponent_key:, receivers:, opponent_threshold:, amount:, trace_id:, memo:
+        )
+      end
+
+      def tip_body_for_withdrawal_create(address_id, amount, fee, trace_id, memo)
+        format(
+          'TIP:WITHDRAWAL:CREATE:%<address_id>s%<amount>s%<fee>s%<trace_id>s%<memo>s',
+          address_id:, amount:, fee:, trace_id:, memo:
+        )
+      end
+
+      def tip_body_for_transfer(asset_id, counter_user_id, amount, trace_id, memo)
+        format(
+          'TIP:TRANSFER:CREATE:%<asset_id>s%<counter_user_id>s%<amount>s%<trace_id>s%<memo>s',
+          asset_id:, counter_user_id:, amount:, trace_id:, memo:
+        )
+      end
+
+      def tip_body_for_phone_number_update(verification_id, code)
+        format('TIP:PHONE:NUMBER:UPDATE:%<verification_id>s%<code>s', verification_id:, code:)
+      end
+
+      def tip_body_for_emergency_contact_create(verification_id, code)
+        format('TIP:EMERGENCY:CONTACT:CREATE:%<verification_id>s%<code>s', verification_id:, code:)
+      end
+
+      def tip_body_for_address_add(asset_id, public_key, key_tag, name)
+        format(
+          'TIP:ADDRESS:ADD:%<asset_id>s%<public_key>s%<key_tag>s%<name>s',
+          asset_id:, public_key:, key_tag:, name:
+        )
+      end
+
+      def tip_body_for_provisioning_update(device_id, secret)
+        format('TIP:PROVISIONING:UPDATE:%<device_id>s%<secret>s', device_id:, secret:)
+      end
+
+      def tip_body_for_ownership_transfer(user_id)
+        format('TIP:APP:OWNERSHIP:TRANSFER:%<user_id>s', user_id:)
+      end
+
+      def tip_body_for_sequencer_register(user_id, public_key)
+        format('SEQUENCER:REGISTER:%<user_id>s%<public_key>s', user_id:, public_key:)
+      end
+
+      def tip_body(str)
+        str.to_s.b
+      end
     end
   end
 end

data/lib/mixin_bot/api/transaction.rb

@@ -36,7 +36,7 @@ module MixinBot
         recipients.each_with_index do |recipient, index|
           next if recipient[:mix_address].blank?
 
-          if recipient[:members].all?(&->(m) { m.start_with? MixinBot::Utils::Address::MAIN_ADDRESS_PREFIX })
+          if recipient[:members].all?(&->(m) { m.start_with? MixinBot::MAIN_ADDRESS_PREFIX })
             key = JOSE::JWA::Ed25519.keypair
             gk = {
               mask: key[0].unpack1('H*'),
@@ -54,7 +54,7 @@ module MixinBot
 
             ghost_keys[index] = gk.with_indifferent_access
 
-          elsif recipient[:members].none?(&->(m) { m.start_with? MixinBot::Utils::Address::MAIN_ADDRESS_PREFIX })
+          elsif recipient[:members].none?(&->(m) { m.start_with? MixinBot::MAIN_ADDRESS_PREFIX })
             uuid_recipients.push(
               {
                 receivers: recipient[:members],
@@ -88,7 +88,12 @@ module MixinBot
       # }
       SAFE_RAW_TRANSACTION_ARGUMENTS = %i[utxos receivers].freeze
       def build_safe_transaction(**kwargs)
-        raise ArgumentError, "#{SAFE_RAW_TRANSACTION_ARGUMENTS.join(', ')} are needed for build safe transaction" unless SAFE_RAW_TRANSACTION_ARGUMENTS.all? { |param| kwargs.keys.include? param }
+        unless SAFE_RAW_TRANSACTION_ARGUMENTS.all? do |param|
+                 kwargs.keys.include? param
+               end
+          raise ArgumentError,
+                "#{SAFE_RAW_TRANSACTION_ARGUMENTS.join(', ')} are needed for build safe transaction"
+        end
         raise ArgumentError, 'receivers should be an array' unless kwargs[:receivers].is_a? Array
         raise ArgumentError, 'utxos should be an array' unless kwargs[:utxos].is_a? Array
 
@@ -126,10 +131,20 @@ module MixinBot
         end
         raise ArgumentError, 'recipients too many' if recipients.size > 256
 
-        asset = utxos[0]['asset']
+        mixin_asset_for = lambda do |u|
+          h = u.with_indifferent_access
+          next h[:asset] if h[:asset].present?
+
+          aid = h[:asset_id]
+          raise ArgumentError, 'utxo asset_id or asset is required' if aid.blank?
+
+          SHA3::Digest::SHA256.hexdigest(aid)
+        end
+
+        asset = mixin_asset_for.call(utxos[0])
         inputs = []
         utxos.each do |utxo|
-          raise ArgumentError, 'utxo asset not match' unless utxo['asset'] == asset
+          raise ArgumentError, 'utxo asset not match' unless mixin_asset_for.call(utxo) == asset
 
           inputs << {
             hash: utxo['transaction_hash'],
@@ -171,6 +186,17 @@ module MixinBot
         }
       end
 
+      def verify_raw_transaction(requests)
+        requests = Array(requests).map do |r|
+          r = r.with_indifferent_access
+          { request_id: r[:request_id], raw: r[:raw] }
+        end
+        create_safe_transaction_request(requests.first[:request_id], requests.first[:raw]) if requests.one?
+
+        path = '/safe/transaction/requests'
+        client.post path, *requests
+      end
+
       def create_safe_transaction_request(request_id, raw)
         path = '/safe/transaction/requests'
         payload = [{
@@ -181,25 +207,73 @@ module MixinBot
         client.post path, *payload
       end
 
-      def send_safe_transaction(request_id, raw)
+      def send_safe_transaction(request_id, raw = nil, requests: nil)
         path = '/safe/transactions'
-        payload = [{
-          request_id:,
-          raw:
-        }]
+        payload =
+          if requests.present?
+            Array(requests).map { |r| r.with_indifferent_access.slice(:request_id, :raw) }
+          else
+            [{ request_id:, raw: }]
+          end
 
         client.post path, *payload
       end
+      alias send_raw_transaction send_safe_transaction
 
       def safe_transaction(request_id, access_token: nil)
         path = format('/safe/transactions/%<request_id>s', request_id:)
 
         client.get path, access_token:
       end
+      alias get_transaction_by_id safe_transaction
+      alias get_transaction_by_id_with_safe_user safe_transaction
+
+      def estimate_storage_cost(extra)
+        step = BigDecimal(EXTRA_STORAGE_PRICE_STEP)
+        len = extra.to_s.bytesize
+        steps = (len / 1024) + 1
+        step * steps
+      end
+
+      def storage_recipient
+        MixinBot::MixAddress.from_members(
+          members: [MixinBot.utils.burning_address],
+          threshold: 64
+        )
+      end
+
+      def create_object_storage_transaction(extra:, trace_id:, _references: nil, limit: nil, utxos: nil, **transfer_opts)
+        amount = estimate_storage_cost(extra)
+        amount = [amount, BigDecimal(limit.to_s)].max if limit.present?
+        kwargs = {
+          asset_id: XIN_ASSET_ID,
+          amount: amount.to_s('F'),
+          trace_id:,
+          memo: extra.to_s,
+          **transfer_opts
+        }
+        kwargs[:utxos] = utxos if utxos.present?
+        kwargs[:members] = [config.app_id] unless kwargs.key?(:members)
+        create_safe_transfer(**kwargs)
+      end
+
+      def request_ghost_recipients_with_trace_id(recipients, _trace_id)
+        generate_safe_keys(
+          recipients.map do |r|
+            r = r.with_indifferent_access
+            { members: r[:members], threshold: r[:threshold], mix_address: r[:mix_address] }
+          end
+        )
+      end
 
       SIGN_SAFE_TRANSACTION_ARGUMENTS = %i[raw utxos request spend_key].freeze
       def sign_safe_transaction(**kwargs)
-        raise ArgumentError, "#{SIGN_SAFE_TRANSACTION_ARGUMENTS.join(', ')} are needed for sign safe transaction" unless SIGN_SAFE_TRANSACTION_ARGUMENTS.all? { |param| kwargs.keys.include? param }
+        unless SIGN_SAFE_TRANSACTION_ARGUMENTS.all? do |param|
+                 kwargs.keys.include? param
+               end
+          raise ArgumentError,
+                "#{SIGN_SAFE_TRANSACTION_ARGUMENTS.join(', ')} are needed for sign safe transaction"
+        end
 
         raw = kwargs[:raw]
         tx = MixinBot.utils.decode_raw_transaction raw
@@ -265,7 +339,12 @@ module MixinBot
 
       INSCRIBE_TRANSACTION_ARGUMENTS = %i[content collection_hash].freeze
       def build_inscribe_transaction(**kwargs)
-        raise ArgumentError, "#{INSCRIBE_TRANSACTION_ARGUMENTS.join(', ')} are needed for inscribe transaction" unless INSCRIBE_TRANSACTION_ARGUMENTS.all? { |param| kwargs.keys.include? param }
+        unless INSCRIBE_TRANSACTION_ARGUMENTS.all? do |param|
+                 kwargs.keys.include? param
+               end
+          raise ArgumentError,
+                "#{INSCRIBE_TRANSACTION_ARGUMENTS.join(', ')} are needed for inscribe transaction"
+        end
 
         receivers = kwargs[:receivers].presence || [config.app_id]
         receivers_threshold = kwargs[:receivers_threshold] || receivers.length
@@ -283,14 +362,20 @@ module MixinBot
         MixinBot.api.build_object_transaction data.to_json, references: [collection_hash]
       end
 
-      OCCUPY_INSCRIPTION_TRANSACTION_ARGUMENTS = %i[amount inscription_hash utxos].freeze
+      OCCUPY_INSCRIPTION_TRANSACTION_ARGUMENTS = %i[amount inscription_hash sequence utxos].freeze
       def build_occupy_transaction(**kwargs)
-        raise ArgumentError, "#{OCCUPY_INSCRIPTION_TRANSACTION_ARGUMENTS.join(', ')} are needed for occupy NFT transaction" unless OCCUPY_INSCRIPTION_TRANSACTION_ARGUMENTS.all? { |param| kwargs.keys.include? param }
+        unless OCCUPY_INSCRIPTION_TRANSACTION_ARGUMENTS.all? do |param|
+                 kwargs.keys.include? param
+               end
+          raise ArgumentError,
+                "#{OCCUPY_INSCRIPTION_TRANSACTION_ARGUMENTS.join(', ')} are needed for occupy NFT transaction"
+        end
 
         members = kwargs[:members].presence || [config.app_id]
         threshold = kwargs[:threshold] || members.length
         amount = kwargs[:amount]
         inscription_hash = kwargs[:inscription_hash]
+        sequence = kwargs[:sequence]
 
         receivers = [
           {
@@ -302,11 +387,15 @@ module MixinBot
 
         extra = {
           operation: 'occupy',
-          recipient:,
-          content:
+          sequence:
         }.to_json
 
-        MixinBot.api.build_safe_transaction(utxos:, receivers:, extra:, references: [inscription_hash])
+        build_safe_transaction(utxos: kwargs[:utxos], receivers:, extra:, references: [inscription_hash])
+      end
+
+      def send_kernel_transaction_from_account(**_kwargs)
+        raise NotImplementedError,
+              'send_kernel_transaction_from_account requires kernel UTXO signing; use native mixin CLI or build manually'
       end
     end
   end