erpc-sdk 0.4.0

data/lib/erpc_sdk/rest.rb

@@ -0,0 +1,370 @@
+# frozen_string_literal: true
+
+require "json"
+require "time"
+
+module ERPC
+  module Validation
+    module_function
+
+    def mapping(value)
+      raise InvalidResponseError unless value.is_a?(Hash) && value.keys.all? { |key| key.is_a?(String) }
+
+      value
+    end
+
+    def string(value)
+      raise InvalidResponseError unless value.is_a?(String)
+
+      value
+    end
+
+    def number(value, integer: false, nonnegative: false)
+      valid = value.is_a?(Numeric) && value.finite?
+      valid &&= value.is_a?(Integer) if integer
+      valid &&= value >= 0 if nonnegative
+      raise InvalidResponseError unless valid
+
+      value
+    end
+
+    def datetime(value)
+      text = string(value)
+      Time.iso8601(text)
+      text
+    rescue ArgumentError
+      raise InvalidResponseError
+    end
+  end
+
+  class AccountClient
+    def initialize(transport)
+      @transport = transport
+    end
+
+    def get_token_balance
+      data = Validation.mapping(@transport.get("/v3/erpc/token-balance"))
+      unless %w[business developer free pro].include?(data["plan"])
+        raise InvalidResponseError, "ERPC returned an invalid token balance"
+      end
+      Validation.number(data["max_tokens"], integer: true)
+      Validation.number(data["remaining_tokens"], integer: true)
+      Validation.string(data["next_refill_at"]) unless data["next_refill_at"].nil?
+      data
+    rescue InvalidResponseError
+      raise InvalidResponseError, "ERPC returned an invalid token balance"
+    end
+  end
+
+  class UsageClient
+    YEAR_MONTH = /\A\d{4}-(0[1-9]|1[0-2])\z/
+    private_constant :YEAR_MONTH
+
+    def initialize(transport)
+      @transport = transport
+    end
+
+    def get_monthly_api_key_usage(year_month = nil)
+      if !year_month.nil? && !YEAR_MONTH.match?(year_month)
+        raise ConfigError, "year_month must use YYYY-MM format"
+      end
+
+      envelope = Validation.mapping(@transport.get("/v3/user/api-keys/usage", "yearMonth" => year_month))
+      raise InvalidResponseError unless envelope["success"] == true
+
+      usage = Validation.mapping(envelope["message"])
+      validate_usage(usage)
+      usage
+    rescue InvalidResponseError
+      raise InvalidResponseError, "ERPC returned an invalid monthly API key usage response"
+    end
+
+    private
+
+    def validate_usage(usage)
+      raise InvalidResponseError unless YEAR_MONTH.match?(Validation.string(usage["yearMonth"]))
+
+      %w[keyCount totalCount totalCredits].each { |field| Validation.number(usage[field]) }
+      raise InvalidResponseError unless [true, false].include?(usage["hasStrandedUsage"])
+      Validation.string(usage["updatedAt"]) unless usage["updatedAt"].nil?
+      validate_chains(usage["chains"])
+      raise InvalidResponseError unless usage["apiKeys"].is_a?(Array)
+
+      usage["apiKeys"].each do |raw|
+        item = Validation.mapping(raw)
+        Validation.string(item["apiKeyLast4"])
+        %w[apiKeyLength count credits].each { |field| Validation.number(item[field]) }
+        Validation.number(item["keyId"]) unless item["keyId"].nil?
+        Validation.string(item["updatedAt"]) unless item["updatedAt"].nil?
+        validate_chains(item["chains"])
+      end
+    end
+
+    def validate_chains(value)
+      raise InvalidResponseError unless value.is_a?(Array)
+
+      value.each do |raw_chain|
+        chain = Validation.mapping(raw_chain)
+        Validation.string(chain["chain"])
+        %w[count credits].each { |field| Validation.number(chain[field]) }
+        Validation.string(chain["updatedAt"]) unless chain["updatedAt"].nil?
+        raise InvalidResponseError unless chain["methods"].is_a?(Array)
+
+        chain["methods"].each do |raw_method|
+          method = Validation.mapping(raw_method)
+          Validation.string(method["method"])
+          %w[count creditCost credits].each { |field| Validation.number(method[field]) }
+          Validation.string(method["updatedAt"]) unless method["updatedAt"].nil?
+        end
+      end
+    end
+  end
+
+  class PriceClient
+    def initialize(transport)
+      @transport = transport
+    end
+
+    def get_price_feeds(asset_type: nil, query: nil)
+      value = @transport.get("/v2/price_feeds", "query" => query, "asset_type" => asset_type)
+      raise InvalidResponseError, "ERPC returned invalid price feed metadata" unless value.is_a?(Array)
+
+      value.each do |raw|
+        metadata = Validation.mapping(raw)
+        Validation.string(metadata["id"])
+        attributes = metadata["attributes"]
+        next if attributes.nil?
+        unless attributes.is_a?(Hash) && attributes.all? { |key, item| key.is_a?(String) && item.is_a?(String) }
+          raise InvalidResponseError, "ERPC returned invalid price feed metadata"
+        end
+      end
+      value
+    rescue InvalidResponseError
+      raise InvalidResponseError, "ERPC returned invalid price feed metadata"
+    end
+
+    def get_latest_price_updates(ids:, encoding: nil, parsed: nil, ignore_invalid_price_ids: nil)
+      value = @transport.get(
+        "/v2/updates/price/latest",
+        update_query(ids, encoding, parsed, ignore_invalid_price_ids)
+      )
+      price_update(value)
+    end
+
+    def get_price_updates_at_timestamp(publish_time, ids:, encoding: nil, parsed: nil,
+                                       ignore_invalid_price_ids: nil)
+      value = @transport.get(
+        "/v2/updates/price/#{URLs.escape_path(publish_time)}",
+        update_query(ids, encoding, parsed, ignore_invalid_price_ids)
+      )
+      price_update(value)
+    end
+
+    def get_latest_publisher_stake_caps(encoding: nil, parsed: nil)
+      Validation.mapping(
+        @transport.get(
+          "/v2/updates/publisher_stake_caps/latest",
+          "encoding" => encoding,
+          "parsed" => parsed
+        )
+      )
+    end
+
+    def stream_price_updates(ids:, encoding: nil, parsed: nil, ignore_invalid_price_ids: nil,
+                             allow_unordered: nil, benchmarks_only: nil)
+      query = update_query(ids, encoding, parsed, ignore_invalid_price_ids).merge(
+        "allow_unordered" => allow_unordered,
+        "benchmarks_only" => benchmarks_only
+      )
+      chunks = @transport.stream("/v2/updates/price/stream", query)
+      Enumerator.new do |yielder|
+        buffer = +""
+        chunks.each do |chunk|
+          buffer << chunk
+          while (boundary = buffer.match(/\r?\n\r?\n/))
+            block = buffer.slice!(0, boundary.end(0))
+            event = parse_sse_block(block.sub(/\r?\n\r?\n\z/, ""))
+            yielder << event if event
+          end
+        end
+        event = parse_sse_block(buffer)
+        yielder << event if event
+      end
+    end
+
+    private
+
+    def update_query(ids, encoding, parsed, ignore_invalid_price_ids)
+      {
+        "ids[]" => ids,
+        "encoding" => encoding,
+        "parsed" => parsed,
+        "ignore_invalid_price_ids" => ignore_invalid_price_ids
+      }
+    end
+
+    def price_update(value)
+      update = Validation.mapping(value)
+      binary = Validation.mapping(update["binary"])
+      data = binary["data"]
+      valid = data.is_a?(Array) && data.all? { |item| item.is_a?(String) }
+      valid &&= binary["encoding"].is_a?(String)
+      valid &&= update["parsed"].is_a?(Array) if update.key?("parsed")
+      raise InvalidResponseError, "ERPC returned an invalid price update" unless valid
+
+      update
+    rescue InvalidResponseError
+      raise InvalidResponseError, "ERPC returned an invalid price update"
+    end
+
+    def parse_sse_block(block)
+      data = []
+      result = {}
+      block.each_line(chomp: true) do |line|
+        next if line.empty? || line.start_with?(":")
+
+        field, separator, raw = line.partition(":")
+        value = separator.empty? ? "" : raw.sub(/\A /, "")
+        data << value if field == "data"
+        result[field] = value if %w[event id].include?(field)
+      end
+      return nil if data.empty?
+
+      result["data"] = price_update(JSON.parse(data.join("\n")))
+      result
+    rescue JSON::ParserError, InvalidResponseError
+      raise InvalidResponseError, "ERPC returned malformed stream data"
+    end
+  end
+
+  class CloudCatalogClient
+    RESOURCE_KINDS = %w[bare-metal solana-grpc solana-shredstream vps].freeze
+    RESOURCE_MODES = %w[dedicated direct shared].freeze
+
+    def initialize(transport)
+      @transport = transport
+    end
+
+    def list
+      envelope = Validation.mapping(@transport.get("/v4/cloud/catalog"))
+      message = Validation.mapping(envelope["message"])
+      offerings = message["offerings"]
+      raise InvalidResponseError unless envelope["success"] == true && offerings.is_a?(Array)
+
+      offerings.each do |raw|
+        item = Validation.mapping(raw)
+        %w[id name description].each { |field| Validation.string(item[field]) }
+        raise InvalidResponseError unless RESOURCE_KINDS.include?(item["kind"])
+        raise InvalidResponseError if item["mode"] && !RESOURCE_MODES.include?(item["mode"])
+        %w[regions capabilities].each do |field|
+          array = item[field]
+          raise InvalidResponseError unless array.is_a?(Array) && array.all? { |entry| entry.is_a?(String) }
+        end
+      end
+      offerings
+    rescue InvalidResponseError
+      raise InvalidResponseError, "ERPC returned an invalid Cloud catalog"
+    end
+  end
+
+  class CloudCreditClient
+    ALERT_LEVELS = %w[critical normal suspended warning].freeze
+
+    def initialize(transport)
+      @transport = transport
+    end
+
+    def get
+      envelope = Validation.mapping(@transport.get("/v4/cloud/credit"))
+      raise InvalidResponseError unless envelope["success"] == true
+
+      credit = Validation.mapping(envelope["message"])
+      raise InvalidResponseError unless ALERT_LEVELS.include?(credit["alertLevel"])
+      Validation.number(credit["balanceCents"], integer: true)
+      Validation.number(credit["burnRateCentsPerHour"], integer: true, nonnegative: true)
+      Validation.number(credit["timeToZeroHours"], nonnegative: true) unless credit["timeToZeroHours"].nil?
+      Validation.datetime(credit["quoteTimestamp"])
+      Validation.datetime(credit["quoteExpiresAt"])
+      credit
+    rescue InvalidResponseError
+      raise InvalidResponseError, "ERPC returned an invalid Cloud credit snapshot"
+    end
+  end
+
+  class CloudResourcesClient
+    RESOURCE_KINDS = CloudCatalogClient::RESOURCE_KINDS
+    RESOURCE_MODES = CloudCatalogClient::RESOURCE_MODES
+    BILLING_STATUSES = %w[active grace-period inactive suspended].freeze
+
+    def initialize(transport)
+      @transport = transport
+    end
+
+    def list
+      envelope = Validation.mapping(@transport.get("/v4/cloud/resources"))
+      message = Validation.mapping(envelope["message"])
+      resources = message["resources"]
+      raise InvalidResponseError unless envelope["success"] == true && resources.is_a?(Array)
+
+      resources.each { |resource| validate_resource(resource) }
+      resources
+    rescue InvalidResponseError
+      raise InvalidResponseError, "ERPC returned an invalid Cloud resource list"
+    end
+
+    def get(resource_id)
+      value = @transport.get("/v4/cloud/resources/#{URLs.escape_path(normalize_id(resource_id))}")
+      envelope = Validation.mapping(value)
+      message = Validation.mapping(envelope["message"])
+      raise InvalidResponseError unless envelope["success"] == true
+
+      validate_resource(message["resource"])
+    rescue InvalidResponseError
+      raise InvalidResponseError, "ERPC returned an invalid Cloud resource"
+    end
+
+    def get_status(resource_id)
+      path = "/v4/cloud/resources/#{URLs.escape_path(normalize_id(resource_id))}/status"
+      envelope = Validation.mapping(@transport.get(path))
+      raise InvalidResponseError unless envelope["success"] == true
+
+      status = Validation.mapping(envelope["message"])
+      Validation.string(status["id"])
+      Validation.string(status["status"])
+      validate_billing(status["billing"]) if status.key?("billing")
+      status
+    rescue InvalidResponseError
+      raise InvalidResponseError, "ERPC returned an invalid Cloud resource status"
+    end
+
+    private
+
+    def normalize_id(value)
+      result = value.to_s.strip
+      raise ConfigError, "resource_id must not be empty" if result.empty?
+
+      result
+    end
+
+    def validate_resource(value)
+      resource = Validation.mapping(value)
+      Validation.string(resource["id"])
+      Validation.string(resource["status"])
+      raise InvalidResponseError unless RESOURCE_KINDS.include?(resource["kind"])
+      raise InvalidResponseError if resource["mode"] && !RESOURCE_MODES.include?(resource["mode"])
+      %w[name region createdAt].each do |field|
+        Validation.string(resource[field]) unless resource[field].nil?
+      end
+      resource
+    end
+
+    def validate_billing(value)
+      billing = Validation.mapping(value)
+      raise InvalidResponseError unless BILLING_STATUSES.include?(billing["status"])
+      Validation.number(billing["hourlyCredits"], nonnegative: true) if billing.key?("hourlyCredits")
+      %w[nextChargeAt graceEndsAt].each do |field|
+        Validation.datetime(billing[field]) if billing.key?(field)
+      end
+    end
+  end
+end

data/lib/erpc_sdk/rpc.rb

@@ -0,0 +1,269 @@
+# frozen_string_literal: true
+
+module ERPC
+  SOLANA_RPC_METHODS = [
+    "getAccountInfo",
+    "getBalance",
+    "getBlock",
+    "getBlockCommitment",
+    "getBlockHeight",
+    "getBlockProduction",
+    "getBlockTime",
+    "getBlocks",
+    "getBlocksWithLimit",
+    "getClusterNodes",
+    "getEpochInfo",
+    "getEpochSchedule",
+    "getFeeForMessage",
+    "getFirstAvailableBlock",
+    "getGenesisHash",
+    "getHealth",
+    "getHighestSnapshotSlot",
+    "getIdentity",
+    "getInflationGovernor",
+    "getInflationRate",
+    "getInflationReward",
+    "getLargestAccounts",
+    "getLatestBlockhash",
+    "getLeaderSchedule",
+    "getMaxRetransmitSlot",
+    "getMaxShredInsertSlot",
+    "getMinimumBalanceForRentExemption",
+    "getMultipleAccounts",
+    "getParsedTransaction",
+    "getPriorityFeeEstimate",
+    "getProgramAccounts",
+    "getProgramAccountsV2",
+    "getRecentPerformanceSamples",
+    "getRecentPrioritizationFees",
+    "getSignatureStatuses",
+    "getSignaturesForAddress",
+    "getSlot",
+    "getSlotLeader",
+    "getSlotLeaders",
+    "getStakeMinimumDelegation",
+    "getSupply",
+    "getTokenAccountBalance",
+    "getTokenAccountsByDelegate",
+    "getTokenAccountsByOwner",
+    "getTokenLargestAccounts",
+    "getTokenSupply",
+    "getTransaction",
+    "getTransactionCount",
+    "getVersion",
+    "getVoteAccounts",
+    "isBlockhashValid",
+    "minimumLedgerSlot",
+    "requestAirdrop",
+    "sendTransaction",
+    "simulateTransaction"
+  ].freeze
+
+  SOLANA_DAS_METHODS = [
+    "getAsset",
+    "getAssetBatch",
+    "getAssetProof",
+    "getAssetProofBatch",
+    "getAssetsByAuthority",
+    "getAssetsByCreator",
+    "getAssetsByGroup",
+    "getAssetsByOwner",
+    "getNftEditions",
+    "getSignaturesForAsset",
+    "getTokenAccounts",
+    "getTokensByDelegate",
+    "getTokensByOwner",
+    "searchAssets"
+  ].freeze
+
+  SOLANA_HISTORY_METHODS = [
+    "getTransactionsForAddress",
+    "getTransfersByAddress"
+  ].freeze
+
+  SOLANA_LEADER_METHODS = [
+    "getLeaderSlots",
+    "getValidatorsInformation"
+  ].freeze
+
+  SOLANA_ANALYTICS_METHODS = [
+    "jetEpochSummary",
+    "jetProgramStats",
+    "jetSlotStats",
+    "jetTopPrograms",
+    "jetTpsTimeseries"
+  ].freeze
+
+  SOLANA_ENHANCED_SUBSCRIPTION_METHODS = [
+    "accountSubscribe",
+    "accountUnsubscribe",
+    "transactionSubscribe",
+    "transactionUnsubscribe"
+  ].freeze
+
+  ETHEREUM_RPC_METHODS = [
+    "eth_accounts",
+    "eth_baseFee",
+    "eth_blobBaseFee",
+    "eth_blockNumber",
+    "eth_call",
+    "eth_callMany",
+    "eth_capabilities",
+    "eth_chainId",
+    "eth_createAccessList",
+    "eth_estimateGas",
+    "eth_feeHistory",
+    "eth_gasPrice",
+    "eth_getAccount",
+    "eth_getBalance",
+    "eth_getBlockByHash",
+    "eth_getBlockByNumber",
+    "eth_getBlockReceipts",
+    "eth_getBlockTransactionCountByHash",
+    "eth_getBlockTransactionCountByNumber",
+    "eth_getCode",
+    "eth_getFilterChanges",
+    "eth_getFilterLogs",
+    "eth_getLogs",
+    "eth_getProof",
+    "eth_getRawTransactionByHash",
+    "eth_getStorageAt",
+    "eth_getTransactionByBlockHashAndIndex",
+    "eth_getTransactionByBlockNumberAndIndex",
+    "eth_getTransactionByHash",
+    "eth_getTransactionBySenderAndNonce",
+    "eth_getTransactionCount",
+    "eth_getTransactionReceipt",
+    "eth_getUncleCountByBlockHash",
+    "eth_getUncleCountByBlockNumber",
+    "eth_maxPriorityFeePerGas",
+    "eth_newBlockFilter",
+    "eth_newFilter",
+    "eth_newPendingTransactionFilter",
+    "eth_sendRawTransaction",
+    "eth_signTransaction",
+    "eth_simulateV1",
+    "eth_submitWork",
+    "eth_syncing",
+    "eth_uninstallFilter",
+    "net_listening",
+    "net_peerCount",
+    "net_version",
+    "txpool_content",
+    "txpool_contentFrom",
+    "txpool_inspect",
+    "txpool_status",
+    "web3_clientVersion",
+    "web3_sha3"
+  ].freeze
+
+  ETHEREUM_SUBSCRIPTION_METHODS = [
+    "eth_subscribe",
+    "eth_unsubscribe"
+  ].freeze
+
+  HEAVY_SOLANA_METHODS = %w[
+    getPriorityFeeEstimate
+    getProgramAccounts
+    getProgramAccountsV2
+    getTokenLargestAccounts
+  ].freeze
+  private_constant :HEAVY_SOLANA_METHODS
+
+  class PendingRpcRequest
+    def initialize(transport, method, params, decoder)
+      @transport = transport
+      @method = method
+      @params = params
+      @decoder = decoder
+    end
+
+    def send
+      @decoder.call(@transport.request(@method, @params))
+    end
+  end
+
+  class PendingRpcBatchRequest
+    def initialize(transport, calls)
+      @transport = transport
+      @calls = calls.map(&:dup).freeze
+    end
+
+    def send
+      @transport.batch(@calls)
+    end
+  end
+
+  class RpcNamespace
+    attr_reader :endpoint
+
+    def initialize(transport, methods, parameter_mode:, batch_policy: :any)
+      @transport = transport
+      @endpoint = transport.endpoint
+      @methods = methods.to_h { |method| [method, true] }.freeze
+      @aliases = methods.to_h { |method| [snake_case(method), method] }.freeze
+      @parameter_mode = parameter_mode
+      @batch_policy = batch_policy
+    end
+
+    def request(method, params = nil, decoder: nil)
+      unless @methods.key?(method)
+        raise ConfigError, "#{method.inspect} is not in this namespace; use raw for forward-compatible methods"
+      end
+
+      PendingRpcRequest.new(@transport, method, params, decoder || ->(value) { value })
+    end
+
+    def raw(method, params = nil, decoder: nil)
+      raise ConfigError, "method must not be empty" if method.to_s.empty?
+
+      PendingRpcRequest.new(@transport, method, params, decoder || ->(value) { value })
+    end
+
+    def batch(calls)
+      if @batch_policy == :unsupported && !calls.empty?
+        raise BatchPolicyError, "Leader RPC methods do not support batching"
+      end
+      if @batch_policy == :solana_standard
+        methods = calls.map { |call| call[:method] || call["method"] }
+        has_heavy = methods.any? { |method| HEAVY_SOLANA_METHODS.include?(method) }
+        has_standard = methods.any? { |method| !HEAVY_SOLANA_METHODS.include?(method) }
+        if has_heavy && has_standard
+          raise BatchPolicyError, "Solana indexed and standard RPC methods cannot share a batch"
+        end
+      end
+
+      PendingRpcBatchRequest.new(@transport, calls)
+    end
+
+    def method_missing(name, *arguments, &block)
+      return super if block
+
+      string_name = name.to_s
+      method = @methods.key?(string_name) ? string_name : @aliases[string_name]
+      return super unless method
+
+      params = if @parameter_mode == :positional
+                 arguments
+               elsif arguments.empty?
+                 nil
+               elsif arguments.length == 1 && arguments.first.is_a?(Hash)
+                 arguments.first
+               else
+                 raise ConfigError, "named RPC methods require one Hash argument"
+               end
+      request(method, params)
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      string_name = name.to_s
+      @methods.key?(string_name) || @aliases.key?(string_name) || super
+    end
+
+    private
+
+    def snake_case(value)
+      value.gsub(/(?<=[a-z0-9])(?=[A-Z])/, "_").downcase
+    end
+  end
+end