mixin_bot 1.4.0 → 2.0.0

data/examples/blaze.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require './lib/mixin_bot'
+require 'base64'
+require 'yaml'
+
+CONFIG = YAML.load_file("#{File.dirname __FILE__}/config.yml")
+MixinBot.configure do
+  self.app_id = CONFIG['app_id']
+  self.client_secret = CONFIG['client_secret']
+  self.session_id = CONFIG['session_id']
+  self.server_public_key = CONFIG['server_public_key']
+  self.session_private_key = CONFIG['session_private_key']
+end
+
+# default connect
+# EM.run {
+#   MixinBot.api.start_blaze_connect
+# }
+
+EM.run do
+  MixinBot.api.start_blaze_connect do
+    def on_open(blaze, _event)
+      p [Time.now.to_s, :on_open]
+      blaze.send list_pending_message
+    end
+
+    def on_message(blaze, event)
+      raw = JSON.parse ws_message(event.data)
+      p [Time.now.to_s, :on_message, raw&.[]('action')]
+
+      blaze.send acknowledge_message_receipt(raw['data']['message_id']) unless raw&.[]('data')&.[]('message_id').nil?
+    end
+
+    # def on_error(blaze, event)
+    #   p [Time.now.to_s, :on_error]
+    # end
+
+    # def on_close(blaze, event)
+    #   p [Time.now.to_s, :on_close, event.code, event.reason]
+    # end
+  end
+end

data/examples/config.yml.example

@@ -0,0 +1,21 @@
+app_id: 0508a116-1239-4e28-b150-85a8e3e6b400
+client_secret: d9dc58107bacde6713c12734663de6bbb2b83e917d5fe62167bda13ca6665b15
+session_id: 25696f85-b7b4-4509-8c3f-2684a8fc4a2a
+pin_code: "431005"
+server_public_key: b0pjBUKI0Vp9K+NspaLCKKeV1IzuO5o2Zgzp2uriXYn6bKcKowhZ7nsjNT1mxtq82dsPzGficOM9H9n1HvNyilrKrpW5ndu7/dMsw/r3JvbexDvLZfAGmuAHcZOy+AwbMSJ/XurLJg1lS9w9PVkDltqWWy2TOunUlbe1lWYy/1M=
+session_private_key: |
+  -----BEGIN RSA PRIVATE KEY-----
+  MIICXAIBAAKBgQDQYjiR/Te6Bh/1bk8gWRbQkrX0AIGPja1DLUQHu5Uw9M4P53O3
+  f4pDCGoN3R5+LYjODtquOwmEjcMhbhp6XarrnJVXH8WGmJcpjVwGtwIjPTeRMu4Z
+  8XWo314fO2pLeiqWbJ4knlGb0oiXxBghwF4KglUSElQ/FXjdKaabHCw0zQIDAQAB
+  AoGALgqFlTvtZByWUxPcR7lnYQ4JRbAW8DDNZ1pI/axkejyciscIujJjygvB4u5I
+  HnjRETYW+wfwQmlQA8Lf9slbSe1FlsajNWl/zc+bwoYTO3yfB81GWwk/e20dTGfs
+  2d8ITe+LlYUMlqZgBGr2Y2pHeXDvuzC6ZsKZQKoS3B2RscECQQD0RTXp0tNSbWE7
+  TzhXwZu3jkIRhZsajeDv+7VYMZ94TO1PGeQSi25jBT8JcDfbyXO8eZTtjARfTEmE
+  Ln6ejveHAkEA2mPb+TyZl0FqIluwo1KbCv3PVlaHDL+HyHoBsq+6yhn3VRMDbyqs
+  ZKViJxaLrzUx6+IQOr9T8LqFcaQhSrxeCwJANqMgewuoLwC+RejjXmW08erFBmxP
+  FDJ2BNfVaUO4Os1iK1ZMOIWtjEKJJhBOvj+iPp8nW7b852AF9aX8tnSeEwJAacH8
+  D7l6A5aJCDRw2NazAGKjGoNyiQjjf4Ed+2NASIjEjq1Td20p6N9yJc20PVe8Yieq
+  hliLFMOuxbae7KtFuwJBAI9xMuLBLWixwvezyFCAJpj93ClOgSIlM7qgEfUxLvjZ
+  YxyVoIU3haXJPYPgaVE9nEwwiNPRS5DJ2fCGT+oGfrY=
+  -----END RSA PRIVATE KEY-----

data/lib/mixin_bot/address.rb

@@ -10,6 +10,14 @@ module MixinBot
   class MixAddress
     attr_accessor :version, :uuid_members, :xin_members, :threshold, :address, :payload
 
+    def self.parse(string)
+      new(address: string)
+    end
+
+    def self.from_members(members:, threshold:)
+      new(members:, threshold:)
+    end
+
     def initialize(**args)
       args = args.with_indifferent_access
 
@@ -23,8 +31,9 @@ module MixinBot
         @version = args[:version] || MIX_ADDRESS_VERSION
 
         if args[:members].present?
-          @uuid_members = args[:members].reject { |member| member.start_with?(MAIN_ADDRESS_PREFIX) }
-          @xin_members = args[:members].select { |member| member.start_with? MAIN_ADDRESS_PREFIX }
+          @xin_members, @uuid_members = args[:members].partition do |member|
+            member.start_with?(MAIN_ADDRESS_PREFIX)
+          end
         else
           @uuid_members = args[:uuid_members] || []
           @xin_members = args[:xin_members] || []
@@ -53,11 +62,42 @@ module MixinBot
       }
     end
 
+    def request_or_generate_ghost_keys(output_index = 0, api: MixinBot.api)
+      if xin_members.present?
+        key = JOSE::JWA::Ed25519.keypair
+        gk = { 'mask' => key[0].unpack1('H*'), 'keys' => [] }
+        xin_members.each do |member|
+          payload = MixinBot.utils.parse_main_address(member)
+          spend_key = payload[0...32]
+          view_key = payload[-32..]
+          ghost = MixinBot.utils.derive_ghost_public_key(key[1], view_key, spend_key, output_index)
+          gk['keys'] << ghost.unpack1('H*')
+        end
+        gk
+      else
+        hint = SecureRandom.uuid
+        api.create_safe_keys(
+          { receivers: (uuid_members + xin_members).sort, index: output_index, hint: }
+        )['data'].first
+      end
+    end
+
     def encode
       raise ArgumentError, 'members should be an array' unless uuid_members.is_a?(Array) || xin_members.is_a?(Array)
       raise ArgumentError, 'members should not be empty' if uuid_members.empty? && xin_members.empty?
       raise ArgumentError, 'members length should less than 256' if uuid_members.length + xin_members.length > 255
-      raise ArgumentError, "invalid threshold: #{threshold}" if threshold > (uuid_members.length + xin_members.length)
+
+      member_count = uuid_members.length + xin_members.length
+      # UUID mix (Go NewUUIDMixAddress): threshold must be in 1..len(members).
+      # XIN-only mix (Go NewMainnetMixAddress): threshold may exceed member count (sparse), e.g. storage 1-of-64 style.
+      if uuid_members.present? && xin_members.empty?
+        raise ArgumentError, "invalid threshold: #{threshold}" unless threshold.positive? && threshold <= member_count
+      elsif xin_members.present? && uuid_members.empty?
+        raise ArgumentError, "invalid threshold: #{threshold}" unless threshold.positive?
+        raise ArgumentError, 'too many XIN members' if member_count > 64
+      elsif threshold > member_count
+        raise ArgumentError, "invalid threshold: #{threshold}"
+      end
 
       prefix =
         [version].pack('C*') +

data/lib/mixin_bot/api/app.rb

@@ -20,6 +20,13 @@ module MixinBot
 
         client.get path, access_token:
       end
+
+      def transfer_app_ownership(receiver_user_id:, pin:, access_token: nil)
+        path = format('/apps/%<app_id>s/transfer', app_id: config.app_id)
+        tip = tip_or_legacy_pin_payload(pin, 'TIP:APP:OWNERSHIP:TRANSFER:', receiver_user_id)
+        client.post path, user_id: receiver_user_id, pin_base64: tip[:pin_base64] || tip[:pin], access_token:
+      end
+      alias migrate transfer_app_ownership
     end
   end
 end

data/lib/mixin_bot/api/asset.rb

@@ -2,20 +2,101 @@
 
 module MixinBot
   class API
+    ##
+    # API methods for asset management.
+    #
+    # Provides methods to:
+    # - List all assets in bot's wallet
+    # - Read specific asset information
+    # - Get asset ticker/price data
+    #
     module Asset
-      # https://developers.mixin.one/api/alpha-mixin-network/read-assets/
+      ##
+      # Retrieves all assets in the bot's wallet.
+      #
+      # Returns an array of asset objects, each containing:
+      # - asset_id: the asset UUID
+      # - symbol: the asset symbol (e.g., "BTC", "ETH")
+      # - name: the full asset name
+      # - icon_url: URL to the asset icon
+      # - balance: current balance
+      # - destination: deposit address
+      # - tag: deposit memo/tag (if applicable)
+      # - price_btc: price in BTC
+      # - price_usd: price in USD
+      # - chain_id: the blockchain UUID
+      # - change_btc: 24h price change in BTC
+      # - change_usd: 24h price change in USD
+      # - confirmations: required confirmations
+      # - asset_key: the asset key for deposit
+      #
+      # @param access_token [String, nil] optional access token
+      # @return [Array<Hash>] array of asset objects
+      #
+      # @example
+      #   assets = api.assets
+      #   assets.each do |asset|
+      #     puts "#{asset['symbol']}: #{asset['balance']}"
+      #   end
+      #
+      # @see https://developers.mixin.one/docs/api/assets/assets
+      #
       def assets(access_token: nil)
         path = '/assets'
         client.get path, access_token:
       end
 
-      # https://developers.mixin.one/api/alpha-mixin-network/read-asset/
+      ##
+      # Retrieves information for a specific asset.
+      #
+      # Returns detailed information about a single asset including:
+      # - Current balance
+      # - Price information
+      # - Deposit address
+      # - Network details
+      #
+      # @param asset_id [String] the asset UUID
+      # @param access_token [String, nil] optional access token
+      # @return [Hash] the asset information
+      #
+      # @example
+      #   # Get Bitcoin information
+      #   btc = api.asset('c6d0c728-2624-429b-8e0d-d9d19b6592fa')
+      #   puts "BTC Balance: #{btc['balance']}"
+      #   puts "BTC Price: $#{btc['price_usd']}"
+      #
+      # @see https://developers.mixin.one/docs/api/assets/asset
+      #
       def asset(asset_id, access_token: nil)
         path = format('/assets/%<asset_id>s', asset_id:)
         client.get path, access_token:
       end
 
-      # https://developers.mixin.one/document/wallet/api/ticker
+      ##
+      # Retrieves ticker/price data for an asset.
+      #
+      # Returns historical price and volume data for an asset,
+      # useful for charts and price tracking.
+      #
+      # @param asset_id [String] the asset UUID
+      # @param kwargs [Hash] query options
+      # @option kwargs [String, DateTime, Time] :offset the time offset for historical data
+      # @option kwargs [String] :access_token optional access token
+      # @return [Hash] ticker data including price and volume
+      #
+      # @example
+      #   # Get current ticker
+      #   ticker = api.ticker('c6d0c728-2624-429b-8e0d-d9d19b6592fa')
+      #   puts "Price: $#{ticker['price_usd']}"
+      #
+      #   # Get historical ticker
+      #   ticker = api.ticker(
+      #     'c6d0c728-2624-429b-8e0d-d9d19b6592fa',
+      #     offset: 1.day.ago
+      #   )
+      #
+      # @see https://developers.mixin.one/docs/api/assets/ticker
+      #
       def ticker(asset_id, **kwargs)
         offset = kwargs[:offset]
         offset = DateTime.rfc3339(offset) if offset.is_a? String
@@ -24,6 +105,36 @@ module MixinBot
         path = '/ticker'
         client.get path, asset_id:, offset:, access_token: kwargs[:access_token]
       end
+
+      def fetch_assets(asset_ids, access_token: nil)
+        client.fetch_post_array '/safe/assets/fetch', Array(asset_ids), access_token:
+      end
+
+      def asset_fee(asset_id, destination:, access_token: nil)
+        path = format('/safe/assets/%<asset_id>s/fees', asset_id:)
+        client.get path, destination:, access_token:
+      end
+      alias read_asset_fee asset_fee
+
+      def asset_balance(asset_id)
+        outputs = safe_outputs(asset: asset_id, state: 'unspent')
+        Array(outputs['data']).sum { |o| o['amount'].to_d }
+      end
+      alias asset_balance_with_safe_user asset_balance
+
+      def user_asset_balance(user_id, asset_id, access_token: nil)
+        members_hash = MixinBot.utils.hash_members([user_id])
+        path = '/safe/outputs'
+        response = client.get(
+          path,
+          members: members_hash,
+          threshold: 1,
+          asset: asset_id,
+          state: 'unspent',
+          access_token:
+        )
+        Array(response['data']).sum { |o| o['amount'].to_d }
+      end
     end
   end
 end

data/lib/mixin_bot/api/auth.rb

@@ -3,8 +3,22 @@
 module MixinBot
   class API
     module Auth
+      def sign_oauth_access_token(_authorization_id:, method:, uri:, body:, scope:, request_id: nil, **kwargs)
+        MixinBot.utils.access_token(
+          method,
+          uri,
+          body,
+          exp_in: kwargs[:exp_in] || 600,
+          scp: scope,
+          app_id: kwargs[:app_id] || config.app_id,
+          session_id: kwargs[:session_id] || config.session_id,
+          private_key: kwargs[:private_key] || config.session_private_key,
+          request_id:
+        )
+      end
+
       def oauth_token(code)
-        path = 'oauth/token'
+        path = '/oauth/token'
         payload = {
           client_id: config.app_id,
           client_secret: config.client_secret,
@@ -30,20 +44,15 @@ module MixinBot
 
         path = '/oauth/authorize'
         pin = kwargs[:pin] || config.pin
+        raise ArgumentError, 'pin is required' if pin.blank?
+
+        tip = tip_or_legacy_pin_payload(pin, 'TIP:OAUTH:APPROVE:', data['scopes'], data['authorization_id'])
         payload = {
           authorization_id: data['authorization_id'],
           scopes: data['scopes'],
-          pin_base64: encrypt_pin(kwargs[:pin])
+          pin_base64: tip[:pin_base64] || tip[:pin]
         }
 
-        raise ArgumentError, 'pin is required' if pin.blank?
-
-        payload[:pin_base64] = if pin.size > 6
-                                 encrypt_tip_pin(pin, 'TIP:OAUTH:APPROVE:', data['scopes'], data['authorization_id'])
-                               else
-                                 encrypt_pin(pin)
-                               end
-
         client.post path, **payload, access_token: kwargs[:access_token]
       end
 

data/lib/mixin_bot/api/blaze.rb

@@ -58,6 +58,87 @@ module MixinBot
           start_blaze_connect(&_block) if reconnect
         end
       end
+
+      def blaze_send_plain_text(socket, conversation_id:, recipient_id:, content:)
+        socket.send write_ws_message(
+          params: {
+            conversation_id:,
+            recipient_id:,
+            message_id: SecureRandom.uuid,
+            category: 'PLAIN_TEXT',
+            data_base64: Base64.urlsafe_encode64(content.to_s, padding: false)
+          }
+        )
+      end
+
+      def blaze_send_recall_message(socket, conversation_id:, recipient_id:, message_id:)
+        data = { message_id: }.to_json
+        socket.send write_ws_message(
+          params: {
+            conversation_id:,
+            recipient_id:,
+            message_id: SecureRandom.uuid,
+            category: 'MESSAGE_RECALL',
+            data_base64: Base64.urlsafe_encode64(data, padding: false)
+          }
+        )
+      end
+
+      def blaze_send_post(socket, conversation_id:, recipient_id:, content:)
+        blaze_send_plain_text(socket, conversation_id:, recipient_id:, content:)
+      end
+
+      def blaze_send_contact(socket, conversation_id:, recipient_id:, contact_id:)
+        data = { user_id: contact_id }.to_json
+        socket.send write_ws_message(
+          params: {
+            conversation_id:,
+            recipient_id:,
+            message_id: SecureRandom.uuid,
+            category: 'PLAIN_CONTACT',
+            data_base64: Base64.urlsafe_encode64(data, padding: false)
+          }
+        )
+      end
+
+      def blaze_send_app_card(socket, conversation_id:, recipient_id:, title:, description:, action:, icon_url:)
+        data = { title:, description:, action:, icon_url: }.to_json
+        socket.send write_ws_message(
+          params: {
+            conversation_id:,
+            recipient_id:,
+            message_id: SecureRandom.uuid,
+            category: 'APP_CARD',
+            data_base64: Base64.urlsafe_encode64(data, padding: false)
+          }
+        )
+      end
+
+      def blaze_send_app_button(socket, conversation_id:, recipient_id:, label:, action:, color:)
+        data = [{ label:, action:, color: }].to_json
+        socket.send write_ws_message(
+          params: {
+            conversation_id:,
+            recipient_id:,
+            message_id: SecureRandom.uuid,
+            category: 'APP_BUTTON_GROUP',
+            data_base64: Base64.urlsafe_encode64(data, padding: false)
+          }
+        )
+      end
+
+      def blaze_send_group_app_button(socket, conversation_id:, recipient_id:, buttons:)
+        data = buttons.to_json
+        socket.send write_ws_message(
+          params: {
+            conversation_id:,
+            recipient_id:,
+            message_id: SecureRandom.uuid,
+            category: 'APP_BUTTON_GROUP',
+            data_base64: Base64.urlsafe_encode64(data, padding: false)
+          }
+        )
+      end
     end
   end
 end

data/lib/mixin_bot/api/chain.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module MixinBot
+  class API
+    module Chain
+      CHAIN_NAMES = {
+        '59c09123-95cc-3ffd-a659-0f9169074cee' => 'Lightning',
+        'c6d0c728-2624-429b-8e0d-d9d19b6592fa' => 'Bitcoin',
+        'fd11b6e3-0b87-41f1-a41f-f0e9b49e5bf0' => 'Bitcoin Cash',
+        '574388fd-b93f-4034-a682-01c2bc095d17' => 'Bitcoin SV',
+        '76c802a2-7c88-447f-a93e-c29c9e5dd9c8' => 'Litecoin',
+        '43d61dcd-e413-450d-80b8-101d5e903357' => 'Ethereum',
+        '2204c1ee-0ea2-4add-bb9a-b3719cfff93a' => 'Ethereum Classic',
+        '1949e683-6a08-49e2-b087-d6b72398588f' => 'BNB Smart Chain',
+        'b7938396-3f94-4e0a-9179-d3440718156f' => 'Polygon',
+        '3fb612c5-6844-3979-ae4a-5a84e79da870' => 'Base',
+        '60360611-370c-3b69-9826-b13db93f6aba' => 'OP Mainnet',
+        '8c590110-1abc-3697-84f2-05214e6516aa' => 'Arbitrum One',
+        'a0ffd769-5850-4b48-9651-d2ae44a3e64d' => 'Mixin Virtual Machine',
+        '8f5caf2a-283d-4c85-832a-91e83bbf290b' => 'Decred',
+        '23dfb5a5-5d7b-48b6-905f-3970e3176e27' => 'Ripple',
+        '990c4c29-57e9-48f6-9819-7d986ea44985' => 'Siacoin',
+        '6cfe566e-4aad-470b-8c9a-2fd35b49c68d' => 'EOS',
+        '6770a1e5-6086-44d5-b60f-545f9d9e8ffd' => 'Dogecoin',
+        '6472e7e3-75fd-48b6-b1dc-28d294ee1476' => 'Dash',
+        'c996abc9-d94e-4494-b1cf-2a3fd3ac5714' => 'Zcash',
+        '27921032-f73e-434e-955f-43d55672ee31' => 'NEM',
+        '882eb041-64ea-465f-a4da-817bd3020f52' => 'Arweave',
+        'a2c5d22b-62a2-4c13-b3f0-013290dbac60' => 'Horizen',
+        '25dabac5-056a-48ff-b9f9-f67395dc407c' => 'TRON',
+        '56e63c06-b506-4ec5-885a-4a5ac17b83c1' => 'Stellar',
+        'b207bce9-c248-4b8e-b6e3-e357146f3f4c' => 'MassGrid',
+        '443e1ef5-bc9b-47d3-be77-07f328876c50' => 'Bytom',
+        '71a0e8b5-a289-4845-b661-2b70ff9968aa' => 'Bytom',
+        '7397e9f1-4e42-4dc8-8a3b-171daaadd436' => 'Cosmos',
+        '9c612618-ca59-4583-af34-be9482f5002d' => 'Akash',
+        '17f78d7c-ed96-40ff-980c-5dc62fecbc85' => 'BNB Beacon Chain',
+        '05c5ac01-31f9-4a69-aa8a-ab796de1d041' => 'Monero',
+        'c99a3779-93df-404d-945d-eddc440aa0b2' => 'Starcoin',
+        '05891083-63d2-4f3d-bfbe-d14d7fb9b25a' => 'Bitshares',
+        '6877d485-6b64-4225-8d7e-7333393cb243' => 'Ravencoin',
+        '1351e6bd-66cf-40c1-8105-8a8fe518a222' => 'Grin',
+        'c3b9153a-7fab-4138-a3a4-99849cadc073' => 'VCash',
+        '13036886-6b83-4ced-8d44-9f69151587bf' => 'Handshake',
+        'd243386e-6d84-42e6-be03-175be17bf275' => 'Nervos',
+        '5649ca42-eb5f-4c0e-ae28-d9a4e77eded3' => 'Tezos',
+        'f8b77dc0-46fd-4ea1-9821-587342475869' => 'Namecoin',
+        '64692c23-8971-4cf4-84a7-4dd1271dd887' => 'Solana',
+        'd6ac94f7-c932-4e11-97dd-617867f0669e' => 'NEAR',
+        '08285081-e1d8-4be6-9edc-e203afa932da' => 'Filecoin',
+        'eea900a8-b327-488c-8d8d-1428702fe240' => 'MobileCoin',
+        '54c61a72-b982-4034-a556-0d99e3c21e39' => 'Polkadot',
+        '9d29e4f6-d67c-4c4b-9525-604b04afbe9f' => 'Kusama',
+        '706b6f84-3333-4e55-8e89-275e71ce9803' => 'Algorand',
+        'cbc77539-0a20-4666-8c8a-4ded62b36f0a' => 'Avalanche X-Chain',
+        '1f67ac58-87ba-3571-9781-e9413c046f34' => 'Avalanche C-Chain',
+        '163a2142-398d-3483-aee3-d47db8da4d10' => 'MarsChain',
+        'b12bb04a-1cea-401c-a086-0be61f544889' => 'XDC Network',
+        'd2c1c7e1-a1a9-4f88-b282-d93b0a08b42b' => 'Aptos',
+        '2bd97283-2582-33a8-bcba-f4b8ed189572' => 'Sui',
+        'ef660437-d915-4e27-ad3f-632bfb6ba0ee' => 'TON'
+      }.freeze
+
+      XIN_ASSET_ID = 'c94ac88f-4671-3976-b60a-09064f1811e8'
+      VAULTA_ASSET_ID = 'ac2b79f3-ec9c-3d87-b4ca-3e825228dda5'
+
+      def network_chain(chain_id)
+        path = format('/network/chains/%<chain_id>s', chain_id:)
+        client.get path, access_token: ''
+      end
+      alias read_network_chain_by_id network_chain
+
+      def network_chains
+        client.get '/network/chains', access_token: ''
+      end
+      alias read_network_chains network_chains
+
+      def chain_name(chain_id)
+        CHAIN_NAMES[chain_id] || 'Not Supported Chain'
+      end
+      alias get_chain_name chain_name
+
+      def chain_id?(chain_id)
+        CHAIN_NAMES.key?(chain_id)
+      end
+      alias is_chain_id chain_id?
+
+      def full_chains
+        CHAIN_NAMES.transform_values { true }.dup
+      end
+      alias get_full_chains full_chains
+    end
+  end
+end

data/lib/mixin_bot/api/code.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module MixinBot
+  class API
+    module Code
+      def read_code(code_id, access_token: nil)
+        path = format('/codes/%<code_id>s', code_id:)
+        client.get path, access_token: access_token || ''
+      end
+
+      def read_multisig_by_code(code_id, access_token: nil)
+        read_code(code_id, access_token:)
+      end
+    end
+  end
+end

data/lib/mixin_bot/api/computer_api.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module MixinBot
+  class API
+    # Delegates to {MixinBot::Computer} for API surface parity with Go SDK.
+    module ComputerApi
+      def get_computer_info
+        MixinBot::Computer.info
+      end
+
+      def get_computer_user(addr)
+        MixinBot::Computer.user(addr)
+      end
+
+      def get_computer_deployed_assets
+        MixinBot::Computer.deployed_assets
+      end
+
+      def get_computer_system_call(id)
+        MixinBot::Computer.system_call(id)
+      end
+
+      def computer_deploy_external_asset(assets)
+        MixinBot::Computer.deploy_external_assets(assets)
+      end
+
+      def lock_computer_nonce_account(mix)
+        MixinBot::Computer.lock_nonce_account(mix)
+      end
+
+      def get_fee_on_xin_based_on_sol(sol_amount)
+        MixinBot::Computer.fee_on_xin_from_sol(sol_amount)
+      end
+
+      def register_computer
+        MixinBot::Computer.register_computer(self)
+      end
+
+      def computer_user_id_to_bytes(id)
+        MixinBot::Computer.user_id_to_bytes(id)
+      end
+
+      def build_system_call_extra(uid, cid, skip_process: false, fid: nil)
+        MixinBot::Computer.build_system_call_extra(uid, cid, skip_process:, fid:)
+      end
+
+      def encode_operation_memo(operation, extra = +'')
+        MixinBot::Computer.encode_operation_memo(operation, extra)
+      end
+
+      def encode_mtg_extra(app_id, extra)
+        MixinBot::Computer.encode_mtg_extra(app_id, extra)
+      end
+
+      def decode_computer_extra_base64(extra)
+        MixinBot::Computer.decode_computer_extra_base64(extra)
+      end
+    end
+  end
+end

data/lib/mixin_bot/api/conversation.rb

@@ -29,7 +29,8 @@ module MixinBot
 
       def create_group_conversation(user_ids:, name:, **kwargs)
         random_id = kwargs[:random_id] || SecureRandom.uuid
-        conversation_id = kwargs[:conversation_id] || MixinBot.utils.generate_group_conversation_id(user_ids:, name:, owner_id: config.app_id, random_id:)
+        conversation_id = kwargs[:conversation_id] || MixinBot.utils.generate_group_conversation_id(user_ids:, name:,
+                                                                                                    owner_id: config.app_id, random_id:)
         create_conversation(
           announcement: kwargs[:announcement],
           category: 'GROUP',
@@ -94,6 +95,11 @@ module MixinBot
         client.post path, access_token:
       end
 
+      def join_conversation(conversation_id, access_token: nil)
+        path = format('/conversations/%<conversation_id>s/join', conversation_id:)
+        client.post path, access_token:
+      end
+
       def rotate_conversation(conversation_id, access_token: nil)
         path = format('/conversations/%<id>s/rotate', id: conversation_id)
 

data/lib/mixin_bot/api/deposit.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module MixinBot
+  class API
+    module Deposit
+      def pending_safe_deposits
+        client.get '/safe/deposits', access_token: ''
+      end
+      alias fetch_pending_safe_deposits pending_safe_deposits
+    end
+  end
+end

data/lib/mixin_bot/api/encrypted_message.rb

@@ -194,7 +194,7 @@ module MixinBot
         decrypter.key = key
         decrypter.iv = bytes[prefix_size...(prefix_size + 12)].pack('C*')
         decrypter.auth_tag = bytes.last(16).pack('C*')
-        decrypted = decrypter.update(bytes[(prefix_size + 12)...(bytes.size - 16)].pack('C*'))
+        decrypted = decrypter.update(bytes[(prefix_size + 12)...-16].pack('C*'))
         decrypter.final
 
         Base64.urlsafe_encode64 decrypted

data/lib/mixin_bot/api/fiat.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module MixinBot
+  class API
+    module Fiat
+      def fiats(access_token: nil)
+        client.get '/external/fiats', access_token: access_token || ''
+      end
+      alias get_fiats fiats
+    end
+  end
+end

data/lib/mixin_bot/api/inscription.rb

@@ -21,8 +21,8 @@ module MixinBot
         client.get path, offset:
       end
 
-      def collectibles(members: [], access_token: nil)
-        unspent_outputs = safe_outputs(state: :unspent, members:, access_token:)['data']
+      def collectibles(members: [], access_token: nil, state: :unspent)
+        unspent_outputs = safe_outputs(state:, members:, access_token:)['data']
         unspent_outputs.select { |output| output['inscription_hash'].present? }
       end