mixin_bot 2.2.2 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5a607209836b8c47fbcff727229f7ab93940f9b1dc5a99d4ab307345ffa952a0
-  data.tar.gz: aae920ac21d384f0a978b7e4a07e20df5c55cc6016cd7fbce1fa5231c638b742
+  metadata.gz: 06d699c83730cba7bfd93dedbc47f96b1d97c1cd2d4816babd0d310effce3f99
+  data.tar.gz: 8ac62f6fbd15d257d3fae717eb3e3ae1fbca0a46caf9f7f6a03b81797ec7fdf7
 SHA512:
-  metadata.gz: 46937ef32ab9ada8e3218c682fbe36a4086f7688ed5cf21ed5ad5aab575f9e8d8fe65c45220748021194500b486a538a06ddaa4d653af6762d65744c0bff51f8
-  data.tar.gz: 4a6d552a0fc8476105cf553b79ab1f2c231db95acc4cedec9131cc805758c1a68fd9845bc819f5396a42c297b3caf20f119a57e9cd066ab37d7f1cb7de04edb5
+  metadata.gz: ded5aea75050e8ea99a1fd95de4473229fd0dc8c38fa819b01f039ed1917b791e4ccb8183e519521973447b82f909a333f467b438aacd1a9e50f8dff679ea85d
+  data.tar.gz: e4041c6a976a0127cb4d2740cda7315f5c16d72cd6edc0b0ca54f978fac8ce64d33d464e730863181473d361b1f5b69d98ae0903e746f5fea0ba979db8d0e354

data/AGENTS.md

@@ -1,6 +1,6 @@
 # AGENTS.md — MixinBot
 
-Ruby gem (v2.2.1): Mixin Network REST SDK + `mixinbot` CLI. Parity targets: [bot-api-go-client](https://github.com/MixinNetwork/bot-api-go-client), [bot-api-nodejs-client](https://github.com/MixinNetwork/bot-api-nodejs-client).
+Ruby gem (v2.3.0): Mixin Network REST SDK + `mixinbot` CLI. Parity targets: [bot-api-go-client](https://github.com/MixinNetwork/bot-api-go-client), [bot-api-nodejs-client](https://github.com/MixinNetwork/bot-api-nodejs-client).
 
 ## Commands
 

data/CHANGELOG.md

@@ -7,6 +7,47 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.4.0] - 2026-07-20
+
+### Added
+
+- **Blaze WebSocket User-Agent** — the client now sends a `User-Agent` header on Blaze WebSocket connections.
+
+### Changed
+
+- **`sha3` dependency** — upgraded from `~> 1.0` to `~> 2.2` (sha3 2.x renames `SHA3::Digest::SHA256` to `SHA3::Digest::SHA3_256`; hash output is unchanged).
+
+### Fixed
+
+- **Payment URL formatting** — `safe_pay_url` now formats amounts without scientific notation for very small or large values.
+
+### Performance
+
+- **Encoder allocations** — replaced `Array` splat patterns with `Array#concat` in `Transaction::Encoder`, `Nfo`, `InvoiceEntry`, `EncryptedMessage`, and `MVM::Registry` to avoid O(n²) reallocation.
+- **Bytes pack caching** — cached `bytes.pack` results in transaction encoders to reduce duplicate allocations.
+
+## [2.3.0] - 2026-05-27
+
+### Added
+
+- **`MixinBot::APIError`** — structured base for API failures with `code`, `description`, `request_id`, `extra`, and helpers `retryable?`, `throttle?`, `client_error?`.
+- **Typed API errors** — `RateLimitError`, `ValidationError`, `ConflictError`, `TransferError`, `TransientError`, `AppUpdateRequiredError`, `InvalidAddressFormatError`, `ServerError`.
+- **`MixinBot.retryable?(error)`** — canonical retry policy for network timeouts, server errors (500+), and transient codes (10104, 10105).
+- **CLI** — structured error kind `rate_limit`; API errors in JSON output include `code`, `request_id`, and `throttle` when available.
+- **`test/mixin_bot/client/test_error_mapper.rb`** — unit tests for full official error-code catalog, legacy codes, HTTP fallbacks, and retry/throttle semantics.
+
+### Changed
+
+- **BREAKING: Error code mapping** — aligned to [Mixin API error codes](https://developers.mixin.one/docs/api/error-codes). Code `429` raises `RateLimitError` (not `ForbiddenError`). Codes `10002` and `20116` raise `ValidationError` and `ConflictError` respectively. `ForbiddenError` is reserved for code `403`.
+- **`Monitor.check_retryable_error`** — delegates to `MixinBot.retryable?` (no longer retries on `"insufficient"` message substrings).
+- **`Client#parse_response!`** — HTTP status fallback for 401/403/429/5xx when JSON `error` is absent (CDN/proxy edge cases).
+
+### Migration
+
+- Rescue rate limits explicitly: `rescue MixinBot::RateLimitError` (or check `error.throttle?`).
+- Replace string-based retry heuristics with `MixinBot.retryable?(error)`.
+- If you rescued `ForbiddenError` expecting throttling, update to handle `RateLimitError` separately.
+
 ## [2.2.2] - 2026-05-24
 
 ### Fixed

data/README.md

@@ -6,7 +6,7 @@ Ruby SDK and CLI for [Mixin Network](https://developers.mixin.one/docs): authent
 
 The gem aims for **parity with the official [bot-api-go-client](https://github.com/MixinNetwork/bot-api-go-client)** Go SDK and **[bot-api-nodejs-client](https://github.com/MixinNetwork/bot-api-nodejs-client)** Node SDK. See [API_COVERAGE.md](API_COVERAGE.md) for the full mapping; run `rake mixin_bot:api_coverage` to confirm no gaps are marked missing.
 
-Current gem version: **2.2.1** (see [CHANGELOG.md](CHANGELOG.md) for breaking changes and deprecations).
+Current gem version: **2.3.0** (see [CHANGELOG.md](CHANGELOG.md) for breaking changes and deprecations).
 
 ## Requirements
 
@@ -194,7 +194,11 @@ Top-level helpers on **`MixinBot::API`**: `access_token`, `encode_raw_transactio
 
 ### Errors
 
-Custom errors under `MixinBot::` include `ResponseError`, `UnauthorizedError`, `InsufficientBalanceError`, `UtxoInsufficientError`, `PinError`, and `InvalidInvoiceFormatError`. See `lib/mixin_bot/errors.rb`.
+API failures raise structured `MixinBot::APIError` subclasses with `code`, `description`, `request_id`, and behavior helpers (`retryable?`, `throttle?`). The full mapping follows the [Mixin error codes](https://developers.mixin.one/docs/api/error-codes) table — notably `429` → `RateLimitError`, not `ForbiddenError`.
+
+Use `MixinBot.retryable?(error)` for job retry decisions; use `error.throttle?` on `RateLimitError` for global backoff. `Monitor.check_retryable_error` delegates to the same policy.
+
+Local validation errors (`ArgumentError`, `InvalidInvoiceFormatError`, …) and `InsufficientAppBillingError` (billing preflight) are separate from API envelope errors. See `lib/mixin_bot/errors.rb`.
 
 ### Multiple bots
 

data/docs/agent/cli.md

@@ -72,7 +72,24 @@ Error (stderr, exit 1):
 }
 ```
 
-Error kinds: `invalid_args`, `auth`, `not_found`, `api_error`, `billing`, `unsupported`, `conflict`, `internal`.
+API failures may also include `code`, `request_id`, and `throttle` (true for rate limits):
+
+```json
+{
+  "status": "error",
+  "error": {
+    "kind": "rate_limit",
+    "message": "GET | /me | {}, errcode: 429, ...",
+    "code": 429,
+    "request_id": "abc-123",
+    "throttle": true
+  }
+}
+```
+
+Error kinds: `invalid_args`, `auth`, `not_found`, `rate_limit`, `api_error`, `billing`, `unsupported`, `conflict`, `internal`.
+
+For retry logic in automation, prefer `MixinBot.retryable?(exception)` in Ruby; CLI kinds mark `rate_limit` as non-retryable (use global backoff when `throttle` is true).
 
 ## Commands
 

data/lib/mixin_bot/address.rb

@@ -109,7 +109,7 @@ module MixinBot
 
       self.payload = prefix + msg
 
-      checksum = SHA3::Digest::SHA256.digest(MIX_ADDRESS_PREFIX + payload)
+      checksum = SHA3::Digest::SHA3_256.digest(MIX_ADDRESS_PREFIX + payload)
       data = payload + checksum[0...4]
       data = Base58.binary_to_base58 data, :bitcoin
       self.address = "#{MIX_ADDRESS_PREFIX}#{data}"
@@ -126,10 +126,10 @@ module MixinBot
         raise ArgumentError, 'invalid address, length invalid' if data.length < 3 + 16 + 4
 
         self.payload = data[...-4]
-        checksum = SHA3::Digest::SHA256.digest(MIX_ADDRESS_PREFIX + payload)[0...4]
+        checksum = SHA3::Digest::SHA3_256.digest(MIX_ADDRESS_PREFIX + payload)[0...4]
         raise ArgumentError, 'invalid address, checksum invalid' unless checksum == data[-4..]
       else
-        checksum = SHA3::Digest::SHA256.digest(MIX_ADDRESS_PREFIX + payload)[0...4]
+        checksum = SHA3::Digest::SHA3_256.digest(MIX_ADDRESS_PREFIX + payload)[0...4]
         data = payload + checksum
         data = Base58.binary_to_base58 data, :bitcoin
         self.address = "#{MIX_ADDRESS_PREFIX}#{data}"
@@ -171,7 +171,7 @@ module MixinBot
 
     def encode
       msg = MAIN_ADDRESS_PREFIX + public_key
-      checksum = SHA3::Digest::SHA256.digest msg
+      checksum = SHA3::Digest::SHA3_256.digest msg
       data = public_key + checksum[0...4]
       base58 = Base58.binary_to_base58 data, :bitcoin
       self.address = "#{MAIN_ADDRESS_PREFIX}#{base58}"
@@ -188,7 +188,7 @@ module MixinBot
       payload = data[...-4]
 
       msg = MAIN_ADDRESS_PREFIX + payload
-      checksum = SHA3::Digest::SHA256.digest msg
+      checksum = SHA3::Digest::SHA3_256.digest msg
 
       raise ArgumentError, 'invalid address' unless checksum[0...4] == data[-4..]
 
@@ -200,8 +200,8 @@ module MixinBot
     def self.burning_address
       seed = "\0" * 64
 
-      digest1 = SHA3::Digest::SHA256.digest seed
-      digest2 = SHA3::Digest::SHA256.digest digest1
+      digest1 = SHA3::Digest::SHA3_256.digest seed
+      digest2 = SHA3::Digest::SHA3_256.digest digest1
       src = digest1 + digest2
 
       spend_key = MixinBot::Utils.shared_public_key(seed)

data/lib/mixin_bot/api/address.rb

@@ -6,7 +6,7 @@ module MixinBot
       def safe_deposit_entries(**kwargs)
         path = '/safe/deposit/entries'
 
-        members = [kwargs[:members]] if kwargs[:members].is_a? String
+        members = Array(kwargs[:members])
 
         payload = {
           members:,

data/lib/mixin_bot/api/blaze.rb

@@ -10,7 +10,7 @@ module MixinBot
         Faye::WebSocket::Client.new(
           format('wss://%<host>s/', host: config.blaze_host),
           ['Mixin-Blaze-1'],
-          headers: { 'Authorization' => authorization },
+          headers: { 'Authorization' => authorization, 'User-Agent' => "mixin_bot/#{MixinBot::VERSION}" },
           ping: 60
         )
       end

data/lib/mixin_bot/api/encrypted_message.rb

@@ -126,8 +126,8 @@ module MixinBot
         ciphertext = encrypter.update(Base64.urlsafe_decode64(data)) + encrypter.final + encrypter.auth_tag
 
         bytes = [1]
-        bytes += [sessions.size].pack('v*').bytes
-        bytes += JOSE::JWA::Ed25519.pk_to_curve25519(pk).bytes
+        bytes.concat([sessions.size].pack('v*').bytes)
+        bytes.concat(JOSE::JWA::Ed25519.pk_to_curve25519(pk).bytes)
 
         sessions.each do |session|
           aes_key = JOSE::JWA::X25519.shared_secret(
@@ -143,12 +143,12 @@ module MixinBot
           iv = encrypter.random_iv
           encrypter.iv = iv
 
-          bytes += (MixinBot::UUID.new(hex: session['session_id']).packed + iv).bytes
-          bytes += encrypter.update(key + padtext).bytes
+          bytes.concat((MixinBot::UUID.new(hex: session['session_id']).packed + iv).bytes)
+          bytes.concat(encrypter.update(key + padtext).bytes)
         end
 
-        bytes += nounce.bytes
-        bytes += ciphertext.bytes
+        bytes.concat(nounce.bytes)
+        bytes.concat(ciphertext.bytes)
 
         Base64.urlsafe_encode64 bytes.pack('C*'), padding: false
       end

data/lib/mixin_bot/api/legacy_transaction.rb

@@ -89,7 +89,7 @@ module MixinBot
           end
         end
 
-        asset = asset_mixin_id || SHA3::Digest::SHA256.hexdigest(asset_id)
+        asset = asset_mixin_id || SHA3::Digest::SHA3_256.hexdigest(asset_id)
         {
           version:,
           asset:,

data/lib/mixin_bot/api/legacy_user.rb

@@ -10,12 +10,15 @@ module MixinBot
         kl = keystore.with_indifferent_access
         priv = OpenSSL::PKey::RSA.new(kl[:private_key])
         token = Base64.decode64(kl[:pin_token])
+        # Use string keys with the dash form (`'oaep-label'`) for Ruby 4.0
+        # compatibility; the underscore form `oaep_label` is no longer
+        # recognized by the OpenSSL EVP_PKEY_CTX in Ruby 4.0.
         key_bytes = priv.decrypt(
           token,
-          rsa_padding_mode: 'oaep',
-          rsa_oaep_md: 'sha256',
-          rsa_mgf1_md: 'sha1',
-          oaep_label: kl[:session_id]
+          'rsa_padding_mode' => 'oaep',
+          'rsa_oaep_md' => 'sha256',
+          'rsa_mgf1_md' => 'sha1',
+          'oaep-label' => kl[:session_id]
         )
 
         pin_byte = kl[:pin].to_s.b

data/lib/mixin_bot/api/payment.rb

@@ -12,6 +12,9 @@ module MixinBot
         trace_id = kwargs[:trace_id] || SecureRandom.uuid
 
         mix_address = MixinBot.utils.build_mix_address(members:, threshold:)
+        # Format amount without scientific notation so the Mixin web UI's URL
+        # parser accepts it. Mirrors `MixinBot::Utils::Address#build_safe_recipient`.
+        amount = format('%.8f', amount.to_d.to_r).gsub(/\.?0+\z/, '')
 
         "https://mixin.one/pay/#{mix_address}?amount=#{amount}&asset=#{asset_id}&memo=#{memo}&trace=#{trace_id}"
       end

data/lib/mixin_bot/api/transaction.rb

@@ -138,7 +138,7 @@ module MixinBot
           aid = h[:asset_id]
           raise ArgumentError, 'utxo asset_id or asset is required' if aid.blank?
 
-          SHA3::Digest::SHA256.hexdigest(aid)
+          SHA3::Digest::SHA3_256.hexdigest(aid)
         end
 
         asset = mixin_asset_for.call(utxos[0])

data/lib/mixin_bot/api/user.rb

@@ -164,9 +164,9 @@ module MixinBot
         signing_key_hex = keypair[1].unpack1('H*')
 
         # NOTE: the Go SDK's +crypto.Sha256Hash+ is misleadingly named — it
-        # actually computes SHA3-256, so +SHA3::Digest::SHA256+ is the correct
+        # actually computes SHA3-256, so +SHA3::Digest::SHA3_256+ is the correct
         # match. See bot-api-go-client safe_user.go +RegisterSafeBareUser+.
-        app_id_hash = SHA3::Digest::SHA256.hexdigest config.app_id
+        app_id_hash = SHA3::Digest::SHA3_256.hexdigest config.app_id
         signature = Base64.urlsafe_encode64(
           JOSE::JWA::Ed25519.sign([app_id_hash].pack('H*'), keypair[1]),
           padding: false

data/lib/mixin_bot/cli/errors.rb

@@ -9,6 +9,7 @@ module MixinBot
       invalid_args: { retryable: false, description: 'Invalid or missing arguments' },
       auth: { retryable: false, description: 'Authentication or authorization failed' },
       not_found: { retryable: false, description: 'Requested resource was not found' },
+      rate_limit: { retryable: false, description: 'API rate limit exceeded; slow down globally' },
       api_error: { retryable: false, description: 'Mixin API returned an error' },
       unsupported: { retryable: false, description: 'Operation is not supported in this context' },
       conflict: { retryable: false, description: 'Resource exists with incompatible configuration' },
@@ -30,16 +31,19 @@ module MixinBot
 
     def kind_for_exception(error)
       case error
-      when MixinBot::ArgumentError, ::ArgumentError
+      when MixinBot::ArgumentError, ::ArgumentError, ValidationError, InvalidAddressFormatError
         :invalid_args
+      when RateLimitError
+        :rate_limit
       when UnauthorizedError, ForbiddenError, PinError, ConfigurationNotValidError
         :auth
       when NotFoundError, UserNotFoundError
         :not_found
       when InsufficientAppBillingError
         :billing
-      when ResponseError, RequestError, HttpError,
-           InsufficientBalanceError, UtxoInsufficientError, InsufficientPoolError
+      when ResponseError, RequestError, HttpError, ServerError,
+           InsufficientBalanceError, UtxoInsufficientError, InsufficientPoolError,
+           ConflictError, TransferError, TransientError, AppUpdateRequiredError
         :api_error
       else
         :internal
@@ -50,6 +54,7 @@ module MixinBot
       msg = message.to_s.downcase
       return :auth if msg.include?('unauthorized') || msg.include?('authentication')
       return :not_found if msg.include?('not found') || msg.include?('404')
+      return :rate_limit if msg.include?('too many requests') || msg.include?('errcode: 429')
       return :unsupported if msg.include?('unsupported') || msg.include?('not supported')
       return :invalid_args if msg.include?('invalid') || msg.include?('unknown')
 

data/lib/mixin_bot/cli/output.rb

@@ -84,6 +84,11 @@ module MixinBot
           }
         }
         error_body['error']['hint'] = hint if hint.present?
+        if exception.is_a?(MixinBot::APIError)
+          error_body['error']['code'] = exception.code unless exception.code.nil?
+          error_body['error']['request_id'] = exception.request_id if exception.request_id.present?
+          error_body['error']['throttle'] = true if exception.respond_to?(:throttle?) && exception.throttle?
+        end
         warn(JSON.generate(error_body))
       else
         warn(format_error(message))

data/lib/mixin_bot/client/error_mapper.rb

@@ -6,34 +6,54 @@ module MixinBot
     # Maps Mixin API +error+ objects to Ruby exceptions.
     #
     module ErrorMapper
+      CODE_MAP = {
+        400 => ValidationError,
+        401 => UnauthorizedError,
+        403 => ForbiddenError,
+        404 => NotFoundError,
+        429 => RateLimitError,
+        10_002 => ValidationError,
+        10_006 => AppUpdateRequiredError,
+        10_104 => TransientError,
+        10_105 => TransientError,
+        10_404 => UserNotFoundError,
+        20_116 => ConflictError,
+        20_117 => InsufficientBalanceError,
+        20_118 => PinError,
+        20_119 => PinError,
+        20_120 => TransferError,
+        20_121 => UnauthorizedError,
+        20_123 => ConflictError,
+        20_124 => InsufficientBalanceError,
+        20_125 => ConflictError,
+        20_127 => TransferError,
+        20_131 => ValidationError,
+        20_133 => ConflictError,
+        20_134 => TransferError,
+        20_135 => TransferError,
+        20_150 => ValidationError,
+        30_102 => InvalidAddressFormatError,
+        30_103 => InsufficientPoolError,
+        500 => ServerError,
+        7000 => ServerError,
+        7001 => ServerError
+      }.freeze
+
       module_function
 
       def raise_for!(verb:, path:, body:, response:, result:)
         err = result['error'] || {}
-        code = err['code']
-        desc = err['description']
-        req_id = response&.headers&.[]('X-Request-Id')
-        srv_time = response&.headers&.[]('X-Server-Time')
-        errmsg = "#{verb.upcase} | #{path} | #{body}, errcode: #{code}, errmsg: #{desc}, request_id: #{req_id}, server_time: #{srv_time}"
+        code = err['code']&.to_i
+        klass = CODE_MAP[code] || default_class_for_code(code)
+        raise APIError.build(klass, verb:, path:, body:, response:, result:)
+      end
+
+      def build(klass, verb:, path:, body:, response:, result:, **)
+        APIError.build(klass, verb:, path:, body:, response:, result:, **)
+      end
 
-        case code
-        when 401, 20_121
-          raise UnauthorizedError, errmsg
-        when 403, 20_116, 10_002, 429
-          raise ForbiddenError, errmsg
-        when 404
-          raise NotFoundError, errmsg
-        when 20_117
-          raise InsufficientBalanceError, errmsg
-        when 20_118, 20_119
-          raise PinError, errmsg
-        when 30_103
-          raise InsufficientPoolError, errmsg
-        when 10_404
-          raise UserNotFoundError, errmsg
-        else
-          raise ResponseError, errmsg
-        end
+      def default_class_for_code(_code)
+        ResponseError
       end
     end
   end

data/lib/mixin_bot/client.rb

@@ -125,9 +125,30 @@ module MixinBot
 
     def parse_response!(verb:, path:, body:, response:)
       result = response.body
-      return MixinBot::Models::ApiEnvelope.new(result) if result['error'].blank?
+      result = {} unless result.is_a?(Hash)
+
+      if result['error'].blank?
+        raise_http_status_error!(verb:, path:, body:, response:) if http_error_status?(response.status)
+        return MixinBot::Models::ApiEnvelope.new(result)
+      end
 
       ErrorMapper.raise_for!(verb:, path:, body:, response:, result:)
     end
+
+    def http_error_status?(status)
+      [401, 403, 429].include?(status) || status >= 500
+    end
+
+    def raise_http_status_error!(verb:, path:, body:, response:)
+      klass =
+        case response.status
+        when 429 then RateLimitError
+        when 401 then UnauthorizedError
+        when 403 then ForbiddenError
+        else ServerError
+        end
+
+      raise ErrorMapper.build(klass, verb:, path:, body:, response:, result: {})
+    end
   end
 end

data/lib/mixin_bot/errors.rb

@@ -7,7 +7,7 @@ module MixinBot
   class Error < StandardError; end
 
   ##
-  # Raised when invalid arguments are provided.
+  # Raised when invalid arguments are provided (local validation, not API code 400).
   #
   class ArgumentError < StandardError; end
 
@@ -22,34 +22,196 @@ module MixinBot
   class RequestError < Error; end
 
   ##
-  # Raised when Mixin API returns an error response.
+  # Base class for Mixin API error responses with structured metadata.
   #
-  class ResponseError < Error; end
+  class APIError < Error
+    attr_reader :code, :description, :status, :http_status, :request_id, :server_time,
+                :retry_after, :extra, :path, :verb, :body
+
+    # rubocop:disable Metrics/ParameterLists -- structured API error metadata
+    def initialize(message = nil, code: nil, description: nil, status: nil, http_status: nil,
+                   request_id: nil, server_time: nil, retry_after: nil, extra: nil,
+                   path: nil, verb: nil, body: nil)
+      @code = code&.to_i
+      @description = description
+      @status = status&.to_i
+      @http_status = http_status&.to_i
+      @request_id = request_id
+      @server_time = server_time
+      @retry_after = retry_after
+      @extra = extra
+      @path = path
+      @verb = verb
+      @body = body
+      super(message || formatted_message)
+    end
+    # rubocop:enable Metrics/ParameterLists
+
+    def client_error?
+      c = code.to_i
+      return true if c.between?(400, 499)
+      return true if http_status == 202 && c.positive? && c < 500
+
+      false
+    end
+
+    def retryable?
+      false
+    end
+
+    def throttle?
+      false
+    end
+
+    def formatted_message
+      format(
+        '%<verb>s | %<path>s | %<body>s, errcode: %<code>s, errmsg: %<description>s, ' \
+        'request_id: %<request_id>s, server_time: %<server_time>s',
+        verb: verb.to_s.upcase,
+        path: path.to_s,
+        body: body.to_s,
+        code: code,
+        description: description,
+        request_id: request_id,
+        server_time: server_time
+      )
+    end
+
+    class << self
+      def build(klass, verb:, path:, body:, response:, result:, code: nil, description: nil)
+        err = result.is_a?(Hash) ? (result['error'] || {}) : {}
+        resolved_code = code || err['code'] || infer_code_from_http(response)
+        resolved_description = description || err['description'] || http_status_description(response&.status)
+        headers = response&.headers || {}
+        retry_after = headers['Retry-After'] if klass <= RateLimitError
+
+        klass.new(
+          code: resolved_code,
+          description: resolved_description,
+          status: err['status'],
+          http_status: response&.status,
+          request_id: headers['X-Request-Id'],
+          server_time: headers['X-Server-Time'],
+          retry_after: retry_after,
+          extra: err['extra'],
+          path: path,
+          verb: verb,
+          body: body
+        )
+      end
+
+      private
+
+      def infer_code_from_http(response)
+        return nil unless response
+
+        case response.status
+        when 401 then 401
+        when 403 then 403
+        when 429 then 429
+        else
+          response.status if response.status >= 500
+        end
+      end
+
+      def http_status_description(status)
+        case status
+        when 401 then 'Unauthorized'
+        when 403 then 'Forbidden'
+        when 429 then 'Too Many Requests'
+        when 500.. then 'Internal Server Error'
+        else
+          "HTTP #{status}"
+        end
+      end
+    end
+  end
 
   ##
-  # Raised when a requested resource is not found (HTTP 404).
+  # Raised when Mixin API returns an error response (unmapped or generic codes).
   #
-  class NotFoundError < Error; end
+  class ResponseError < APIError
+    def retryable?
+      code.to_i >= 500
+    end
+  end
+
+  ##
+  # Raised when a requested resource is not found (error code 404).
+  #
+  class NotFoundError < APIError; end
 
   ##
   # Raised when a user is not found (error code 10404).
   #
-  class UserNotFoundError < Error; end
+  class UserNotFoundError < APIError; end
+
+  ##
+  # Raised when authentication fails (error codes 401, 20121).
+  #
+  class UnauthorizedError < APIError; end
+
+  ##
+  # Raised when access is forbidden (error code 403).
+  #
+  class ForbiddenError < APIError; end
+
+  ##
+  # Raised when the API rate limit is exceeded (error code 429).
+  #
+  class RateLimitError < APIError
+    def throttle?
+      true
+    end
+  end
+
+  ##
+  # Raised when request data is invalid (error codes 400, 10002, 20131, 20150).
+  #
+  class ValidationError < APIError; end
+
+  ##
+  # Raised when a resource conflict or capacity limit applies (error codes 20116, 20123, 20125, 20133).
+  #
+  class ConflictError < APIError; end
+
+  ##
+  # Raised for transfer/withdraw amount or fee constraints.
+  #
+  class TransferError < APIError; end
+
+  ##
+  # Raised for transient conditions that may succeed on retry (error codes 10104, 10105).
+  #
+  class TransientError < APIError
+    def retryable?
+      true
+    end
+  end
 
   ##
-  # Raised when authentication fails (HTTP 401).
+  # Raised when the app must be updated (error code 10006).
   #
-  class UnauthorizedError < Error; end
+  class AppUpdateRequiredError < APIError; end
 
   ##
-  # Raised when access is forbidden (HTTP 403).
+  # Raised when an address format is invalid (error code 30102).
   #
-  class ForbiddenError < Error; end
+  class InvalidAddressFormatError < APIError; end
 
   ##
-  # Raised when there is insufficient balance for a transaction (error code 20117).
+  # Raised for server-side failures (error codes 500, 7000, 7001).
   #
-  class InsufficientBalanceError < Error; end
+  class ServerError < APIError
+    def retryable?
+      true
+    end
+  end
+
+  ##
+  # Raised when there is insufficient balance for a transaction (error codes 20117, 20124).
+  #
+  class InsufficientBalanceError < APIError; end
 
   ##
   # Raised when app prepaid billing credit lacks headroom for a billed operation.
@@ -77,8 +239,8 @@ module MixinBot
   class UtxoInsufficientError < InsufficientBalanceError
     attr_reader :total_input, :total_output, :output_size
 
-    def initialize(message, total_input: nil, total_output: nil, output_size: nil)
-      super(message)
+    def initialize(message = nil, total_input: nil, total_output: nil, output_size: nil, **)
+      super(message, **)
       @total_input = total_input
       @total_output = total_output
       @output_size = output_size
@@ -88,12 +250,12 @@ module MixinBot
   ##
   # Raised when there is insufficient pool for a transaction (error code 30103).
   #
-  class InsufficientPoolError < Error; end
+  class InsufficientPoolError < APIError; end
 
   ##
   # Raised when PIN verification fails (error codes 20118, 20119).
   #
-  class PinError < Error; end
+  class PinError < APIError; end
 
   ##
   # Raised when NFO memo format is invalid.
@@ -119,4 +281,16 @@ module MixinBot
   # Raised when invoice format is invalid.
   #
   class InvalidInvoiceFormatError < Error; end
+
+  class << self
+    ##
+    # Canonical retry decision for API and network failures.
+    #
+    def retryable?(error)
+      return true if error.is_a?(Faraday::TimeoutError) || error.is_a?(Faraday::ConnectionFailed)
+      return error.retryable? if error.respond_to?(:retryable?)
+
+      false
+    end
+  end
 end

data/lib/mixin_bot/invoice.rb

@@ -54,7 +54,7 @@ module MixinBot
       payload = payload.pack('C*')
 
       # Calculate checksum
-      checksum = SHA3::Digest::SHA256.digest(INVOICE_PREFIX + payload)[0...4]
+      checksum = SHA3::Digest::SHA3_256.digest(INVOICE_PREFIX + payload)[0...4]
 
       # Combine everything and encode to base64
       self.address = INVOICE_PREFIX + Base64.urlsafe_encode64(payload + checksum, padding: false)
@@ -68,7 +68,7 @@ module MixinBot
       raise MixinBot::InvalidInvoiceFormatError, 'invalid invoice payload size' if data.size < 3 + 23 + 1
 
       payload = data[...-4]
-      checksum = SHA3::Digest::SHA256.digest(INVOICE_PREFIX + payload)[0...4]
+      checksum = SHA3::Digest::SHA3_256.digest(INVOICE_PREFIX + payload)[0...4]
       raise MixinBot::InvalidInvoiceFormatError, 'invalid invoice checksum' unless checksum == data[-4..]
 
       payload = payload.bytes
@@ -141,29 +141,29 @@ module MixinBot
     def encode
       bytes = []
 
-      bytes += MixinBot::UUID.new(hex: trace_id).packed.bytes
-      bytes += MixinBot::UUID.new(hex: asset_id).packed.bytes
+      bytes.concat MixinBot::UUID.new(hex: trace_id).packed.bytes
+      bytes.concat MixinBot::UUID.new(hex: asset_id).packed.bytes
 
       amount_string = amount.to_d.to_s('F')
       amount_bytes = amount_string.bytes
-      bytes += MixinBot.utils.encode_int(amount_bytes.size)
-      bytes += amount_bytes
+      bytes.concat MixinBot.utils.encode_int(amount_bytes.size)
+      bytes.concat amount_bytes
 
       extra_bytes = extra.bytes
-      bytes += MixinBot.utils.encode_uint16(extra_bytes.size)
-      bytes += extra_bytes
+      bytes.concat MixinBot.utils.encode_uint16(extra_bytes.size)
+      bytes.concat extra_bytes
 
       references_count = (index_references || []).size + (hash_references || []).size
-      bytes += MixinBot.utils.encode_int(references_count)
+      bytes.concat MixinBot.utils.encode_int(references_count)
 
       index_references&.each do |index|
-        bytes += MixinBot.utils.encode_int(1)
-        bytes += MixinBot.utils.encode_int(index)
+        bytes.concat MixinBot.utils.encode_int(1)
+        bytes.concat MixinBot.utils.encode_int(index)
       end
 
       hash_references&.each do |hash|
-        bytes += MixinBot.utils.encode_int(0)
-        bytes += [hash].pack('H*').bytes
+        bytes.concat MixinBot.utils.encode_int(0)
+        bytes.concat [hash].pack('H*').bytes
       end
 
       bytes

data/lib/mixin_bot/monitor.rb

@@ -61,16 +61,7 @@ module MixinBot
       end
 
       def check_retryable_error(error)
-        return false if error.nil?
-
-        reason = error.message.to_s.downcase
-        return true if reason.include?('timeout')
-        return true if reason.include?('internal server')
-        return true if reason.include?('insufficient')
-        return true if reason.include?('inputs locked by')
-        return true if reason.include?('by other transaction')
-
-        false
+        MixinBot.retryable?(error)
       end
     end
   end

data/lib/mixin_bot/nfo.rb

@@ -39,10 +39,10 @@ module MixinBot
 
     def unique_token_id
       bytes = []
-      bytes += MixinBot::UUID.new(hex: chain).packed.bytes
-      bytes += [nm_class].pack('H*').bytes
-      bytes += MixinBot::UUID.new(hex: collection).packed.bytes
-      bytes += MixinBot.utils.encode_int token
+      bytes.concat MixinBot::UUID.new(hex: chain).packed.bytes
+      bytes.concat [nm_class].pack('H*').bytes
+      bytes.concat MixinBot::UUID.new(hex: collection).packed.bytes
+      bytes.concat MixinBot.utils.encode_int token
 
       md5 = Digest::MD5.new
       md5.update bytes.pack('c*')
@@ -67,33 +67,33 @@ module MixinBot
     def encode
       bytes = []
 
-      bytes += prefix.bytes
-      bytes += [version]
+      bytes.concat prefix.bytes
+      bytes.push(version)
 
       if mask.zero?
-        bytes += [0]
+        bytes << 0
       else
-        bytes += [1]
-        bytes += MixinBot.utils.encode_uint64 mask
-        bytes += MixinBot::UUID.new(hex: chain).packed.bytes
+        bytes << 1
+        bytes.concat MixinBot.utils.encode_uint64 mask
+        bytes.concat MixinBot::UUID.new(hex: chain).packed.bytes
 
         class_bytes = [nm_class].pack('H*').bytes
-        bytes += MixinBot.utils.encode_int class_bytes.size
-        bytes += class_bytes
+        bytes.concat MixinBot.utils.encode_int class_bytes.size
+        bytes.concat class_bytes
 
         collection_bytes = collection.split('-').pack('H* H* H* H* H*').bytes
-        bytes += MixinBot.utils.encode_int collection_bytes.size
-        bytes += collection_bytes
+        bytes.concat MixinBot.utils.encode_int collection_bytes.size
+        bytes.concat collection_bytes
 
         # token_bytes = memo[:token].split('-').pack('H* H* H* H* H*').bytes
         token_bytes = MixinBot.utils.encode_int token
-        bytes += MixinBot.utils.encode_int token_bytes.size
-        bytes += token_bytes
+        bytes.concat MixinBot.utils.encode_int token_bytes.size
+        bytes.concat token_bytes
       end
 
       extra_bytes = [extra].pack('H*').bytes
-      bytes += MixinBot.utils.encode_int extra_bytes.size
-      bytes += extra_bytes
+      bytes.concat MixinBot.utils.encode_int extra_bytes.size
+      bytes.concat extra_bytes
 
       @raw = bytes.pack('C*')
       @hex = raw.unpack1('H*')

data/lib/mixin_bot/transaction/decoder.rb

@@ -12,7 +12,7 @@ module MixinBot
 
       def decode
         raw = [@tx.hex].pack('H*').bytes
-        @tx.hash = SHA3::Digest::SHA256.hexdigest(raw.pack('C*'))
+        @tx.hash = SHA3::Digest::SHA3_256.hexdigest(raw.pack('C*'))
         @buf = Buffer.new(raw)
 
         magic = @buf.shift(2)

data/lib/mixin_bot/transaction/encoder.rb

@@ -17,28 +17,25 @@ module MixinBot
 
         bytes = []
 
-        bytes += Transaction::MAGIC
-        bytes += [0, @tx.version]
-        bytes += [@tx.asset].pack('H*').bytes
+        bytes.concat Transaction::MAGIC
+        bytes.push(0, @tx.version)
+        bytes.concat [@tx.asset].pack('H*').bytes
 
-        bytes += encode_inputs
-        bytes += encode_outputs
-        bytes += encode_references if @tx.version >= Transaction::REFERENCES_TX_VERSION
+        bytes.concat encode_inputs
+        bytes.concat encode_outputs
+        bytes.concat encode_references if @tx.version >= Transaction::REFERENCES_TX_VERSION
 
         extra_bytes = @tx.extra.bytes
         raise InvalidTransactionFormatError, 'extra is too long' if extra_bytes.size > Transaction::MAX_EXTRA_SIZE
 
-        bytes += MixinBot.utils.encode_uint32 extra_bytes.size
-        bytes += extra_bytes
+        bytes.concat MixinBot.utils.encode_uint32 extra_bytes.size
+        bytes.concat extra_bytes
 
-        bytes += if @tx.aggregated.nil?
-                   encode_signatures
-                 else
-                   encode_aggregated_signature
-                 end
+        bytes.concat(@tx.aggregated.nil? ? encode_signatures : encode_aggregated_signature)
 
-        @tx.hash = SHA3::Digest::SHA256.hexdigest bytes.pack('C*')
-        @tx.hex = bytes.pack('C*').unpack1('H*')
+        packed = bytes.pack('C*')
+        @tx.hash = SHA3::Digest::SHA3_256.hexdigest packed
+        @tx.hex = packed.unpack1('H*')
 
         @tx
       end
@@ -48,63 +45,63 @@ module MixinBot
       def encode_inputs
         bytes = []
 
-        bytes += MixinBot.utils.encode_uint16(@tx.inputs.size)
+        bytes.concat MixinBot.utils.encode_uint16(@tx.inputs.size)
 
         @tx.inputs.each do |input|
-          bytes += [input['hash']].pack('H*').bytes
-          bytes += MixinBot.utils.encode_uint16(input['index'])
+          bytes.concat [input['hash']].pack('H*').bytes
+          bytes.concat MixinBot.utils.encode_uint16(input['index'])
 
           genesis = input['genesis'] || ''
           if genesis.empty?
-            bytes += Transaction::NULL_BYTES
+            bytes.concat Transaction::NULL_BYTES
           else
             genesis_bytes = [genesis].pack('H*').bytes
-            bytes += MixinBot.utils.encode_uint16 genesis_bytes.size
-            bytes += genesis_bytes
+            bytes.concat MixinBot.utils.encode_uint16 genesis_bytes.size
+            bytes.concat genesis_bytes
           end
 
           deposit = input['deposit']
           if deposit.nil?
-            bytes += Transaction::NULL_BYTES
+            bytes.concat Transaction::NULL_BYTES
           else
-            bytes += Transaction::MAGIC
-            bytes += [deposit['chain']].pack('H*').bytes
+            bytes.concat Transaction::MAGIC
+            bytes.concat [deposit['chain']].pack('H*').bytes
 
             asset_bytes = [deposit['asset']].pack('H*')
-            bytes += MixinBot.utils.encode_uint16 asset_bytes.size
-            bytes += asset_bytes.bytes
+            bytes.concat MixinBot.utils.encode_uint16 asset_bytes.size
+            bytes.concat asset_bytes.bytes
 
             transaction_bytes = [deposit['transaction']].pack('H*')
-            bytes += MixinBot.utils.encode_uint16 transaction_bytes.size
-            bytes += transaction_bytes.bytes
+            bytes.concat MixinBot.utils.encode_uint16 transaction_bytes.size
+            bytes.concat transaction_bytes.bytes
 
-            bytes += MixinBot.utils.encode_uint64 deposit['index']
+            bytes.concat MixinBot.utils.encode_uint64 deposit['index']
 
             amount_bytes = MixinBot.utils.bytes_of deposit['amount']
-            bytes += MixinBot.utils.encode_uint16 amount_bytes.size
-            bytes += amount_bytes
+            bytes.concat MixinBot.utils.encode_uint16 amount_bytes.size
+            bytes.concat amount_bytes
           end
 
           mint = input['mint']
           if mint.nil?
-            bytes += Transaction::NULL_BYTES
+            bytes.concat Transaction::NULL_BYTES
           else
-            bytes += Transaction::MAGIC
+            bytes.concat Transaction::MAGIC
 
             group = mint['group'] || ''
             if group.empty?
-              bytes += Transaction::NULL_BYTES
+              bytes.concat Transaction::NULL_BYTES
             else
               group_bytes = [group].pack('H*')
-              bytes += MixinBot.utils.encode_uint16 group_bytes.size
-              bytes += group_bytes.bytes
+              bytes.concat MixinBot.utils.encode_uint16 group_bytes.size
+              bytes.concat group_bytes.bytes
             end
 
-            bytes += MixinBot.utils.encode_uint64 mint['batch']
+            bytes.concat MixinBot.utils.encode_uint64 mint['batch']
 
             amount_bytes = MixinBot.utils.encode_int mint['amount']
-            bytes += MixinBot.utils.encode_uint16 amount_bytes.size
-            bytes += amount_bytes
+            bytes.concat MixinBot.utils.encode_uint16 amount_bytes.size
+            bytes.concat amount_bytes
           end
         end
 
@@ -114,55 +111,55 @@ module MixinBot
       def encode_outputs
         bytes = []
 
-        bytes += MixinBot.utils.encode_uint16 @tx.outputs.size
+        bytes.concat MixinBot.utils.encode_uint16 @tx.outputs.size
 
         @tx.outputs.each do |output|
           type = output['type'] || 0
-          bytes += [0x00, type]
+          bytes.push(0x00, type)
 
           amount_bytes = MixinBot.utils.encode_int((output['amount'].to_d * 1e8).round)
-          bytes += MixinBot.utils.encode_uint16 amount_bytes.size
-          bytes += amount_bytes
+          bytes.concat MixinBot.utils.encode_uint16 amount_bytes.size
+          bytes.concat amount_bytes
 
-          bytes += MixinBot.utils.encode_uint16 output['keys'].size
+          bytes.concat MixinBot.utils.encode_uint16 output['keys'].size
           output['keys'].each do |key|
-            bytes += [key].pack('H*').bytes
+            bytes.concat [key].pack('H*').bytes
           end
 
-          bytes += [output['mask']].pack('H*').bytes
+          bytes.concat [output['mask']].pack('H*').bytes
 
           script_bytes = [output['script']].pack('H*').bytes
-          bytes += MixinBot.utils.encode_uint16 script_bytes.size
-          bytes += script_bytes
+          bytes.concat MixinBot.utils.encode_uint16 script_bytes.size
+          bytes.concat script_bytes
 
           withdrawal = output['withdrawal']
           if withdrawal.nil?
-            bytes += Transaction::NULL_BYTES
+            bytes.concat Transaction::NULL_BYTES
           else
-            bytes += Transaction::MAGIC
+            bytes.concat Transaction::MAGIC
 
-            bytes += [withdrawal['chain']].pack('H*').bytes
+            bytes.concat [withdrawal['chain']].pack('H*').bytes
 
             asset_bytes = [withdrawal['asset']].pack('H*')
-            bytes += MixinBot.utils.encode_uint16 asset_bytes.bytesize
-            bytes += asset_bytes.bytes
+            bytes.concat MixinBot.utils.encode_uint16 asset_bytes.bytesize
+            bytes.concat asset_bytes.bytes
 
             address = withdrawal['address'] || ''
             if address.empty?
-              bytes += Transaction::NULL_BYTES
+              bytes.concat Transaction::NULL_BYTES
             else
               address_bytes = [address].pack('H*').bytes
-              bytes += MixinBot.utils.encode_uint16 address_bytes.size
-              bytes += address_bytes
+              bytes.concat MixinBot.utils.encode_uint16 address_bytes.size
+              bytes.concat address_bytes
             end
 
             tag = withdrawal['tag'] || ''
             if tag.empty?
-              bytes += Transaction::NULL_BYTES
+              bytes.concat Transaction::NULL_BYTES
             else
               tag_bytes = [tag].pack('H*').bytes
-              bytes += MixinBot.utils.encode_uint16 tag_bytes.size
-              bytes += tag_bytes
+              bytes.concat MixinBot.utils.encode_uint16 tag_bytes.size
+              bytes.concat tag_bytes
             end
           end
         end
@@ -174,10 +171,10 @@ module MixinBot
         bytes = []
 
         references = Array(@tx.references)
-        bytes += MixinBot.utils.encode_uint16 references.size
+        bytes.concat MixinBot.utils.encode_uint16 references.size
 
         references.each do |reference|
-          bytes += [reference].pack('H*').bytes
+          bytes.concat [reference].pack('H*').bytes
         end
 
         bytes
@@ -186,14 +183,14 @@ module MixinBot
       def encode_aggregated_signature
         bytes = []
 
-        bytes += MixinBot.utils.encode_uint16 Transaction::MAX_ENCODE_INT
-        bytes += MixinBot.utils.encode_uint16 Transaction::AGGREGATED_SIGNATURE_PREFIX
-        bytes += [@tx.aggregated['signature']].pack('H*').bytes
+        bytes.concat MixinBot.utils.encode_uint16 Transaction::MAX_ENCODE_INT
+        bytes.concat MixinBot.utils.encode_uint16 Transaction::AGGREGATED_SIGNATURE_PREFIX
+        bytes.concat [@tx.aggregated['signature']].pack('H*').bytes
 
         signers = @tx.aggregated['signers'] || []
         if signers.empty?
-          bytes += Transaction::AGGREGATED_SIGNATURE_ORDINAY_MASK
-          bytes += Transaction::NULL_BYTES
+          bytes.concat Transaction::AGGREGATED_SIGNATURE_ORDINAY_MASK
+          bytes.concat Transaction::NULL_BYTES
           return bytes
         end
 
@@ -205,17 +202,17 @@ module MixinBot
         max = signers.last
         sig_byte_len = [@tx.aggregated['signature']].pack('H*').bytes.size
         if ((max / 8) + 1) > sig_byte_len
-          bytes += Transaction::AGGREGATED_SIGNATURE_SPARSE_MASK
-          bytes += MixinBot.utils.encode_uint16 signers.size
-          signers.each { |signer| bytes += MixinBot.utils.encode_uint16(signer) }
+          bytes.concat Transaction::AGGREGATED_SIGNATURE_SPARSE_MASK
+          bytes.concat MixinBot.utils.encode_uint16 signers.size
+          signers.each { |signer| bytes.concat MixinBot.utils.encode_uint16(signer) }
         else
           masks_bytes = Array.new((max / 8) + 1, 0)
           signers.each do |signer|
             masks_bytes[signer / 8] ^= (1 << (signer % 8))
           end
-          bytes += Transaction::AGGREGATED_SIGNATURE_ORDINAY_MASK
-          bytes += MixinBot.utils.encode_uint16 masks_bytes.size
-          bytes += masks_bytes
+          bytes.concat Transaction::AGGREGATED_SIGNATURE_ORDINAY_MASK
+          bytes.concat MixinBot.utils.encode_uint16 masks_bytes.size
+          bytes.concat masks_bytes
         end
 
         bytes
@@ -233,18 +230,18 @@ module MixinBot
 
         raise ArgumentError, 'signatures overflow' if sl == Transaction::MAX_ENCODE_INT
 
-        bytes += MixinBot.utils.encode_uint16 sl
+        bytes.concat MixinBot.utils.encode_uint16 sl
 
         if sl.positive?
           @tx.signatures.each do |signature|
-            bytes += MixinBot.utils.encode_uint16 signature.keys.size
+            bytes.concat MixinBot.utils.encode_uint16 signature.keys.size
 
             signature.keys.sort.each do |key|
               signature_bytes = [signature[key]].pack('H*').bytes
               raise ArgumentError, 'Signature should be 64 bytes' if signature_bytes.size != 64
 
-              bytes += MixinBot.utils.encode_uint16 key
-              bytes += signature_bytes
+              bytes.concat MixinBot.utils.encode_uint16 key
+              bytes.concat signature_bytes
             end
           end
         end

data/lib/mixin_bot/utils/address.rb

@@ -52,7 +52,7 @@ module MixinBot
       #
       def hash_members(ids)
         list = Array(ids).flatten.compact.map(&:to_s).sort
-        SHA3::Digest::SHA256.hexdigest(list.join)
+        SHA3::Digest::SHA3_256.hexdigest(list.join)
       end
     end
   end

data/lib/mixin_bot/version.rb

@@ -11,5 +11,5 @@ module MixinBot
   #
   # @see https://semver.org/
   #
-  VERSION = '2.2.2'
+  VERSION = '2.4.0'
 end

data/lib/mvm/registry.rb

@@ -53,9 +53,9 @@ module MVM
 
     def contract_from_multisig(user_ids, threshold)
       bytes = []
-      bytes += MixinBot.utils.encode_uint16(user_ids.length)
-      bytes += [user_ids.sort.join.gsub('-', '')].pack('H*').bytes
-      bytes += MixinBot.utils.encode_uint16(threshold)
+      bytes.concat(MixinBot.utils.encode_uint16(user_ids.length))
+      bytes.concat([user_ids.sort.join.gsub('-', '')].pack('H*').bytes)
+      bytes.concat(MixinBot.utils.encode_uint16(threshold))
 
       hash = Eth::Util.bin_to_prefixed_hex(Eth::Util.keccak256(bytes.pack('C*')))
       @rpc.call @registry, 'contracts', hash.to_i(16)

data/llms.txt

@@ -1,6 +1,6 @@
 # MixinBot
 
-> Ruby SDK and CLI for Mixin Network: Safe UTXO transfers, REST API, Blaze messaging, transaction crypto, optional MVM helpers. Ruby >= 3.2. Gem version 2.2.1.
+> Ruby SDK and CLI for Mixin Network: Safe UTXO transfers, REST API, Blaze messaging, transaction crypto, optional MVM helpers. Ruby >= 3.2. Gem version 2.3.0.
 
 Important notes:
 

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: mixin_bot
 version: !ruby/object:Gem::Version
-  version: 2.2.2
+  version: 2.4.0
 platform: ruby
 authors:
 - an-lee
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-05-24 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -232,14 +231,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '2.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '2.2'
 - !ruby/object:Gem::Dependency
   name: thor
   requirement: !ruby/object:Gem::Requirement
@@ -375,7 +374,6 @@ licenses:
 - MIT
 metadata:
   rubygems_mfa_required: 'true'
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -390,8 +388,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.22
-signing_key:
+rubygems_version: 4.0.16
 specification_version: 4
 summary: A Ruby SDK for Mixin Network
 test_files: []