mixin_bot 0.12.1 → 1.1.0

data/lib/mixin_bot/api/tip.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module MixinBot
+  class API
+    module Tip
+      TIP_ACTIONS = %w[
+        TIP:VERIFY:
+        TIP:ADDRESS:ADD:
+        TIP:ADDRESS:REMOVE:
+        TIP:USER:DEACTIVATE:
+        TIP:EMERGENCY:CONTACT:CREATE:
+        TIP:EMERGENCY:CONTACT:READ:
+        TIP:EMERGENCY:CONTACT:REMOVE:
+        TIP:PHONE:NUMBER:UPDATE:
+        TIP:MULTISIG:REQUEST:SIGN:
+        TIP:MULTISIG:REQUEST:UNLOCK:
+        TIP:COLLECTIBLE:REQUEST:SIGN:
+        TIP:COLLECTIBLE:REQUEST:UNLOCK:
+        TIP:TRANSFER:CREATE:
+        TIP:WITHDRAWAL:CREATE:
+        TIP:TRANSACTION:CREATE:
+        TIP:OAUTH:APPROVE:
+        TIP:PROVISIONING:UPDATE:
+        TIP:APP:OWNERSHIP:TRANSFER:
+        SEQUENCER:REGISTER:
+      ].freeze
+
+      def encrypt_tip_pin(pin, action, *params)
+        raise ArgumentError, 'invalid action' unless TIP_ACTIONS.include? action
+
+        pin_key = MixinBot.utils.decode_key pin
+
+        msg = action + params.flatten.map(&:to_s).join
+
+        msg = Digest::SHA256.digest(msg) unless action == 'TIP:VERIFY:'
+
+        signature = JOSE::JWA::Ed25519.sign msg, pin_key
+
+        encrypt_pin signature
+      end
+    end
+  end
+end

data/lib/mixin_bot/api/transaction.rb

@@ -3,75 +3,310 @@
 module MixinBot
   class API
     module Transaction
-      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]
-        threshold = options[:threshold]
-        amount = options[:amount].to_d
-        memo = options[:memo]
-        trace_id = options[:trace_id] || SecureRandom.uuid
-        encrypted_pin = options[:encrypted_pin] || encrypt_pin(pin)
-
-        path = '/transactions'
-        payload = {
-          asset_id: asset_id,
-          opponent_multisig: {
-            receivers: receivers,
-            threshold: threshold
-          },
-          pin: encrypted_pin,
-          amount: format('%.8f', amount.to_r),
-          trace_id: trace_id,
-          memo: memo
-        }
+      SAFE_TX_VERSION = 0x05
+      OUTPUT_TYPE_SCRIPT = 0x00
+      OUTPUT_TYPE_WITHDRAW_SUBMIT = 0xa1
+      XIN_ASSET_ID = 'c94ac88f-4671-3976-b60a-09064f1811e8'
+      EXTRA_SIZE_STORAGE_CAPACITY = 1024 * 1024 * 4
+      EXTRA_STORAGE_PRICE_STEP = 0.0001
+
+      def create_safe_keys(*payload, access_token: nil)
+        raise ArgumentError, 'payload should be an array' unless payload.is_a? Array
+        raise ArgumentError, 'payload should not be empty' unless payload.size.positive?
+        raise ArgumentError, 'invalid payload' unless payload.all?(&lambda { |param|
+                                                                      param.key?(:receivers) && param.key?(:index)
+                                                                    })
+
+        payload.each do |param|
+          param[:hint] ||= SecureRandom.uuid
+        end
+
+        path = '/safe/keys'
+
+        client.post path, *payload, access_token:
+      end
+      alias create_ghost_keys create_safe_keys
+
+      def generate_safe_keys(recipients)
+        raise ArgumentError, 'recipients should be an array' unless recipients.is_a? Array
+
+        ghost_keys = []
+        uuid_recipients = []
 
-        access_token = options[: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)
+        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 })
+            key = JOSE::JWA::Ed25519.keypair
+            gk = {
+              mask: key[0].unpack1('H*'),
+              keys: []
+            }
+            recipient[:members].each do |member|
+              payload = MixinBot.utils.parse_main_address member
+              spend_key = payload[0...32]
+              view_key = payload[-32..]
+
+              ghost_public_key = MixinBot.utils.derive_ghost_public_key(key[1], view_key, spend_key, index)
+
+              gk[:keys] << ghost_public_key.unpack1('H*')
+            end
+
+            ghost_keys[index] = gk.with_indifferent_access
+
+          elsif recipient[:members].none?(&->(m) { m.start_with? MixinBot::Utils::Address::MAIN_ADDRESS_PREFIX })
+            uuid_recipients.push(
+              {
+                receivers: recipient[:members],
+                index:,
+                hint: SecureRandom.uuid
+              }.with_indifferent_access
+            )
+          end
+        end
+
+        if uuid_recipients.present?
+          keys = create_safe_keys(*uuid_recipients)['data']
+          keys.each_with_index do |key, index|
+            ghost_keys[uuid_recipients[index][:index]] = key
+          end
+        end
+
+        ghost_keys
       end
 
-      MAINNET_TRANSACTION_ARGUMENTS = %i[asset_id opponent_key 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_key = options[:opponent_key]
-        amount = options[:amount].to_d
-        memo = options[:memo]
-        trace_id = options[:trace_id] || SecureRandom.uuid
-        encrypted_pin = options[:encrypted_pin] || encrypt_pin(pin)
-
-        path = '/transactions'
-        payload = {
-          asset_id: asset_id,
-          opponent_key: opponent_key,
-          pin: encrypted_pin,
-          amount: format('%.8f', amount.to_r),
-          trace_id: trace_id,
-          memo: memo
+      # kwargs:
+      # {
+      #  utxos: [ utxo ],
+      #  receivers: [ {
+      #   members: [ uuid ],
+      #   threshold: integer,
+      #   amount: string,
+      #  } ],
+      #  ghosts: [ ghost ],
+      #  extra: string,
+      # }
+      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 }
+        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
+
+        utxos = kwargs[:utxos].map(&:with_indifferent_access)
+        receivers = kwargs[:receivers].map(&:with_indifferent_access)
+
+        senders = utxos.map { |utxo| utxo['receivers'] }.uniq
+        raise ArgumentError, 'utxos should have same senders' if senders.size > 1
+
+        senders_threshold = utxos.map { |utxo| utxo['receivers_threshold'] }.uniq
+        raise ArgumentError, 'utxos should have same senders_threshold' if senders_threshold.size > 1
+
+        raise ArgumentError, 'utxos should not be empty' if utxos.empty?
+        raise ArgumentError, 'utxos too many' if utxos.size > 256
+
+        recipients = receivers.map do |receiver|
+          MixinBot.utils.build_safe_recipient(
+            members: receiver[:members],
+            threshold: receiver[:threshold],
+            amount: receiver[:amount]
+          ).with_indifferent_access
+        end
+
+        inputs_sum = utxos.sum(&->(utxo) { utxo['amount'].to_d })
+        outputs_sum = recipients.sum(&->(recipient) { recipient['amount'].to_d })
+        change = inputs_sum - outputs_sum
+        raise InsufficientBalanceError, "inputs sum #{inputs_sum} < outputs sum #{outputs_sum}" if change.negative?
+
+        if change.positive?
+          recipients << MixinBot.utils.build_safe_recipient(
+            members: utxos.first['receivers'],
+            threshold: utxos.first['receivers_threshold'],
+            amount: change
+          ).with_indifferent_access
+        end
+        raise ArgumentError, 'recipients too many' if recipients.size > 256
+
+        asset = utxos[0]['asset']
+        inputs = []
+        utxos.each do |utxo|
+          raise ArgumentError, 'utxo asset not match' unless utxo['asset'] == asset
+
+          inputs << {
+            hash: utxo['transaction_hash'],
+            index: utxo['output_index']
+          }
+        end
+
+        ghosts = generate_safe_keys(recipients)
+
+        outputs = []
+        recipients.each_with_index do |recipient, index|
+          outputs << if recipient['destination']
+                       {
+                         type: OUTPUT_TYPE_WITHDRAW_SUBMIT,
+                         amount: recipient['amount'],
+                         withdrawal: {
+                           address: recipient['destination'],
+                           tag: recipient['tag'] || ''
+                         }
+                       }
+                     else
+                       {
+                         type: OUTPUT_TYPE_SCRIPT,
+                         amount: recipient['amount'],
+                         keys: ghosts[index]['keys'],
+                         mask: ghosts[index]['mask'],
+                         script: build_threshold_script(recipient['threshold'])
+                       }
+                     end
+        end
+
+        {
+          version: SAFE_TX_VERSION,
+          asset:,
+          inputs:,
+          outputs:,
+          extra: kwargs[:extra] || '',
+          references: kwargs[:references] || []
         }
+      end
+
+      def create_safe_transaction_request(request_id, raw)
+        path = '/safe/transaction/requests'
+        payload = [{
+          request_id:,
+          raw:
+        }]
+
+        client.post path, *payload
+      end
 
-        access_token = options[: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)
+      def send_safe_transaction(request_id, raw)
+        path = '/safe/transactions'
+        payload = [{
+          request_id:,
+          raw:
+        }]
+
+        client.post path, *payload
+      end
+
+      def safe_transaction(request_id, access_token: nil)
+        path = format('/safe/transactions/%<request_id>s', request_id:)
+
+        client.get path, access_token:
       end
 
-      def transactions(**options)
-        path = format(
-          '/external/transactions?limit=%<limit>s&offset=%<offset>s&asset=%<asset>s&destination=%<destination>s&tag=%<tag>s',
-          limit: options[:limit],
-          offset: options[:offset],
-          asset: options[:asset],
-          destination: options[:destination],
-          tag: options[:tag]
+      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 }
+
+        raw = kwargs[:raw]
+        tx = MixinBot.utils.decode_raw_transaction raw
+        utxos = kwargs[:utxos]
+        request = kwargs[:request]
+        spend_key = MixinBot.utils.decode_key(kwargs[:spend_key]) || config.spend_key
+        spend_key = Digest::SHA512.digest spend_key[...32]
+
+        msg = [raw].pack('H*')
+
+        y_scalar = JOSE::JWA::FieldElement.new(
+          JOSE::JWA::X25519.clamp_scalar(spend_key[...32]).x,
+          JOSE::JWA::Edwards25519Point::L
         )
 
-        client.get path
+        tx[:signatures] = []
+        tx[:inputs].each_with_index do |input, index|
+          utxo = utxos[index]
+          raise ArgumentError, 'utxo not match' unless input['hash'] == utxo['transaction_hash'] && input['index'] == utxo['output_index']
+
+          view = [request['views'][index]].pack('H*')
+          x_scalar = MixinBot.utils.scalar_from_bytes(view)
+
+          t_scalar = x_scalar + y_scalar
+          key = t_scalar.to_bytes(JOSE::JWA::Edwards25519Point::B)
+
+          pub = MixinBot.utils.shared_public_key key
+          key_index = utxo['keys'].index pub.unpack1('H*')
+          raise ArgumentError, 'cannot find valid key' unless key_index.is_a? Integer
+
+          signature = MixinBot.utils.sign(msg, key:)
+          signature = signature.unpack1('H*')
+          sig = {}
+          sig[key_index] = signature
+          tx[:signatures] << sig
+        end
+
+        MixinBot.utils.encode_raw_transaction tx
+      end
+
+      def build_object_transaction(extra, **)
+        extra = extra.to_s
+        raise ArgumentError, 'Extra too large' if extra.bytesize > EXTRA_SIZE_STORAGE_CAPACITY
+
+        # calculate fee base on extra length
+        amount = EXTRA_STORAGE_PRICE_STEP * ((extra.bytesize / 1024) + 1)
+
+        # burning address
+        receivers = [
+          {
+            members: [MixinBot.utils.burning_address],
+            threshold: 64,
+            amount:
+          }
+        ]
+
+        # find XIN utxos
+        utxos = build_utxos(asset_id: XIN_ASSET_ID, amount:)
+
+        # build transaction
+        build_safe_transaction utxos:, receivers:, extra:, **
+      end
+
+      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 }
+
+        receivers = kwargs[:receivers].presence || [config.app_id]
+        receivers_threshold = kwargs[:receivers_threshold] || receivers.length
+        recipient = MixinBot.utils.build_mix_address(receivers, receivers_threshold)
+
+        content = kwargs[:content]
+        collection_hash = kwargs[:collection_hash]
+
+        data = {
+          operation: 'inscribe',
+          recipient:,
+          content:
+        }
+
+        MixinBot.api.build_object_transaction data.to_json, references: [collection_hash]
+      end
+
+      OCCUPY_INSCRIPTION_TRANSACTION_ARGUMENTS = %i[amount inscription_hash 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 }
+
+        members = kwargs[:members].presence || [config.app_id]
+        threshold = kwargs[:threshold] || members.length
+        amount = kwargs[:amount]
+        inscription_hash = kwargs[:inscription_hash]
+
+        receivers = [
+          {
+            members:,
+            threshold:,
+            amount:
+          }
+        ]
+
+        extra = {
+          operation: 'occupy',
+          recipient:,
+          content:
+        }.to_json
+
+        MixinBot.api.build_safe_transaction(utxos:, receivers:, extra:, references: [inscription_hash])
       end
     end
   end

data/lib/mixin_bot/api/transfer.rb

@@ -3,40 +3,78 @@
 module MixinBot
   class API
     module Transfer
-      TRANSFER_ARGUMENTS = %i[asset_id opponent_id amount].freeze
-      def create_transfer(pin, options = {})
-        raise ArgumentError, "#{TRANSFER_ARGUMENTS.join(', ')} are needed for create transfer" unless TRANSFER_ARGUMENTS.all? { |param| options.keys.include? param }
-
-        asset_id = options[:asset_id]
-        opponent_id = options[:opponent_id]
-        amount = options[:amount].to_d
-        memo = options[:memo]
-        trace_id = options[:trace_id] || SecureRandom.uuid
-        encrypted_pin = options[:encrypted_pin] || encrypt_pin(pin)
-
-        path = '/transfers'
-        payload = {
-          asset_id: asset_id,
-          opponent_id: opponent_id,
-          pin: encrypted_pin,
-          amount: format('%.8f', amount.to_r),
-          trace_id: trace_id,
-          memo: memo
-        }
-
-        access_token = options[: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)
+      # kwargs:
+      # {
+      #  members: uuid | [ uuid ],
+      #  threshold: integer / nil,
+      #  asset_id: uuid,
+      #  amount: string / float,
+      #  trace_id: uuid / nil,
+      #  request_id: uuid / nil,
+      #  memo: string,
+      #  spend_key: string / nil,
+      # }
+      def create_safe_transfer(**kwargs)
+        asset_id = kwargs[:asset_id]
+        raise ArgumentError, 'asset_id required' if asset_id.blank?
+
+        amount = kwargs[:amount]&.to_d
+        raise ArgumentError, 'amount required' if amount.blank?
+
+        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] || ''
+
+        # step 1: select inputs
+        utxos = build_utxos(asset_id:, amount:)
+
+        # step 2: build transaction
+        tx = build_safe_transaction(
+          utxos:,
+          receivers: [{
+            members:,
+            threshold:,
+            amount:
+          }],
+          extra: memo
+        )
+        raw = MixinBot.utils.encode_raw_transaction tx
+
+        # step 3: verify transaction
+        request = create_safe_transaction_request(request_id, raw)['data']
+
+        # step 4: sign transaction
+        spend_key = MixinBot.utils.decode_key(kwargs[:spend_key]) || config.spend_key
+        signed_raw = MixinBot.api.sign_safe_transaction(
+          raw:,
+          utxos:,
+          request: request[0],
+          spend_key:
+        )
+
+        # step 5: submit transaction
+        send_safe_transaction(
+          request_id,
+          signed_raw
+        )
       end
 
-      def transfer(trace_id, access_token: nil)
-        path = format('/transfers/trace/%<trace_id>s', trace_id: trace_id)
-        access_token ||= access_token('GET', path, '')
-        authorization = format('Bearer %<access_token>s', access_token: access_token)
-        client.get(path, headers: { 'Authorization': authorization })
+      def build_utxos(asset_id:, amount:)
+        outputs = safe_outputs(state: 'unspent', asset: asset_id, limit: 500)['data'].sort_by { |o| o['amount'].to_d }
+
+        utxos = []
+        outputs.each do |output|
+          break if utxos.sum { |o| o['amount'].to_d } >= amount
+
+          utxos.shift if utxos.size >= 256
+          utxos << output
+        end
+
+        utxos
       end
-      alias read_transfer transfer
     end
   end
 end