quorum_sdk 0.1.0 → 0.3.0

data/lib/quorum_sdk/chain/management.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module QuorumSdk
+  class Chain
+    # Wrapper for HTTP APIs for chain
+    module Management
+      def allow_list(group_id: nil)
+        group_id ||= @group_id
+        raise ArgumentError, 'group_id must be provided' if group_id.blank?
+
+        path = "api/v1/group/#{group_id}/trx/allowlist"
+        client.get(path).body
+      end
+
+      def deny_list(group_id: nil)
+        group_id ||= @group_id
+        raise ArgumentError, 'group_id must be provided' if group_id.blank?
+
+        path = "api/v1/group/#{group_id}/trx/denylist"
+        client.get(path).body
+      end
+
+      def auth_type(trx_type, group_id: nil)
+        group_id ||= @group_id
+        raise ArgumentError, 'group_id must be provided' if group_id.blank?
+
+        path = "api/v1/group/#{group_id}/trx/auth/#{trx_type}"
+        client.get(path).body
+      end
+
+      ARGUMENTS_FOR_UPDATE_CHAIN_CONFIG = %i[config type].freeze
+      def update_chain_config(**kwargs)
+        raise ArgumentError, "Keyword arguments #{ARGUMENTS_FOR_UPDATE_CHAIN_CONFIG} must be provided" unless ARGUMENTS_FOR_UPDATE_CHAIN_CONFIG.all?(&->(arg) { arg.in? kwargs.keys })
+
+        type = kwargs[:type]
+        raise ArgumentError, 'type must be one of set_trx_auth_mode/upd_alw_list/upd_dny_list' unless type.in? %w[set_trx_auth_mode upd_alw_list upd_dny_list]
+
+        config = kwargs[:config]
+        config = config.to_json if config.is_a?(Hash)
+
+        group_id = kwargs[:group_id] || @group_id
+        raise ArgumentError, 'group_id must be provided' if group_id.blank?
+
+        path = 'api/v1/group/chainconfig'
+        payload = {
+          type:,
+          config:,
+          group_id:,
+          memo: kwargs[:memo]
+        }.compact
+        client.post(path, **payload).body
+      end
+
+      ARGUMENTS_FOR_UPDATE_AUTH_MODE = %i[trx_auth_mode].freeze
+      def update_trx_auth_mode(**kwargs)
+        raise ArgumentError, "Keyword arguments #{ARGUMENTS_FOR_UPDATE_AUTH_MODE} must be provided" unless ARGUMENTS_FOR_UPDATE_AUTH_MODE.all?(&->(arg) { arg.in? kwargs.keys })
+
+        trx_type = kwargs[:trx_type] || 'POST'
+        raise ArgumentError, 'trx_type must be one of POST/ANNOUNCE/REQ_BLOCK_FORWARD/REQ_BLOCK_FORWARD' unless trx_type.in? %w[POST ANNOUNCE REQ_BLOCK_RESP REQ_BLOCK_BACKWARD]
+
+        trx_auth_mode = kwargs[:trx_auth_mode]
+        raise ArgumentError, 'trx_auth_mode must be one of follow_alw_list/follow_dny_list' unless trx_auth_mode.in? %w[follow_alw_list follow_dny_list]
+
+        group_id = kwargs[:group_id] || @group_id
+        raise ArgumentError, 'group_id must be provided' if group_id.blank?
+
+        update_chain_config(
+          group_id:,
+          type: 'set_trx_auth_mode',
+          config: {
+            trx_type:,
+            trx_auth_mode:
+          },
+          memo: kwargs[:memo]
+        )
+      end
+
+      ARGUMENTS_FOR_UPDATE_ALLOW_LIST = %i[action pubkey].freeze
+      def update_allow_list(**kwargs)
+        raise ArgumentError, "Keyword arguments #{ARGUMENTS_FOR_UPDATE_ALLOW_LIST} must be provided" unless ARGUMENTS_FOR_UPDATE_ALLOW_LIST.all?(&->(arg) { arg.in? kwargs.keys })
+
+        trx_type = kwargs[:trx_type] || ['POST']
+        trx_type = [trx_type] if trx_type.is_a?(String)
+        raise ArgumentError, 'trx type must be one of POST/ANNOUNCE/REQ_BLOCK_FORWARD/REQ_BLOCK_FORWARD' unless trx_type.all?(&->(op) { op.in? %w[POST ANNOUNCE REQ_BLOCK_RESP REQ_BLOCK_BACKWARD] })
+
+        action = kwargs[:action]
+        raise ArgumentError, 'trx_auth_mode must be one of add/remove' unless action.in? %w[add remove]
+
+        pubkey = kwargs[:pubkey]
+        if Eth::Util.hex?(pubkey)
+          pubkey = Secp256k1::PublicKey.from_data([pubkey].pack('H*')).compressed
+          pubkey = Base64.urlsafe_encode64(pubkey)
+        end
+
+        group_id = kwargs[:group_id] || @group_id
+        raise ArgumentError, 'group_id must be provided' if group_id.blank?
+
+        update_chain_config(
+          group_id:,
+          type: 'upd_alw_list',
+          config: {
+            trx_type:,
+            action:,
+            pubkey:
+          },
+          memo: kwargs[:memo]
+        )
+      end
+
+      ARGUMENTS_FOR_UPDATE_DENY_LIST = %i[action pubkey].freeze
+      def update_deny_list(**kwargs)
+        raise ArgumentError, "Keyword arguments #{ARGUMENTS_FOR_UPDATE_DENY_LIST} must be provided" unless ARGUMENTS_FOR_UPDATE_DENY_LIST.all?(&->(arg) { arg.in? kwargs.keys })
+
+        trx_type = kwargs[:trx_type] || ['POST']
+        trx_type = [trx_type] if trx_type.is_a?(String)
+        raise ArgumentError, 'trx type must be one of POST/ANNOUNCE/REQ_BLOCK_FORWARD/REQ_BLOCK_FORWARD' unless trx_type.all?(&->(op) { op.in? %w[POST ANNOUNCE REQ_BLOCK_RESP REQ_BLOCK_BACKWARD] })
+
+        action = kwargs[:action]
+        raise ArgumentError, 'trx_auth_mode must be one of add/remove' unless action.in? %w[add remove]
+
+        pubkey = kwargs[:pubkey]
+        if Eth::Util.hex?(pubkey)
+          pubkey = Secp256k1::PublicKey.from_data([pubkey].pack('H*')).compressed
+          pubkey = Base64.urlsafe_encode64(pubkey)
+        end
+
+        group_id = kwargs[:group_id] || @group_id
+        raise ArgumentError, 'group_id must be provided' if group_id.blank?
+
+        update_chain_config(
+          group_id:,
+          type: 'upd_dny_list',
+          config: {
+            trx_type:,
+            action:,
+            pubkey:
+          },
+          memo: kwargs[:memo]
+        )
+      end
+    end
+  end
+end

data/lib/quorum_sdk/chain/node.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module QuorumSdk
+  class Chain
+    # Wrapper for HTTP APIs for chain
+    module Node
+      def network
+        path = 'api/v1/network'
+        client.get(path).body
+      end
+
+      def node
+        path = 'api/v1/node'
+        client.get(path).body
+      end
+    end
+  end
+end

data/lib/quorum_sdk/chain.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative 'chain/chain'
+require_relative 'chain/group'
+require_relative 'chain/management'
+require_relative 'chain/node'
+require_relative 'client'
+
+module QuorumSdk
+  # Wrapper for HTTP APIs as chain admin
+  class Chain
+    attr_reader :chain_url, :jwt, :client
+
+    def initialize(**kwargs)
+      @chain_url = kwargs[:chain_url]
+      @jwt = kwargs[:jwt]
+
+      @client = QuorumSdk::Client.new(@chain_url, @jwt)
+    end
+
+    include QuorumSdk::Chain::Chain
+    include QuorumSdk::Chain::Group
+    include QuorumSdk::Chain::Management
+    include QuorumSdk::Chain::Node
+  end
+end

data/lib/quorum_sdk/client.rb

@@ -1,19 +1,32 @@
 # frozen_string_literal: true
 
-require_relative 'api/light_node'
-
 module QuorumSdk
   # HTTP Client wrapper
   class Client
     attr_reader :domains
 
-    def initialize(domains)
-      @domains = domains || []
-      @conn = Faraday.new(url: @domains.first) do |f|
-        f.request :json
-        f.response :json
-        f.response :logger
-      end
+    def initialize(chain_url, jwt = nil)
+      chain_url =
+        case chain_url
+        when Array
+          chain_url.first
+        when String
+          chain_url
+        end
+
+      uri = Addressable::URI.parse chain_url
+      url = Addressable::URI.new(scheme: uri.scheme, host: uri.host, port: uri.port).to_s
+      jwt ||= uri.query_values['jwt']
+
+      @conn =
+        Faraday.new(
+          url:,
+          headers: { Authorization: "Bearer #{jwt}" }
+        ) do |f|
+          f.request :json
+          f.response :json
+          f.response :logger
+        end
     end
 
     def post(path, **body)
@@ -21,7 +34,7 @@ module QuorumSdk
     end
 
     def get(path, **params)
-      @conn.post path, **params
+      @conn.get path, **params
     end
   end
 end

data/lib/quorum_sdk/node/announce.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module QuorumSdk
+  class Node
+    # Announce module
+    module Announce
+      def announce(**kwargs)
+        group_id = kwargs[:group_id] || @group_id
+        raise ArgumentError, 'group_id must be provided' if group_id.blank?
+
+        payload = {
+          data: {
+            Action: kwargs[:action],
+            AnnouncerSignature: kwargs[:announce_signature],
+            EncryptPubkey: kwargs[:encrypt_pubkey],
+            GroupId: group_id,
+            Memo: kwargs[:memo],
+            OwnerPubkey: kwargs[:owner_pubkey],
+            OwnerSignature: kwargs[:owner_signature],
+            Result: kwargs[:result],
+            SignPubkey: kwargs[:sign_pubkey],
+            TimeStamp: kwargs[:timestamp],
+            Type: kwargs[:type]
+          }
+        }
+
+        path = "/api/v1/node/#{group_id}/announce"
+        client.post(path, **payload).body
+      end
+
+      def announced_producers(group_id: nil)
+        group_id ||= @group_id
+        raise ArgumentError, 'group_id must be provided' if group_id.blank?
+
+        path = "/api/v1/node/#{group_id}/announced/producer"
+        client.get(path).body
+      end
+
+      def announced_users(group_id: nil, pubkey: nil)
+        group_id ||= @group_id
+        raise ArgumentError, 'group_id must be provided' if group_id.blank?
+
+        params = {
+          pubkey:
+        }.compact
+
+        path = "/api/v1/node/#{group_id}/announced/user"
+        client.get(path, **params).body
+      end
+    end
+  end
+end

data/lib/quorum_sdk/node/app_config.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module QuorumSdk
+  class Node
+    # Appconfig module
+    module AppConfig
+      def app_config(key, group_id: nil)
+        group_id ||= @group_id
+        raise ArgumentError, 'group_id must be provided' if group_id.blank?
+        raise ArgumentError, 'key must be provided' if key.blank?
+
+        path = "api/v1/node/#{group_id}/appconfig/by/#{key}"
+        client.get(path).body
+      end
+
+      def app_config_keys(group_id: nil)
+        group_id ||= @group_id
+        raise ArgumentError, 'group_id must be provided' if group_id.blank?
+
+        path = "api/v1/node/#{group_id}/appconfig/keylist"
+        client.get(path).body
+      end
+    end
+  end
+end

data/lib/quorum_sdk/node/auth.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module QuorumSdk
+  class Node
+    # Auth module
+    module Auth
+      def allow_list(group_id: nil)
+        group_id ||= @group_id
+        raise ArgumentError, 'group_id must be provided' if group_id.blank?
+
+        path = "api/v1/node/#{group_id}/auth/alwlist"
+        client.get(path).body
+      end
+
+      def deny_list(group_id: nil)
+        group_id ||= @group_id
+        raise ArgumentError, 'group_id must be provided' if group_id.blank?
+
+        path = "api/v1/node/#{group_id}/auth/denylist"
+        client.get(path).body
+      end
+
+      def auth_type(group_id: nil, trx_type: 'POST')
+        group_id ||= @group_id
+        raise ArgumentError, 'group_id must be provided' if group_id.blank?
+
+        path = "api/v1/node/#{group_id}/auth/by/#{trx_type}"
+        client.get(path).body
+      end
+    end
+  end
+end

data/lib/quorum_sdk/node/group.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module QuorumSdk
+  class Node
+    # group module
+    module Group
+      def info(group_id: nil)
+        group_id ||= @group_id
+        raise ArgumentError, 'group_id must be provided' if group_id.blank?
+
+        path = "api/v1/node/#{group_id}/info"
+        client.get(path).body
+      end
+
+      def producers(group_id: nil)
+        group_id ||= @group_id
+        raise ArgumentError, 'group_id must be provided' if group_id.blank?
+
+        path = "api/v1/node/#{group_id}/producers"
+        client.get(path).body
+      end
+
+      def user_encrypt_pubkeys(group_id: nil)
+        group_id ||= @group_id
+        raise ArgumentError, 'group_id must be provided' if group_id.blank?
+
+        path = "api/v1/node/#{group_id}/userencryptpubkeys"
+        client.get(path).body
+      end
+    end
+  end
+end

data/lib/quorum_sdk/node/trx.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module QuorumSdk
+  class Node
+    # Wrapper for HTTP APIs as light node client
+    module Trx
+      ARGUMENTS_FOR_BUILD_TRX = %i[private_key data].freeze
+      def build_trx(**kwargs)
+        group_id = kwargs[:group_id] || @group_id
+        raise ArgumentError, 'group_id must be provided' if group_id.blank?
+
+        cipher_key = kwargs[:cipher_key] || @cipher_key
+        raise ArgumentError, 'cipher_key must be provided' if cipher_key.blank?
+
+        raise ArgumentError, "Keyword arguments #{ARGUMENTS_FOR_BUILD_TRX} must be provided" unless ARGUMENTS_FOR_BUILD_TRX.all?(&->(arg) { arg.in? kwargs.keys })
+
+        kwargs = kwargs.merge(
+          group_id:,
+          cipher_key:
+        )
+        QuorumSdk::Utils.build_trx(**kwargs)
+      end
+
+      ARGUMENTS_FOR_SEND_TRX = %i[data sender_pubkey sender_sign trx_id version].freeze
+      def send_trx(trx = nil, **kwargs)
+        trx ||= kwargs
+        raise ArgumentError, "Keyword arguments #{ARGUMENTS_FOR_SEND_TRX} must be provided" unless ARGUMENTS_FOR_SEND_TRX.all?(&->(arg) { arg.in? trx.keys })
+
+        group_id = trx[:group_id] || @group_id
+        raise ArgumentError, 'group_id must be provided' if group_id.blank?
+
+        payload = {
+          data: trx[:data],
+          sender_pubkey: trx[:sender_pubkey],
+          sender_sign: trx[:sender_sign],
+          timestamp: trx[:time_stamp] || trx[:timestamp],
+          trx_id: trx[:trx_id],
+          version: trx[:version]
+        }.compact
+        payload.deep_transform_values!(&->(v) { v.is_a?(String) ? v : v.to_s })
+
+        path = "api/v1/node/#{group_id}/trx"
+        client.post(path, **payload).body
+      end
+
+      def list_trx(**kwargs)
+        group_id = kwargs[:group_id] || @group_id
+        raise ArgumentError, 'group_id must be provided' if group_id.blank?
+
+        cipher_key = kwargs[:cipher_key] || @cipher_key
+
+        params = {
+          group_id:,
+          start_trx: kwargs[:start_trx],
+          num: kwargs[:num] || 100,
+          senders: kwargs[:senders],
+          reverse: kwargs[:reverse],
+          include_start_trx: kwargs[:include_start_trx]
+        }.compact
+
+        path = "api/v1/node/#{group_id}/groupctn"
+        list = client.get(path, **params).body
+
+        return list unless list.is_a?(Array)
+        return list if cipher_key.blank?
+
+        list.each do |trx|
+          next if trx['Data'].blank?
+
+          data = Base64.strict_decode64 trx['Data']
+          trx['DecryptedData'] = QuorumSdk::Utils.decrypt_trx_data data, key: cipher_key
+        end
+
+        list
+      end
+    end
+  end
+end

data/lib/quorum_sdk/node.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative 'client'
+require_relative 'node/announce'
+require_relative 'node/app_config'
+require_relative 'node/auth'
+require_relative 'node/group'
+require_relative 'node/trx'
+
+module QuorumSdk
+  # Wrapper for HTTP APIs as light node client
+  class Node
+    attr_reader :group_id, :group_name, :consensus_type, :encryption_type, :app_key, :owner_pubkey, :signature,
+                :cipher_key, :chain_url, :jwt, :client
+
+    def initialize(**kwargs)
+      config =
+        if kwargs[:seed].present?
+          QuorumSdk::Utils.parse_seed kwargs[:seed]
+        else
+          kwargs
+        end
+
+      @group_id = config[:group_id]
+      @group_name = config[:group_name]
+      @consensus_type = config[:consensus_type]
+      @encryption_type = config[:encryption_type]
+      @app_key = config[:app_key]
+      @owner_pubkey = config[:owner_pubkey]
+      @signature = config[:signature]
+      @cipher_key = config[:cipher_key]
+      @chain_url = config[:chain_url]
+      @jwt = config[:jwt]
+
+      @client = QuorumSdk::Client.new(@chain_url, @jwt)
+    end
+
+    include QuorumSdk::Node::Announce
+    include QuorumSdk::Node::AppConfig
+    include QuorumSdk::Node::Auth
+    include QuorumSdk::Node::Group
+    include QuorumSdk::Node::Trx
+  end
+end

data/lib/quorum_sdk/utils.rb

@@ -3,8 +3,10 @@
 module QuorumSdk
   # Wrapper for some useful methods
   module Utils
+    TRX_VERSION = '2.0.0'
+
     class << self
-      def parse_seed_url(url)
+      def parse_seed(url)
         url = Addressable::URI.parse(url.gsub(/\\u([a-f0-9]{4})/i) { [::Regexp.last_match(1).hex].pack('U') })
         query_values = url.query_values
 
@@ -17,7 +19,7 @@ module QuorumSdk
         app_key = query_values['y']
         consensus_type = query_values['n'].to_s == '1' ? 'pos' : 'poa'
         encryption_type = query_values['e'].to_s == '0' ? 'public' : 'private'
-        chain_urls = query_values['u'].split('|')
+        chain_url = query_values['u'].split('|')
 
         {
           group_id:,
@@ -29,11 +31,13 @@ module QuorumSdk
           app_key:,
           consensus_type:,
           encryption_type:,
-          chain_urls:
+          chain_url:
         }
       end
 
       def uuid_from_base64(str)
+        return if str.blank?
+
         hex = Base64.urlsafe_decode64(str).unpack1('H*')
         format(
           '%<first>s-%<second>s-%<third>s-%<forth>s-%<fifth>s',
@@ -46,38 +50,62 @@ module QuorumSdk
       end
 
       ARGUMENTS_FOR_ENCRYPT_TRX = %i[private_key group_id cipher_key data].freeze
-      def encrypt_trx(**kwargs)
+      def build_trx(**kwargs)
         raise ArgumentError, "Keyword arguments #{ARGUMENTS_FOR_ENCRYPT_TRX} must be provided" unless ARGUMENTS_FOR_ENCRYPT_TRX.all?(&->(arg) { arg.in? kwargs.keys })
-        raise ArgumentError, 'data should be instance of Google::Protobuf::MessageExts' unless kwargs[:data].is_a?(Google::Protobuf::MessageExts)
 
-        data = Google::Protobuf::Any.new(
-          type_url: "type.googleapis.com/#{kwargs[:data].class.descriptor.name}",
-          value: kwargs[:data].to_proto
-        ).to_proto
-        encrypted_data = aes_encrypt data, key: kwargs[:cipher_key]
+        data =
+          case kwargs[:data]
+          when Hash
+            kwargs[:data].to_json
+          else
+            kwargs[:data].to_s
+          end
+        encrypted_data = aes_encrypt(data, key: kwargs[:cipher_key])
 
         account = QuorumSdk::Account.new priv: kwargs[:private_key]
 
-        msg =
+        trx =
           Quorum::Pb::Trx.new(
             TrxId: (kwargs[:trx_id] || SecureRandom.uuid),
             GroupId: kwargs[:group_id],
             Data: encrypted_data,
-            TimeStamp: (kwargs[:timestamp].to_i || (Time.now.to_f * 1e9).to_i),
-            Version: (kwargs[:version] || '1.0.0'),
-            Expired: (kwargs[:expired].to_i || (30.seconds.from_now.to_f * 1e9).to_i),
-            Nonce: (kwargs[:nonce] || 1),
+            TimeStamp: (kwargs[:timestamp].presence || (Time.now.to_f * 1e9)).to_i,
+            Version: (kwargs[:version] || TRX_VERSION),
             SenderPubkey: Base64.urlsafe_encode64(account.public_bytes_compressed, padding: false)
           )
 
-        hash = Digest::SHA256.hexdigest msg.to_proto
+        hash = Digest::SHA256.hexdigest trx.to_proto
         signature = account.sign [hash].pack('H*')
-        msg.SenderSign = [signature].pack('H*')
-        trx_json = {
-          TrxBytes: Base64.strict_encode64(msg.to_proto)
-        }
-        encrypted = aes_encrypt trx_json.to_json, key: kwargs[:cipher_key]
-        Base64.strict_encode64 encrypted
+        trx.SenderSign = [signature].pack('H*')
+
+        json = Quorum::Pb::Trx.encode_json trx
+        JSON.parse(json).deep_transform_keys! { |key| key.to_s.underscore.to_sym }
+      end
+
+      def verify_trx(trx = nil, **kwargs)
+        trx ||= kwargs
+        trx.deep_transform_keys! { |key| key.to_s.camelize.to_sym }
+        trx = trx.with_indifferent_access
+        trx['TimeStamp'] = trx['TimeStamp'].to_i if trx['TimeStamp'].present? && trx['TimeStamp'].is_a?(String)
+        trx['Expired'] = trx['Expired'].to_i if trx['Expired'].present? && trx['Expired'].is_a?(String)
+
+        signature = Base64.urlsafe_decode64(trx['SenderSign']).unpack1('H*')
+
+        trx = Quorum::Pb::Trx.new(
+          TrxId: trx['TrxId'],
+          GroupId: trx['GroupId'],
+          Data: Base64.decode64(trx['Data']),
+          TimeStamp: trx['TimeStamp'],
+          Expired: trx['Expired'],
+          Version: trx['Version'],
+          SenderPubkey: trx['SenderPubkey']
+        )
+
+        hash = Digest::SHA256.hexdigest trx.to_proto
+        public_key = Secp256k1::PublicKey.from_data(Base64.urlsafe_decode64(trx.SenderPubkey)).uncompressed.unpack1('H*')
+        recover_key = Eth::Signature.recover [hash].pack('H*'), signature
+
+        public_key == recover_key
       end
 
       def decrypt_trx(cipher, key:)
@@ -91,9 +119,9 @@ module QuorumSdk
         hash = Digest::SHA256.hexdigest Quorum::Pb::Trx.encode(trx_without_sig)
 
         signature = trx.SenderSign.unpack1('H*')
-        public_key_compressed = Base64.urlsafe_decode64(trx.SenderPubkey).unpack1('H*')
-        public_key_uncompressed = Eth::Signature.recover [hash].pack('H*'), signature
-        raise QuorumSdk::Error, 'Signature not verified' if public_key_uncompressed[2...66] != public_key_compressed[2...]
+        public_key = Secp256k1::PublicKey.from_data(Base64.urlsafe_decode64(trx.SenderPubkey)).uncompressed.unpack1('H*')
+        recover_key = Eth::Signature.recover [hash].pack('H*'), signature
+        raise QuorumSdk::Error, "Signature not verified: #{public_key} != #{recover_key}" unless public_key == recover_key
 
         data = decrypt_trx_data(trx.Data, key:)
 
@@ -104,9 +132,11 @@ module QuorumSdk
 
       def decrypt_trx_data(cipher, key:)
         decrypted_data = aes_decrypt(cipher, key:)
-        obj = Google::Protobuf::Any.decode decrypted_data
-        msgclass = ::Google::Protobuf::DescriptorPool.generated_pool.lookup(obj.type_url.split('/').last).msgclass
-        JSON.parse msgclass.encode_json(msgclass.decode(obj.value))
+        begin
+          JSON.parse(decrypted_data).with_indifferent_access
+        rescue JSON::ParserError
+          decrypted_data
+        end
       end
 
       def aes_encrypt(data, key:)

data/lib/quorum_sdk/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module QuorumSdk
-  VERSION = '0.1.0'
+  VERSION = '0.3.0'
 end

data/lib/quorum_sdk.rb

@@ -9,10 +9,10 @@ require 'faraday'
 require 'faraday/retry'
 require 'google/protobuf/well_known_types'
 
-require_relative 'proto/activity_stream_pb'
 require_relative 'proto/chain_pb'
 require_relative 'quorum_sdk/account'
-require_relative 'quorum_sdk/api'
+require_relative 'quorum_sdk/chain'
+require_relative 'quorum_sdk/node'
 require_relative 'quorum_sdk/utils'
 require_relative 'quorum_sdk/version'