mixin_bot 1.0.0 → 1.2.0

data/lib/mixin_bot/api.rb

@@ -8,9 +8,10 @@ require_relative 'api/asset'
 require_relative 'api/attachment'
 require_relative 'api/auth'
 require_relative 'api/blaze'
-require_relative 'api/collectible'
 require_relative 'api/conversation'
 require_relative 'api/encrypted_message'
+require_relative 'api/inscription'
+require_relative 'api/legacy_collectible'
 require_relative 'api/legacy_multisig'
 require_relative 'api/legacy_output'
 require_relative 'api/legacy_payment'
@@ -67,8 +68,8 @@ module MixinBot
       )
     end
 
-    def encode_raw_transaction(tx)
-      utils.encode_raw_transaction tx
+    def encode_raw_transaction(txn)
+      utils.encode_raw_transaction txn
     end
 
     def decode_raw_transaction(raw)
@@ -107,9 +108,10 @@ module MixinBot
     include MixinBot::API::Attachment
     include MixinBot::API::Auth
     include MixinBot::API::Blaze
-    include MixinBot::API::Collectible
     include MixinBot::API::Conversation
     include MixinBot::API::EncryptedMessage
+    include MixinBot::API::Inscription
+    include MixinBot::API::LegacyCollectible
     include MixinBot::API::LegacyMultisig
     include MixinBot::API::LegacyOutput
     include MixinBot::API::LegacyPayment

data/lib/mixin_bot/client.rb

@@ -78,7 +78,7 @@ module MixinBot
         return result
       end
 
-      errmsg = "#{verb.upcase}|#{path}|#{body}, errcode: #{result['error']['code']}, errmsg: #{result['error']['description']}, request_id: #{response&.[]('X-Request-Id')}, server_time: #{response&.[]('X-Server-Time')}'"
+      errmsg = "#{verb.upcase} | #{path} | #{body}, errcode: #{result['error']['code']}, errmsg: #{result['error']['description']}, request_id: #{response&.[]('X-Request-Id')}, server_time: #{response&.[]('X-Server-Time')}'"
 
       case result['error']['code']
       when 401, 20121
@@ -87,8 +87,6 @@ module MixinBot
         raise ForbiddenError, errmsg
       when 404
         raise NotFoundError, errmsg
-      when 400, 10006, 20133, 500, 7000, 7001
-        raise ResponseError, errmsg
       when 20117
         raise InsufficientBalanceError, errmsg
       when 20118, 20119

data/lib/mixin_bot/nfo.rb

@@ -74,7 +74,7 @@ module MixinBot
         bytes += [0]
       else
         bytes += [1]
-        bytes += MixinBot.utils.encode_uint_64 mask
+        bytes += MixinBot.utils.encode_uint64 mask
         bytes += MixinBot::UUID.new(hex: chain).packed.bytes
 
         class_bytes = [nm_class].pack('H*').bytes

data/lib/mixin_bot/transaction.rb

@@ -51,13 +51,13 @@ module MixinBot
       bytes += encode_outputs
 
       # placeholder for `references`
-      bytes += NULL_BYTES if version >= REFERENCES_TX_VERSION
+      bytes += encode_references if version >= REFERENCES_TX_VERSION
 
       # extra
       extra_bytes = extra.bytes
       raise InvalidTransactionFormatError, 'extra is too long' if extra_bytes.size > MAX_EXTRA_SIZE
 
-      bytes += MixinBot.utils.encode_uint_32 extra_bytes.size
+      bytes += MixinBot.utils.encode_uint32 extra_bytes.size
       bytes += extra_bytes
 
       # aggregated
@@ -93,24 +93,20 @@ module MixinBot
       # read outputs
       decode_outputs
 
-      # TODO:
       # read references
-      if version >= REFERENCES_TX_VERSION
-        references_size = @bytes.shift 2
-        raise ArgumentError, 'Not support references yet' unless references_size == NULL_BYTES
-      end
+      decode_references if version >= REFERENCES_TX_VERSION
 
       # read extra
       # unsigned 32 endian for extra size
-      extra_size = MixinBot.utils.decode_uint_32 @bytes.shift(4)
+      extra_size = MixinBot.utils.decode_uint32 @bytes.shift(4)
       @extra = @bytes.shift(extra_size).pack('C*')
 
-      num = MixinBot.utils.decode_uint_16 @bytes.shift(2)
+      num = MixinBot.utils.decode_uint16 @bytes.shift(2)
       if num == MAX_ENCODE_INT
         # aggregated
         @aggregated = {}
 
-        raise ArgumentError, 'invalid aggregated' unless MixinBot.utils.decode_uint_16(@bytes.shift(2)) == AGGREGATED_SIGNATURE_PREFIX
+        raise ArgumentError, 'invalid aggregated' unless MixinBot.utils.decode_uint16(@bytes.shift(2)) == AGGREGATED_SIGNATURE_PREFIX
 
         @aggregated['signature'] = @bytes.shift(64).pack('C*').unpack1('H*')
 
@@ -118,7 +114,7 @@ module MixinBot
         case byte
         when AGGREGATED_SIGNATURE_ORDINAY_MASK.first
           @aggregated['signers'] = []
-          masks_size = MixinBot.utils.decode_uint_16 @bytes.shift(2)
+          masks_size = MixinBot.utils.decode_uint16 @bytes.shift(2)
           masks = @bytes.shift(masks_size)
           masks = Array(masks)
 
@@ -129,12 +125,12 @@ module MixinBot
             end
           end
         when AGGREGATED_SIGNATURE_SPARSE_MASK.first
-          signers_size = MixinBot.utils.decode_uint_16 @bytes.shift(2)
+          signers_size = MixinBot.utils.decode_uint16 @bytes.shift(2)
           return if signers_size.zero?
 
           aggregated['signers'] = []
           signers_size.times do
-            aggregated['signers'].push MixinBot.utils.decode_uint_16(@bytes.shift(2))
+            aggregated['signers'].push MixinBot.utils.decode_uint16(@bytes.shift(2))
           end
         end
       elsif num.present? && num.positive? && @bytes.size.positive?
@@ -142,10 +138,10 @@ module MixinBot
         num.times do
           signature = {}
 
-          keys_size = MixinBot.utils.decode_uint_16 @bytes.shift(2)
+          keys_size = MixinBot.utils.decode_uint16 @bytes.shift(2)
 
           keys_size.times do
-            index = MixinBot.utils.decode_uint_16 @bytes.shift(2)
+            index = MixinBot.utils.decode_uint16 @bytes.shift(2)
             signature[index] = @bytes.shift(64).pack('C*').unpack1('H*')
           end
 
@@ -175,11 +171,11 @@ module MixinBot
     def encode_inputs
       bytes = []
 
-      bytes += MixinBot.utils.encode_uint_16(inputs.size)
+      bytes += MixinBot.utils.encode_uint16(inputs.size)
 
       inputs.each do |input|
         bytes += [input['hash']].pack('H*').bytes
-        bytes += MixinBot.utils.encode_uint_16(input['index'])
+        bytes += MixinBot.utils.encode_uint16(input['index'])
 
         # genesis
         genesis = input['genesis'] || ''
@@ -187,7 +183,7 @@ module MixinBot
           bytes += NULL_BYTES
         else
           genesis_bytes = [genesis].pack('H*').bytes
-          bytes += MixinBot.utils.encode_uint_16 genesis_bytes.size
+          bytes += MixinBot.utils.encode_uint16 genesis_bytes.size
           bytes += genesis_bytes
         end
 
@@ -200,17 +196,17 @@ module MixinBot
           bytes += [deposit['chain']].pack('H*').bytes
 
           asset_bytes = [deposit['asset']].pack('H*')
-          bytes += MixinBot.utils.encode_uint_16 asset_bytes.size
+          bytes += MixinBot.utils.encode_uint16 asset_bytes.size
           bytes += asset_bytes
 
           transaction_bytes = [deposit['transaction']].pack('H*')
-          bytes += MixinBot.utils.encode_uint_16 transaction_bytes.size
+          bytes += MixinBot.utils.encode_uint16 transaction_bytes.size
           bytes += transaction_bytes
 
-          bytes += MixinBot.utils.encode_uint_64 deposit['index']
+          bytes += MixinBot.utils.encode_uint64 deposit['index']
 
           amount_bytes = MixinBot.utils.bytes_of deposit['amount']
-          bytes +=  MixinBot.utils.encode_uint_16 amount_bytes.size
+          bytes +=  MixinBot.utils.encode_uint16 amount_bytes.size
           bytes +=  amount_bytes
         end
 
@@ -224,17 +220,17 @@ module MixinBot
           # group
           group = mint['group'] || ''
           if group.empty?
-            bytes += MixinBot.utils.encode_uint_16 NULL_BYTES
+            bytes += MixinBot.utils.encode_uint16 NULL_BYTES
           else
             group_bytes = [group].pack('H*')
-            bytes += MixinBot.utils.encode_uint_16 group_bytes.size
+            bytes += MixinBot.utils.encode_uint16 group_bytes.size
             bytes += group_bytes
           end
 
-          bytes += MixinBot.utils.encode_uint_64 mint['batch']
+          bytes += MixinBot.utils.encode_uint64 mint['batch']
 
           amount_bytes = MixinBot.utils.encode_int mint['amount']
-          bytes +=  MixinBot.utils.encode_uint_16 amount_bytes.size
+          bytes +=  MixinBot.utils.encode_uint16 amount_bytes.size
           bytes +=  amount_bytes
         end
       end
@@ -245,7 +241,7 @@ module MixinBot
     def encode_outputs
       bytes = []
 
-      bytes += MixinBot.utils.encode_uint_16 outputs.size
+      bytes += MixinBot.utils.encode_uint16 outputs.size
 
       outputs.each do |output|
         type = output['type'] || 0
@@ -253,11 +249,11 @@ module MixinBot
 
         # amount
         amount_bytes = MixinBot.utils.encode_int (output['amount'].to_d * 1e8).round
-        bytes +=  MixinBot.utils.encode_uint_16 amount_bytes.size
+        bytes +=  MixinBot.utils.encode_uint16 amount_bytes.size
         bytes +=  amount_bytes
 
         # keys
-        bytes +=  MixinBot.utils.encode_uint_16 output['keys'].size
+        bytes +=  MixinBot.utils.encode_uint16 output['keys'].size
         output['keys'].each do |key|
           bytes += [key].pack('H*').bytes
         end
@@ -267,7 +263,7 @@ module MixinBot
 
         # script
         script_bytes = [output['script']].pack('H*').bytes
-        bytes += MixinBot.utils.encode_uint_16 script_bytes.size
+        bytes += MixinBot.utils.encode_uint16 script_bytes.size
         bytes += script_bytes
 
         # withdrawal
@@ -282,7 +278,7 @@ module MixinBot
 
           # asset
           @asset_bytes = [withdrawal['asset']].pack('H*')
-          bytes += MixinBot.utils.encode_uint_16 asset_bytes.size
+          bytes += MixinBot.utils.encode_uint16 asset_bytes.size
           bytes += asset_bytes
 
           # address
@@ -291,7 +287,7 @@ module MixinBot
             bytes += NULL_BYTES
           else
             address_bytes = [address].pack('H*').bytes
-            bytes += MixinBot.utils.encode_uint_16 address.size
+            bytes += MixinBot.utils.encode_uint16 address.size
             bytes += address_bytes
           end
 
@@ -301,7 +297,7 @@ module MixinBot
             bytes += NULL_BYTES
           else
             address_bytes = [tag].pack('H*').bytes
-            bytes += MixinBot.utils.encode_uint_16 tag.size
+            bytes += MixinBot.utils.encode_uint16 tag.size
             bytes += address_bytes
           end
         end
@@ -310,11 +306,23 @@ module MixinBot
       bytes
     end
 
+    def encode_references
+      bytes = []
+
+      bytes += MixinBot.utils.encode_uint16 references.size
+
+      references.each do |reference|
+        bytes += [reference].pack('H*').bytes
+      end
+
+      bytes
+    end
+
     def encode_aggregated_signature
       bytes = []
 
-      bytes += MixinBot.utils.encode_uint_16 MAX_ENCODE_INT
-      bytes += MixinBot.utils.encode_uint_16 AGGREGATED_SIGNATURE_PREFIX
+      bytes += MixinBot.utils.encode_uint16 MAX_ENCODE_INT
+      bytes += MixinBot.utils.encode_uint16 AGGREGATED_SIGNATURE_PREFIX
       bytes += [aggregated['signature']].pack('H*').bytes
 
       signers = aggregated['signers']
@@ -330,8 +338,8 @@ module MixinBot
         max = signers.last
         if ((((max / 8) | 0) + 1) | 0) > aggregated['signature'].size * 2
           bytes += AGGREGATED_SIGNATURE_SPARSE_MASK
-          bytes += MixinBot.utils.encode_uint_16 aggregated['signers'].size
-          signers.map(&->(signer) { bytes += MixinBot.utils.encode_uint_16(signer) })
+          bytes += MixinBot.utils.encode_uint16 aggregated['signers'].size
+          signers.map(&->(signer) { bytes += MixinBot.utils.encode_uint16(signer) })
         end
 
         masks_bytes = Array.new((max / 8) + 1, 0)
@@ -339,7 +347,7 @@ module MixinBot
           masks[signer / 8] = masks[signer / 8] ^ (1 << (signer % 8))
         end
         bytes += AGGREGATED_SIGNATURE_ORDINAY_MASK
-        bytes += MixinBot.utils.encode_uint_16 masks_bytes.size
+        bytes += MixinBot.utils.encode_uint16 masks_bytes.size
         bytes += masks_bytes
       end
 
@@ -358,15 +366,15 @@ module MixinBot
 
       raise ArgumentError, 'signatures overflow' if sl == MAX_ENCODE_INT
 
-      bytes += MixinBot.utils.encode_uint_16 sl
+      bytes += MixinBot.utils.encode_uint16 sl
 
       if sl.positive?
         signatures.each do |signature|
-          bytes += MixinBot.utils.encode_uint_16 signature.keys.size
+          bytes += MixinBot.utils.encode_uint16 signature.keys.size
 
           signature.keys.sort.each do |key|
             signature_bytes = [signature[key]].pack('H*').bytes
-            bytes += MixinBot.utils.encode_uint_16 key
+            bytes += MixinBot.utils.encode_uint16 key
             bytes += signature_bytes
           end
         end
@@ -376,7 +384,7 @@ module MixinBot
     end
 
     def decode_inputs
-      inputs_size = MixinBot.utils.decode_uint_16 @bytes.shift(2)
+      inputs_size = MixinBot.utils.decode_uint16 @bytes.shift(2)
       @inputs = []
       inputs_size.times do
         input = {}
@@ -384,12 +392,12 @@ module MixinBot
         input['hash'] = hash.pack('C*').unpack1('H*')
 
         index = @bytes.shift(2)
-        input['index'] = MixinBot.utils.decode_uint_16 index
+        input['index'] = MixinBot.utils.decode_uint16 index
 
         if @bytes[...2] == NULL_BYTES
           @bytes.shift 2
         else
-          genesis_size = MixinBot.utils.decode_uint_16 @bytes.shift(2)
+          genesis_size = MixinBot.utils.decode_uint16 @bytes.shift(2)
           genesis = @bytes.shift genesis_size
           input['genesis'] = genesis.pack('C*').unpack1('H*')
         end
@@ -403,15 +411,15 @@ module MixinBot
           deposit = {}
           deposit['chain'] = @bytes.shift(32).pack('C*').unpack1('H*')
 
-          asset_size = MixinBot.utils.decode_uint_16 @bytes.shift(2)
+          asset_size = MixinBot.utils.decode_uint16 @bytes.shift(2)
           deposit['asset'] = @bytes.shift(asset_size).unpack1('H*')
 
-          transaction_size = MixinBot.utils.decode_uint_16 @bytes.shift(2)
+          transaction_size = MixinBot.utils.decode_uint16 @bytes.shift(2)
           deposit['transaction'] = @bytes.shift(transaction_size).unpack1('H*')
 
-          deposit['index'] = MixinBot.utils.decode_uint_64 @bytes.shift(8)
+          deposit['index'] = MixinBot.utils.decode_uint64 @bytes.shift(8)
 
-          amount_size = MixinBot.utils.decode_uint_16 @bytes.shift(2)
+          amount_size = MixinBot.utils.decode_uint16 @bytes.shift(2)
           deposit['amount'] = MixinBot.utils.decode_int @bytes.shift(amount_size)
 
           input['deposit'] = deposit
@@ -427,12 +435,12 @@ module MixinBot
           if bytes[...2] == NULL_BYTES
             @bytes.shift 2
           else
-            group_size = MixinBot.utils.decode_uint_16 @bytes.shift(2)
+            group_size = MixinBot.utils.decode_uint16 @bytes.shift(2)
             mint['group'] = @bytes.shift(group_size).unpack1('H*')
           end
 
-          mint['batch'] = MixinBot.utils.decode_uint_64 @bytes.shift(8)
-          _amount_size = MixinBot.utils.decode_uint_16 @bytes.shift(2)
+          mint['batch'] = MixinBot.utils.decode_uint64 @bytes.shift(8)
+          _amount_size = MixinBot.utils.decode_uint16 @bytes.shift(2)
           mint['amount'] = MixinBot.utils.decode_int bytes.shift(_amount_size)
 
           input['mint'] = mint
@@ -445,7 +453,7 @@ module MixinBot
     end
 
     def decode_outputs
-      outputs_size = MixinBot.utils.decode_uint_16 @bytes.shift(2)
+      outputs_size = MixinBot.utils.decode_uint16 @bytes.shift(2)
       @outputs = []
       outputs_size.times do
         output = {}
@@ -454,18 +462,18 @@ module MixinBot
         type = @bytes.shift
         output['type'] = type
 
-        amount_size = MixinBot.utils.decode_uint_16 @bytes.shift(2)
+        amount_size = MixinBot.utils.decode_uint16 @bytes.shift(2)
         output['amount'] = format('%.8f', MixinBot.utils.decode_int(@bytes.shift(amount_size)).to_f / 1e8).gsub(/\.?0+$/, '')
 
         output['keys'] = []
-        keys_size = MixinBot.utils.decode_uint_16 @bytes.shift(2)
+        keys_size = MixinBot.utils.decode_uint16 @bytes.shift(2)
         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 = MixinBot.utils.decode_uint_16 @bytes.shift(2)
+        script_size = MixinBot.utils.decode_uint16 @bytes.shift(2)
         output['script'] = @bytes.shift(script_size).pack('C*').unpack1('H*')
 
         if @bytes[...2] == NULL_BYTES
@@ -476,14 +484,14 @@ module MixinBot
 
           output['chain'] = @bytes.shift(32).pack('C*').unpack1('H*')
 
-          asset_size = MixinBot.utils.decode_uint_16 @bytes.shift(2)
+          asset_size = MixinBot.utils.decode_uint16 @bytes.shift(2)
           output['asset'] = @bytes.shift(asset_size).unpack1('H*')
 
           if @bytes[...2] == NULL_BYTES
             @bytes.shift 2
           else
 
-            adderss_size = MixinBot.utils.decode_uint_16 @bytes.shift(2)
+            adderss_size = MixinBot.utils.decode_uint16 @bytes.shift(2)
             output['adderss'] = @bytes.shift(adderss_size).pack('C*').unpack1('H*')
           end
 
@@ -491,7 +499,7 @@ module MixinBot
             @bytes.shift 2
           else
 
-            tag_size = MixinBot.utils.decode_uint_16 @bytes.shift(2)
+            tag_size = MixinBot.utils.decode_uint16 @bytes.shift(2)
             output['tag'] = @bytes.shift(tag_size).pack('C*').unpack1('H*')
           end
         end
@@ -501,5 +509,16 @@ module MixinBot
 
       self
     end
+
+    def decode_references
+      references_size = MixinBot.utils.decode_uint16 @bytes.shift(2)
+      @references = []
+
+      references_size.times do
+        @references.push @bytes.shift(32).pack('C*').unpack1('H*')
+      end
+
+      self
+    end
   end
 end

data/lib/mixin_bot/utils/address.rb

@@ -20,7 +20,6 @@ module MixinBot
 
         data = address[MAIN_ADDRESS_PREFIX.length..]
         data = Base58.base58_to_binary data, :bitcoin
-        raise ArgumentError, 'invalid address' unless data.length == 68
 
         payload = data[...-4]
 
@@ -32,11 +31,12 @@ module MixinBot
         payload
       end
 
-      def build_mix_address(members, threshold)
+      def build_mix_address(members:, threshold:)
         raise ArgumentError, 'members should be an array' unless members.is_a? Array
         raise ArgumentError, 'members should not be empty' if members.empty?
         raise ArgumentError, 'members length should less than 256' if members.length > 255
-        raise ArgumentError, "invalid threshold: #{threshold}" if threshold > members.length
+
+        # raise ArgumentError, "invalid threshold: #{threshold}" if threshold > members.length
 
         prefix = [MIX_ADDRESS_VERSION].pack('C*') + [threshold].pack('C*') + [members.length].pack('C*')
 
@@ -61,24 +61,24 @@ module MixinBot
 
         data = address[MIX_ADDRESS_PREFIX.length..]
         data = Base58.base58_to_binary data, :bitcoin
-        raise ArgumentError, 'invalid address' if data.length < 3 + 16 + 4
+        raise ArgumentError, 'invalid address, length invalid' if data.length < 3 + 16 + 4
 
         msg = data[...-4]
         checksum = SHA3::Digest::SHA256.digest((MIX_ADDRESS_PREFIX + msg))[0...4]
 
-        raise ArgumentError, 'invalid address' unless checksum[0...4] == data[-4..]
+        raise ArgumentError, 'invalid address, checksum invalid' unless checksum[0...4] == data[-4..]
 
         version = data[0].ord
-        raise ArgumentError, 'invalid address' unless version == MIX_ADDRESS_VERSION
+        raise ArgumentError, 'invalid address, version invalid' unless version == MIX_ADDRESS_VERSION
 
         threshold = data[1].ord
         members_count = data[2].ord
 
-        if data[3..].length == members_count * 16
-          members = data[3..].scan(/.{16}/)
+        if data[3...-4].length == members_count * 16
+          members = data[3...-4].chars.each_slice(16).map(&:join)
           members = members.map(&->(member) { MixinBot::UUID.new(raw: member).unpacked })
         else
-          members = data[3..].scan(/.{64}/)
+          members = data[3...-4].chars.each_slice(64).map(&:join)
           members = members.map(&->(member) { build_main_address(member) })
         end
 
@@ -100,9 +100,22 @@ module MixinBot
           members:,
           threshold:,
           amount:,
-          mix_address: build_mix_address(members, threshold)
+          mix_address: build_mix_address(members:, threshold:)
         }
       end
+
+      def burning_address
+        seed = "\0" * 64
+
+        digest1 = SHA3::Digest::SHA256.digest seed
+        digest2 = SHA3::Digest::SHA256.digest digest1
+        src = digest1 + digest2
+
+        spend_key = MixinBot::Utils.shared_public_key(seed)
+        view_key = MixinBot::Utils.shared_public_key(src)
+
+        MixinBot::Utils.build_main_address spend_key + view_key
+      end
     end
   end
 end

data/lib/mixin_bot/utils/crypto.rb

@@ -53,49 +53,45 @@ module MixinBot
         }
       end
 
-      def generate_public_key(key)
-        point = JOSE::JWA::FieldElement.new(
-          OpenSSL::BN.new(key.reverse, 2),
+      def shared_public_key(key)
+        (JOSE::JWA::Edwards25519Point.stdbase * scalar_from_bytes(key[...64]).x.to_i).encode
+      end
+
+      def scalar_from_bytes(raw)
+        JOSE::JWA::FieldElement.new(
+          # https://github.com/potatosalad/ruby-jose/blob/e1be589b889f1e59ac233a5d19a3fa13f1e4b8a0/lib/jose/jwa/x25519.rb#L122C14-L122C48
+          OpenSSL::BN.new(raw.reverse, 2),
           JOSE::JWA::Edwards25519Point::L
         )
-
-        (JOSE::JWA::Edwards25519Point.stdbase * point.x.to_i).encode
       end
 
       def sign(msg, key:)
         msg = Digest::Blake3.digest msg
 
-        pub = generate_public_key key
+        pub = shared_public_key key
 
-        y_point = JOSE::JWA::FieldElement.new(
-          OpenSSL::BN.new(key.reverse, 2),
-          JOSE::JWA::Edwards25519Point::L
-        )
+        y_scalar = scalar_from_bytes key
 
         key_digest = Digest::SHA512.digest key
         msg_digest = Digest::SHA512.digest(key_digest[-32...] + msg)
 
-        z_point = JOSE::JWA::FieldElement.new(
-          OpenSSL::BN.new(msg_digest[...64].reverse, 2),
-          JOSE::JWA::Edwards25519Point::L
-        )
+        z_scalar = scalar_from_bytes msg_digest[...64]
+
+        r_point = JOSE::JWA::Edwards25519Point.stdbase * z_scalar.x.to_i
 
-        r_point = JOSE::JWA::Edwards25519Point.stdbase * z_point.x.to_i
         hram_digest = Digest::SHA512.digest(r_point.encode + pub + msg)
 
-        x_point = JOSE::JWA::FieldElement.new(
-          OpenSSL::BN.new(hram_digest[...64].reverse, 2),
-          JOSE::JWA::Edwards25519Point::L
-        )
-        s_point = (x_point * y_point) + z_point
+        x_scalar = scalar_from_bytes hram_digest[...64]
+
+        s_scalar = (x_scalar * y_scalar) + z_scalar
 
-        r_point.encode + s_point.to_bytes(36)
+        r_point.encode + s_scalar.to_bytes(36)
       end
 
-      def generate_unique_uuid(uuid_1, uuid_2)
+      def generate_unique_uuid(uuid1, uuid2)
         md5 = Digest::MD5.new
-        md5 << [uuid_1, uuid_2].min
-        md5 << [uuid_1, uuid_2].max
+        md5 << [uuid1, uuid2].min
+        md5 << [uuid1, uuid2].max
         digest = md5.digest
         digest6 = ((digest[6].ord & 0x0f) | 0x30).chr
         digest8 = ((digest[8].ord & 0x3f) | 0x80).chr
@@ -175,7 +171,47 @@ module MixinBot
       def tip_public_key(key, counter: 0)
         raise ArgumentError, 'invalid key' if key.size < 32
 
-        (key[0...32].bytes + MixinBot::Utils.encode_uint_64(counter + 1)).pack('c*').unpack1('H*')
+        (key[0...32].bytes + MixinBot::Utils.encode_uint64(counter + 1)).pack('c*').unpack1('H*')
+      end
+
+      def hash_scalar(pkey, output_index)
+        tmp = [output_index].pack('Q<').reverse
+
+        hash1 = Digest::Blake3.digest(pkey + tmp)
+        hash2 = Digest::Blake3.digest hash1
+
+        hash3 = Digest::Blake3.digest(hash1 + hash2)
+        hash4 = Digest::Blake3.digest hash3
+
+        hash3 + hash4
+      end
+
+      def multiply_keys(public_key:, private_key:)
+        public_point = JOSE::JWA::Edwards25519Point.stdbase.decode public_key
+        private_scalar = scalar_from_bytes private_key
+        (public_point * private_scalar.x.to_i).encode
+      end
+
+      def derive_ghost_public_key(private_key, view_key, spend_key, index)
+        mult_value = multiply_keys(public_key: view_key, private_key:)
+
+        x = hash_scalar mult_value, index
+
+        p1 = JOSE::JWA::Edwards25519Point.stdbase.decode spend_key
+        p2 = JOSE::JWA::Edwards25519Point.stdbase * scalar_from_bytes(x).x.to_i
+
+        (p1 + p2).encode
+      end
+
+      def derive_ghost_private_key(public_key, view_key, spend_key, index)
+        mult_value = multiply_keys(public_key:, private_key: view_key)
+
+        x = hash_scalar mult_value, index
+
+        x_scalar = scalar_from_bytes x
+        y_scalar = scalar_from_bytes spend_key
+
+        (x_scalar + y_scalar).to_bytes(36)
       end
     end
   end