solana-ruby-web3js 1.0.1.beta1

data/lib/solana_ruby/http_client.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+require 'uri'
+require 'base64'
+require 'base58'
+require_relative 'base_client'
+Dir[File.join(__dir__, 'http_methods', '*.rb')].each { |file| require file }
+
+module SolanaRuby
+  class HttpClient < BaseClient
+    [HttpMethods::BasicMethods, HttpMethods::LookupTableMethods, HttpMethods::TransactionMethods,
+      HttpMethods::SignatureMethods, HttpMethods::BlockhashMethods, HttpMethods::BlockMethods,
+      HttpMethods::AccountMethods, HttpMethods::TokenMethods, HttpMethods::SlotMethods].each do |mod|
+      include mod
+    end
+    BASE_URL = 'https://api.mainnet-beta.solana.com'
+
+    def initialize(endpoint = BASE_URL)
+      @uri = URI.parse(endpoint)
+    end
+
+    def request(method, params = [])
+      http = Net::HTTP.new(@uri.host, @uri.port)
+      http.use_ssl = true
+
+      request = Net::HTTP::Post.new(@uri.request_uri, {'Content-Type' => 'application/json'})
+      request.body = {
+        jsonrpc: '2.0',
+        id: 1,
+        method: method,
+        params: params
+      }.to_json
+
+      response = http.request(request)
+      handle_http_response(response)
+    rescue StandardError => e
+      handle_error(e)
+    end
+  end
+end

data/lib/solana_ruby/http_methods/account_methods.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module SolanaRuby
+  module HttpMethods
+    # Account Related HTTP Methods
+    module AccountMethods
+      ENCODING_JSON_OPTIONS = { encoding: "jsonParsed", commitment: "finalized" }.freeze
+      FINALIZED_OPTIONS = { commitment: "finalized" }.freeze
+      ENCODING_BASE58_OPTIONS = { encoding: "base58" }.freeze
+
+      def get_account_info(pubkey)
+        account_info = get_account_info_and_context(pubkey)
+        account_info["value"]
+      end
+
+      def get_parsed_account_info(pubkey, options = ENCODING_JSON_OPTIONS)
+        get_account_info_and_context(pubkey, options)
+      end
+
+      def get_account_info_and_context(pubkey, options = {})
+        account_info = request("getAccountInfo", [pubkey, options])
+        account_info["result"]
+      end
+
+      def get_multiple_account_info(pubkeys, options = ENCODING_BASE58_OPTIONS)
+        accounts_info = get_multiple_account_info_and_context(pubkeys, options)
+        accounts_info["value"]
+      end
+
+      def get_multiple_account_info_and_context(pubkeys, options = ENCODING_BASE58_OPTIONS)
+        params = [pubkeys, options]
+        accounts_info = request("getMultipleAccounts", params)
+        accounts_info["result"]
+      end
+
+      def get_multiple_parsed_accounts(pubkeys, options = ENCODING_JSON_OPTIONS)
+        get_multiple_account_info_and_context(pubkeys, options)
+      end
+
+      def get_largest_accounts(options = ENCODING_BASE58_OPTIONS.merge(FINALIZED_OPTIONS))
+        account_info = request("getLargestAccounts", [options])
+        account_info["result"]
+      end
+
+      def get_program_accounts(program_id, options = FINALIZED_OPTIONS)
+        params = [program_id, options]
+        account_info = request("getProgramAccounts", params)
+        account_info["result"]
+      end
+
+      def get_parsed_program_accounts(program_id, options = ENCODING_JSON_OPTIONS)
+        get_program_accounts(program_id, options)
+      end
+
+      def get_vote_accounts(options = FINALIZED_OPTIONS)
+        account_info = request("getVoteAccounts", [options])
+        account_info["result"]
+      end
+
+      def get_parsed_token_accounts_by_owner(owner_pubkey, filters = {}, options = ENCODING_JSON_OPTIONS)
+        params = [owner_pubkey, filters, options]
+        parsed_token_accounts = request("getTokenAccountsByOwner", params)
+        parsed_token_accounts["result"]
+      end
+
+      def get_nonce_and_context(pubkey)
+        account_info_and_context = get_account_info_and_context(pubkey)
+        unless account_info_and_context["value"]["owner"] == "11111111111111111111111111111111"
+          raise "Provided account is not a nonce account"
+        end
+
+        data = account_info_and_context["value"]["data"][0]
+        raise "Nonce account data is empty" if data.nil? || data.empty?
+
+        decoded_data = Base64.decode64(data)
+        nonce_info = parse_nonce_account(decoded_data)
+        {
+          context: account_info_and_context["context"],
+          value: nonce_info
+        }
+      end
+
+      def get_nonce(pubkey)
+        nonce_info = get_nonce_and_context(pubkey)
+        nonce_info[:value]
+      end
+
+      private
+
+      def parse_nonce_account(data)
+        {
+          blockhash: data[4, 32].unpack1("H*"),
+          fee_calculator: { lamports_per_signature: data[36, 8].unpack1("Q<") }
+        }
+      end
+    end
+  end
+end

data/lib/solana_ruby/http_methods/basic_methods.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module SolanaRuby
+  module HttpMethods
+    # Basic Methods
+    module BasicMethods
+      FINALIZED_OPTIONS = { commitment: "finalized" }.freeze
+
+      def get_balance(pubkey)
+        balance_info = request("getBalance", [pubkey])
+        balance_info["result"]["value"]
+      end
+
+      def get_balance_and_context(pubkey)
+        balance_info = request("getBalance", [pubkey])
+        balance_info["result"]
+      end
+
+      def get_epoch_info(options = FINALIZED_OPTIONS)
+        epoch_info = request("getEpochInfo", [options])
+        epoch_info["result"]
+      end
+
+      def get_epoch_schedule
+        epoch_schedule = request("getEpochSchedule")
+        epoch_schedule["result"]
+      end
+
+      def get_genesis_hash
+        genesis_hash = request("getGenesisHash")
+        genesis_hash["result"]
+      end
+
+      def get_inflation_governor
+        inflation_governor = request("getInflationGovernor")
+        inflation_governor["result"]
+      end
+
+      def get_inflation_rate
+        inflation_rate = request("getInflationRate")
+        inflation_rate["result"]
+      end
+
+      def get_inflation_reward(addresses, options = {})
+        params = [addresses, options]
+        request("getInflationReward", params)
+      end
+
+      def get_leader_schedule(options = { epoch: nil })
+        leader_schedule = request("getLeaderSchedule", [options])
+        leader_schedule["result"]
+      end
+
+      def get_minimum_balance_for_rent_exemption(account_data_size, options = FINALIZED_OPTIONS)
+        params = [account_data_size, options]
+        minimum_balance_for_rent_exemption = request("getMinimumBalanceForRentExemption", params)
+        minimum_balance_for_rent_exemption["result"]
+      end
+
+      def get_stake_activation(account_pubkey, options = FINALIZED_OPTIONS.merge(epoch: nil))
+        params = [account_pubkey, options]
+        stake_activation = request("getStakeActivation", params)
+        stake_activation["result"]
+      end
+
+      def get_stake_minimum_delegation(options = FINALIZED_OPTIONS)
+        stake_minimum_delagation = request("getStakeMinimumDelegation", [FINALIZED_OPTIONS])
+        stake_minimum_delagation["result"]
+      end
+
+      def get_supply(options = FINALIZED_OPTIONS)
+        supply_info = request("getSupply", [options])
+        supply_info["result"]
+      end
+
+      def get_version
+        version_info = request("getVersion")
+        version_info["result"]
+      end
+
+      def get_total_supply(options = FINALIZED_OPTIONS)
+        supply_info = get_supply(options)
+        supply_info["value"]["total"]
+      end
+
+      def get_health
+        health_info = request("getHealth")
+        health_info["result"]
+      end
+
+      def get_identity
+        health_info = request("getIdentity")
+        health_info["result"]
+      end
+
+      def get_recent_performance_samples(limit = 10)
+        performance_samples = request("getRecentPerformanceSamples", [limit])
+        performance_samples["result"]
+      end
+
+      def get_recent_prioritization_fees(addresses)
+        params = [addresses]
+        prioritization_fees = request("getRecentPrioritizationFees", params)
+        prioritization_fees["result"]
+      end
+    end
+  end
+end

data/lib/solana_ruby/http_methods/block_methods.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module SolanaRuby
+  module HttpMethods
+    # Block Related HTTP Methods
+    module BlockMethods
+      DEFAULT_OPTIONS = { maxSupportedTransactionVersion: 0 }.freeze
+
+      def get_blocks(start_slot, end_slot)
+        params = [start_slot, end_slot]
+        block_info = request("getBlocks", params)
+        block_info["result"]
+      end
+
+      def get_block(slot, options = DEFAULT_OPTIONS)
+        params = [slot, options]
+        block_info = request("getBlock", params)
+        block_info["result"]
+      end
+
+      def get_block_production
+        request("getBlockProduction")
+      end
+
+      def get_block_time(slot)
+        block_info = request("getBlockTime", [slot])
+        block_info["result"]
+      end
+
+      def get_block_signatures(slot, options = DEFAULT_OPTIONS)
+        block_info = get_block(slot, options)
+        block_signatures(block_info)
+      end
+
+      def get_cluster_nodes
+        cluster_nodes_info = request("getClusterNodes")
+        cluster_nodes_info["result"]
+      end
+
+      def get_confirmed_block(slot, options = DEFAULT_OPTIONS)
+        block_info = get_block(slot, options)
+        block_info["result"]
+      end
+
+      def get_confirmed_block_signatures(slot)
+        block_info = get_confirmed_block(slot)
+        block_signatures(block_info)
+      end
+
+      def get_parsed_block(slot, options = {})
+        params = [slot, { encoding: "jsonParsed", transactionDetails: "full" }.merge(options)]
+        result = request("getBlock", params)
+        result["result"]
+      end
+
+      def get_first_available_block
+        result = request("getFirstAvailableBlock")
+        result["result"]
+      end
+
+      def get_blocks_with_limit(start_slot, limit)
+        params = [start_slot, limit]
+        response = request("getBlocksWithLimit", params)
+        response["result"]
+      end
+
+      def get_block_height
+        block_height = request("getBlockHeight")
+        block_height["result"]
+      end
+
+      def get_block_commitment(block_slot)
+        block_commitment = request("getBlockCommitment", [block_slot])
+        block_commitment["result"]
+      end
+
+      private
+
+      def block_signatures(block_info)
+        signatures = block_info["transactions"][0]["transaction"]["signatures"]
+        block_info.delete("transactions")
+        block_info.delete("rewards")
+        block_info.merge({
+                           signatures: signatures
+                         })
+      end
+    end
+  end
+end

data/lib/solana_ruby/http_methods/blockhash_methods.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module SolanaRuby
+  module HttpMethods
+    # Blockhash Related HTTP Methods
+    module BlockhashMethods
+      def get_latest_blockhash
+        recent_blockhash_info = get_latest_blockhash_and_context
+        recent_blockhash_info["value"]
+      end
+
+      def get_latest_blockhash_and_context
+        recent_blockhash_info = request("getLatestBlockhash")
+        recent_blockhash_info["result"]
+      end
+
+      def get_fee_for_message(blockhash, options = { commitment: "processed" })
+        params = [blockhash, options]
+        fee_for_blockhash_info = request("getFeeForMessage", params)
+        fee_for_blockhash_info["result"]
+      end
+
+      def is_blockhash_valid?(blockhash, options = { commitment: "processed" })
+        params = [blockhash, options]
+        blockhash_info = request("isBlockhashValid", params)
+        blockhash_info["result"]["value"]
+      end
+    end
+  end
+end

data/lib/solana_ruby/http_methods/lookup_table_methods.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module SolanaRuby
+  module HttpMethods
+    # Lookup Table Related HTTP Methods
+    module LookupTableMethods
+      def get_address_lookup_table(pubkey)
+        response = get_account_info_and_context(pubkey)
+
+        # Handle the response to ensure the account is a valid Address Lookup Table
+        unless response && response["value"]
+          raise SolanaError.new("Address Lookup Table not found or invalid account data.")
+        end
+
+        account_data = response["value"]["data"]
+
+        # Decode the account data
+        decode_lookup_table_data(Base64.decode64(account_data))
+
+        # Return the parsed lookup table details
+      end
+
+      private
+
+      def decode_lookup_table_data(data)
+        lookup_table_state = {}
+
+        lookup_table_state[:last_extended_slot],
+        lookup_table_state[:last_extended_block_height],
+        deactivation_slot = data[0, 24].unpack("Q<Q<Q<")
+
+        lookup_table_state[:deactivation_slot] = deactivation_slot == 0xFFFFFFFFFFFFFFFF ? nil : deactivation_slot
+
+        authority_offset = 24
+        addresses_offset = authority_offset + 32
+
+        authority_key = data[authority_offset, 32]
+        lookup_table_state[:authority] = if authority_key == ("\x00" * 32)
+                                           nil
+                                         else
+                                           Base58.binary_to_base58(authority_key, :bitcoin)
+                                         end
+
+        addresses_data = data[addresses_offset..-1]
+        address_count = addresses_data.size / 32
+        lookup_table_state[:addresses] = address_count.times.map do |i|
+          address_data = addresses_data[i * 32, 32]
+          Base58.binary_to_base58(address_data, :bitcoin)
+        end
+
+        lookup_table_state
+      end
+    end
+  end
+end

data/lib/solana_ruby/http_methods/signature_methods.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module SolanaRuby
+  module HttpMethods
+    # Signature Related Web Socket Methods
+    module SignatureMethods
+      def get_signature_statuses(signatures, options = {})
+        params = [signatures, options]
+        signature_request("getSignatureStatuses", params)
+      end
+
+      def get_signature_status(signature, options = {})
+        signature_status = get_signature_statuses([signature], options)
+        signature_status["value"].first
+      end
+
+      def get_signatures_for_address(address, options = {})
+        params = [address, options]
+        signature_request("getSignaturesForAddress", params)
+      end
+
+      private
+
+      def signature_request(method, params)
+        signatures_info = request(method, params)
+        signatures_info["result"]
+      end
+    end
+  end
+end

data/lib/solana_ruby/http_methods/slot_methods.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module SolanaRuby
+  module HttpMethods
+    # Slot Related HTTP Methods
+    module SlotMethods
+      def get_slot
+        slot_info = request("getSlot")
+        slot_info["result"]
+      end
+
+      def get_slot_leader(options = {})
+        slot_leader = request("getSlotLeader", [options])
+        slot_leader["result"]
+      end
+
+      def get_slot_leaders(start_slot, limit)
+        params = [start_slot, limit]
+        slot_leaders = request("getSlotLeaders", params)
+        slot_leaders["result"]
+      end
+
+      def get_highest_snapshot_slot
+        slot_leaders = request("getHighestSnapshotSlot")
+        slot_leaders["result"]
+      end
+
+      def get_minimum_ledger_slot
+        minimum_ladger_slot = request("minimumLedgerSlot")
+        minimum_ladger_slot["result"]
+      end
+
+      def get_max_retransmit_slot
+        max_retransmit_slot = request("getMaxRetransmitSlot")
+        max_retransmit_slot["result"]
+      end
+
+      def get_max_shred_insert_slot
+        max_shred_insert_slot = request("getMaxShredInsertSlot")
+        max_shred_insert_slot["result"]
+      end
+    end
+  end
+end

data/lib/solana_ruby/http_methods/token_methods.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module SolanaRuby
+  module HttpMethods
+    # Token Related HTTP Methods
+    module TokenMethods
+      FINALIZED_OPTIONS = { commitment: "finalized" }.freeze
+
+      def get_token_balance(pubkey, options = FINALIZED_OPTIONS)
+        balance_info = request("getTokenAccountBalance", [pubkey, options])
+        balance_info["result"]["value"]
+      end
+
+      def get_token_supply(pubkey)
+        balance_info = request("getTokenSupply", [pubkey])
+        balance_info["result"]["value"]
+      end
+
+      def get_token_accounts_by_owner(owner_pubkey, filters = {}, options = {})
+        params = [owner_pubkey, filters, options]
+        response = request("getTokenAccountsByOwner", params)
+        response["result"]
+      end
+
+      def get_token_largest_accounts(mint_pubkey, options = {})
+        params = [mint_pubkey, options]
+        response = request("getTokenLargestAccounts", params)
+        response["result"]
+      end
+    end
+  end
+end

data/lib/solana_ruby/http_methods/transaction_methods.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module SolanaRuby
+  module HttpMethods
+    # Transaction Related HTTP Methods
+    module TransactionMethods
+      DEFAULT_COMMITMENT = "finalized"
+      TIMEOUT = 60 # seconds
+      RETRY_INTERVAL = 2 # seconds
+      ENCODED_TRANSACTION_OPTIONS = { skipPreflight: false }.freeze
+      FINALIZED_OPTIONS = { commitment: "finalized" }.freeze
+
+      def send_transaction(signed_transaction, options = {})
+        params = [signed_transaction, options]
+        result = request("sendTransaction", params)
+        result["result"]
+      end
+
+      def confirm_transaction(signature, commitment = DEFAULT_COMMITMENT, timeout = TIMEOUT)
+        start_time = Time.now
+
+        loop do
+          # Fetch transaction status
+          options = { searchTransactionHistory: true }
+          status_info = get_signature_status(signature, options)
+
+          # Check if the transaction is confirmed based on the commitment level
+          if status_info && (status_info["confirmationStatus"] == commitment || status_info["confirmationStatus"] == "confirmed")
+            return true
+          end
+
+          # Break the loop if timeout is reached
+          if Time.now - start_time > timeout
+            raise "Transaction #{signature} was not confirmed within #{timeout} seconds."
+          end
+
+          sleep(RETRY_INTERVAL)
+        end
+      end
+
+      def get_transaction(signature, options = {})
+        params = [signature, options]
+        response = request("getTransaction", params)
+        response["result"]
+      end
+
+      def get_transaction_count(options = FINALIZED_OPTIONS)
+        result = request("getTransactionCount", [options])
+        result["result"]
+      end
+
+      def get_transactions(signatures, options = FINALIZED_OPTIONS)
+        transactions = []
+        signatures.each do |signature|
+          transaction = get_transaction(signature, options)
+          transactions << transaction
+        end
+        transactions
+      end
+
+      def request_airdrop(pubkey, lamports, options = FINALIZED_OPTIONS)
+        params = [pubkey, lamports, options]
+        response = request("requestAirdrop", params)
+        response["result"]
+      end
+
+      def simulate_transaction(transaction, options = { encoding: "base64" })
+        params = [transaction, options]
+        response = request("simulateTransaction", params)
+        response["result"]
+      end
+
+      def send_encoded_transaction(encoded_transaction, options = ENCODED_TRANSACTION_OPTIONS.merge(FINALIZED_OPTIONS))
+        send_transaction(encoded_transaction, options)
+      end
+
+      def send_raw_transaction(raw_transaction, options = ENCODED_TRANSACTION_OPTIONS.merge(FINALIZED_OPTIONS))
+        # Convert the raw hexadecimal transaction to base64 encoding
+        base64_encoded_transaction = Base64.encode64(raw_transaction)
+
+        send_transaction(base64_encoded_transaction, options)
+      end
+    end
+  end
+end

data/lib/solana_ruby/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module SolanaRuby
+  VERSION = "1.0.1.beta1"
+end