Class: Solace::Connection

Inherits:
Object
  • Object
show all
Defined in:
lib/solace/connection.rb

Overview

Connection to a Solana RPC node

This class provides methods for sending JSON-RPC requests to a Solana RPC node and parsing responses. It includes methods for sending transactions, getting account information, and getting blockhashes.

] rubocop:disable Metrics/ClassLength

Examples:

# Initialize the connection
connection = Solace::Connection.new('http://localhost:8899', commitment: 'confirmed')

# Get account information
connection.(.address)

# Request an airdrop
result = connection.request_airdrop(.address, 1000000)

# Wait for the transaction to be finalized
connection.wait_for_confirmed_signature('finalized') { result['result'] }

Raises:

Since:

  • 0.0.1

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(rpc_url = 'http://localhost:8899', commitment: 'processed', http_open_timeout: 30, http_read_timeout: 60, encoding: 'base64') ⇒ Solace::Connection

Initialize the connection with a default or custom RPC URL

Parameters:

  • rpc_url (String) (defaults to: 'http://localhost:8899') —

    The URL of the Solana RPC node

  • commitment (String) (defaults to: 'processed') —

    The commitment level for RPC requests

  • http_open_timeout (Integer) (defaults to: 30) —

    The timeout for opening an HTTP connection

  • http_read_timeout (Integer) (defaults to: 60) —

    The timeout for reading an HTTP response

  • encoding (String) (defaults to: 'base64') —

    The encoding for the RPC requests

Since:

  • 0.0.1



60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
 
# File 'lib/solace/connection.rb', line 60

def initialize(
  rpc_url = 'http://localhost:8899',
  commitment: 'processed',
  http_open_timeout: 30,
  http_read_timeout: 60,
  encoding: 'base64'
)
  # Initialize the RPC client
  @rpc_client = Utils::RPCClient.new(
    rpc_url,
    open_timeout: http_open_timeout,
    read_timeout: http_read_timeout
  )

  # Set default options for rpc requests
  @default_options = {
    commitment: commitment,
    encoding:   encoding
  }
end

Instance Attribute Details

#default_options ⇒ Object (readonly)

Since:

  • 0.0.1



44
45
46
 
# File 'lib/solace/connection.rb', line 44

def default_options
  @default_options
end

#last_fetched_block_height ⇒ Object (readonly)

Last fetched blockhash timestamp

Since:

  • 0.0.1



50
51
52
 
# File 'lib/solace/connection.rb', line 50

def last_fetched_block_height
  @last_fetched_block_height
end

#last_fetched_blockhash ⇒ Object (readonly)

Last fetched blockhash

Since:

  • 0.0.1



47
48
49
 
# File 'lib/solace/connection.rb', line 47

def last_fetched_blockhash
  @last_fetched_blockhash
end

#rpc_client ⇒ Object (readonly)

Since:

  • 0.0.1



40
41
42
 
# File 'lib/solace/connection.rb', line 40

def rpc_client
  @rpc_client
end

#rpc_url ⇒ Object (readonly)

The URL of the Solana RPC node



40
 
# File 'lib/solace/connection.rb', line 40

attr_reader :rpc_client

Instance Method Details

#build_get_latest_blockhash_options ⇒ Hash{Symbol => Object}

Build options for get_latest_blockhash

Returns:

  • (Hash{Symbol => Object})

Since:

  • 0.0.1



122
123
124
125
126
 
# File 'lib/solace/connection.rb', line 122

def build_get_latest_blockhash_options
  {
    commitment: default_options[:commitment]
  }
end

#build_send_transaction_options(overrides) ⇒ Hash

Builds send_transaction options

Parameters:

  • overrides (Hash) —

    The overrides for the options

Returns:

  • (Hash) —

    The options for the send_transaction call

Since:

  • 0.0.1



278
279
280
281
282
283
284
285
 
# File 'lib/solace/connection.rb', line 278

def build_send_transaction_options(overrides)
  {
    skipPreflight:       false,
    encoding:            default_options[:encoding],
    commitment:          default_options[:commitment],
    preflightCommitment: default_options[:commitment]
  }.merge(overrides)
end

#get_account_info(pubkey) ⇒ Object

Get the account information from the Solana node

Parameters:

  • pubkey (String) —

    The public key of the account

Returns:

  • (Object) —

    The account information

Since:

  • 0.0.1



183
184
185
 
# File 'lib/solace/connection.rb', line 183

def (pubkey)
  @rpc_client.rpc_request('getAccountInfo', [pubkey, default_options]).dig('result', 'value')
end

#get_balance(pubkey) ⇒ Integer

Get the balance of a specific account

Parameters:

  • pubkey (String) —

    The public key of the account

Returns:

  • (Integer) —

    The balance of the account

Since:

  • 0.0.1



199
200
201
 
# File 'lib/solace/connection.rb', line 199

def get_balance(pubkey)
  @rpc_client.rpc_request('getBalance', [pubkey, default_options]).dig('result', 'value')
end

#get_block_height(commitment: ) ⇒ Integer

Get the current block height from the Solana node

Defaults to the connection's commitment so comparisons against the lastValidBlockHeight from #get_latest_blockhash stay consistent.

Parameters:

  • commitment (String) (defaults to: ) —

    The commitment level for the request

Returns:

  • (Integer) —

    The current block height

Since:

  • 0.0.1



167
168
169
 
# File 'lib/solace/connection.rb', line 167

def get_block_height(commitment: default_options[:commitment])
  @rpc_client.rpc_request('getBlockHeight', [{ commitment: commitment }])['result']
end

#get_genesis_hash ⇒ String

Get the genesis hash of the Solana node

Returns:

  • (String) —

    The genesis hash

Since:

  • 0.0.1



98
99
100
 
# File 'lib/solace/connection.rb', line 98

def get_genesis_hash
  @rpc_client.rpc_request('getGenesisHash')['result']
end

#get_health ⇒ String

Get the health status of the Solana node

Returns:

  • (String) —

    The health status

Since:

  • 0.0.1



91
92
93
 
# File 'lib/solace/connection.rb', line 91

def get_health
  @rpc_client.rpc_request('getHealth')['result']
end

#get_latest_blockhash ⇒ Array<String, Integer>

Get the latest blockhash from the Solana node

Stores the last fetched blockhash and last valid block height in the connection, as different clients may need to access these values.

Examples:

# Initialize the connection
connection = Solace::Connection.new('http://localhost:8899', commitment: 'confirmed')

# Get the latest blockhash
blockhash, last_valid_block_height = connection.get_latest_blockhash

puts "Latest blockhash: #{blockhash}"
puts "Last valid block height: #{last_valid_block_height}"

# Access the last fetched blockhash and height from the connection
puts "Stored blockhash: #{connection.last_fetched_blockhash}"
puts "Stored last valid block height: #{connection.last_fetched_block_height}"

Returns:

  • (Array<String, Integer>) —

    The latest blockhash and lastValidBlockHeight

Since:

  • 0.0.1



148
149
150
151
152
153
154
155
156
157
158
 
# File 'lib/solace/connection.rb', line 148

def get_latest_blockhash
  result = @rpc_client
           .rpc_request('getLatestBlockhash', [build_get_latest_blockhash_options])
           .dig('result', 'value')

  # Set the last fetched blockhash and last valid block height in the connection
  @last_fetched_blockhash, @last_fetched_block_height = result.values_at('blockhash', 'lastValidBlockHeight')

  # Return the blockhash and last valid block height
  [@last_fetched_blockhash, @last_fetched_block_height]
end

#get_minimum_lamports_for_rent_exemption(space) ⇒ Integer

Get the minimum required lamports for rent exemption

Parameters:

  • space (Integer) —

    Number of bytes to allocate for the account

Returns:

  • (Integer) —

    The minimum required lamports

Since:

  • 0.0.1



175
176
177
 
# File 'lib/solace/connection.rb', line 175

def get_minimum_lamports_for_rent_exemption(space)
  @rpc_client.rpc_request('getMinimumBalanceForRentExemption', [space])['result']
end

#get_mint_program_id(mint) ⇒ String?

Discovery-only helper: returns the program ID that owns a given mint.

Use this to dispatch between Solace::Constants::TOKEN_PROGRAM_ID and Solace::Constants::TOKEN_2022_PROGRAM_ID when the mint's program is not known ahead of time. If you also need the rest of the mint's account data (decimals, supply, ...), call #get_account_info directly and read 'owner' yourself — calling both would cost two RPC roundtrips.

Parameters:

  • mint (String) —

    The mint address

Returns:

  • (String, nil) —

    The program ID that owns the mint, or nil if the account does not exist

Since:

  • 0.0.1



234
235
236
 
# File 'lib/solace/connection.rb', line 234

def get_mint_program_id(mint)
  (mint)&.dig('owner')
end

#get_multiple_accounts(pubkeys) ⇒ Array<Object>

Get multiple accounts information from the Solana node

Parameters:

  • pubkeys (Array<String>) —

    The public keys of the accounts

Returns:

  • (Array<Object>) —

    The accounts information

Since:

  • 0.0.1



191
192
193
 
# File 'lib/solace/connection.rb', line 191

def get_multiple_accounts(pubkeys)
  @rpc_client.rpc_request('getMultipleAccounts', [pubkeys, default_options]).dig('result', 'value')
end

#get_program_accounts(program_id, filters) ⇒ Array

Get the program accounts

Parameters:

  • program_id (String) —

    The program ID

  • filters (Array) —

    The filters

  • options (Hash{Symbol => Object})

Returns:

  • (Array) —

    The program accounts

Since:

  • 0.0.1



262
263
264
 
# File 'lib/solace/connection.rb', line 262

def get_program_accounts(program_id, filters)
  @rpc_client.rpc_request('getProgramAccounts', [program_id, default_options.merge(filters: filters)])['result']
end

#get_signature_status(signature) ⇒ Object

Get the signature status

Parameters:

  • signature (String) —

    The signature of the transaction

Returns:

  • (Object) —

    The signature status

Since:

  • 0.0.1



270
271
272
 
# File 'lib/solace/connection.rb', line 270

def get_signature_status(signature)
  get_signature_statuses([signature])
end

#get_signature_statuses(signatures) ⇒ Object

Get the signature status

Parameters:

  • signatures (Array) —

    The signatures of the transactions

Returns:

  • (Object) —

    The signature status

Since:

  • 0.0.1



251
252
253
254
 
# File 'lib/solace/connection.rb', line 251

def get_signature_statuses(signatures)
  @rpc_client.rpc_request('getSignatureStatuses',
                          [signatures, default_options.merge({ 'searchTransactionHistory' => true })])['result']
end

#get_token_account_balance(token_account) ⇒ Hash

Get the balance of a token account

Parameters:

  • token_account (String) —

    The public key of the token account

Returns:

  • (Hash) —

    Token account balance information with amount and decimals

Since:

  • 0.0.1



207
208
209
 
# File 'lib/solace/connection.rb', line 207

def ()
  @rpc_client.rpc_request('getTokenAccountBalance', [, default_options]).dig('result', 'value')
end

#get_token_accounts_by_owner(owner, token_program_id: Constants::TOKEN_PROGRAM_ID) ⇒ Array<Hash>

Gets the token accounts by owner.

Defaults to the legacy SPL Token program; pass token_program_id: Solace::Constants::TOKEN_2022_PROGRAM_ID for Token-2022.

Parameters:

  • owner (String) —

    The public key of the owner

  • token_program_id (String) (defaults to: Constants::TOKEN_PROGRAM_ID) —

    The token program to filter by (defaults to legacy SPL Token)

Returns:

  • (Array<Hash>) —

    The token accounts owned by the owner under the given token program

Since:

  • 0.0.1



219
220
221
222
 
# File 'lib/solace/connection.rb', line 219

def get_token_accounts_by_owner(owner, token_program_id: Constants::TOKEN_PROGRAM_ID)
  params = [owner, { programId: token_program_id }, default_options]
  @rpc_client.rpc_request('getTokenAccountsByOwner', params).dig('result', 'value')
end

#get_transaction(signature, options = { maxSupportedTransactionVersion: 0 }) ⇒ Transaction

Get the transaction by signature

Parameters:

  • signature (String) —

    The signature of the transaction

  • options (Hash{Symbol => Object}) (defaults to: { maxSupportedTransactionVersion: 0 })

Returns:

Since:

  • 0.0.1



243
244
245
 
# File 'lib/solace/connection.rb', line 243

def get_transaction(signature, options = { maxSupportedTransactionVersion: 0 })
  @rpc_client.rpc_request('getTransaction', [signature, default_options.merge(options)])['result']
end

#get_version ⇒ Hash

Gets the version of the Solana node

Returns:

  • (Hash) —

    The version information

Since:

  • 0.0.1



84
85
86
 
# File 'lib/solace/connection.rb', line 84

def get_version
  @rpc_client.rpc_request('getVersion')['result']
end

#request_airdrop(pubkey, lamports, options = {}) ⇒ String

Request an airdrop of lamports to a given address

Parameters:

  • pubkey (String) —

    The public key of the account to receive the airdrop

  • lamports (Integer) —

    Amount of lamports to airdrop

  • options (Hash{Symbol => Object}) (defaults to: {}) —

    The options for the request

Returns:

  • (String) —

    The transaction signature of the airdrop

Since:

  • 0.0.1



108
109
110
111
112
113
114
115
116
117
 
# File 'lib/solace/connection.rb', line 108

def request_airdrop(pubkey, lamports, options = {})
  @rpc_client.rpc_request(
    'requestAirdrop',
    [
      pubkey,
      lamports,
      default_options.merge(options)
    ]
  )
end

#send_transaction(transaction, overrides = {}) ⇒ String

Send a transaction to the Solana node

Parameters:

  • transaction (Transaction) —

    The transaction to send

  • overrides (Hash{Symbol => Object}) (defaults to: {})

Returns:

  • (String) —

    The signature of the transaction

Since:

  • 0.0.1



292
293
294
 
# File 'lib/solace/connection.rb', line 292

def send_transaction(transaction, overrides = {})
  @rpc_client.rpc_request('sendTransaction', [transaction, build_send_transaction_options(overrides)])
end

#simulate_transaction(transaction, overrides = {}) ⇒ Object

Simulate a transaction on the Solana node

Parameters:

  • transaction (Transaction) —

    The transaction to simulate

  • overrides (Hash{Symbol => Object}) (defaults to: {})

Returns:

  • (Object) —

    The result of the simulation

Since:

  • 0.0.1



301
302
303
 
# File 'lib/solace/connection.rb', line 301

def simulate_transaction(transaction, overrides = {})
  @rpc_client.rpc_request('simulateTransaction', [transaction, build_send_transaction_options(overrides)])
end

#wait_for_confirmed_signature(commitment = 'confirmed', timeout: 60, interval: 0.1) ⇒ String

Wait until the yielded signature reaches the desired commitment or timeout.

Parameters:

  • commitment (String) (defaults to: 'confirmed') —

    One of "processed", "confirmed", "finalized"

  • timeout (Numeric) (defaults to: 60) —

    seconds to wait before raising

  • interval (Numeric) (defaults to: 0.1) —

    polling interval in seconds

Yield Returns:

  • (String, Hash) —

    a signature string or a JSON-RPC hash with "result"

Returns:

  • (String) —

    the signature when the commitment is reached

Raises:

Since:

  • 0.0.1



313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
 
# File 'lib/solace/connection.rb', line 313

def wait_for_confirmed_signature(
  commitment = 'confirmed',
  timeout: 60,
  interval: 0.1
)
  raise ArgumentError, 'Block required' unless block_given?

  signature = extract_signature_from(yield)
  deadline  = monotonic_deadline(timeout)

  # Wait for confirmation
  until deadline_passed?(deadline)
    return signature if commitment_reached?(signature, commitment)

    sleep interval
  end

  raise Errors::ConfirmationTimeout.format(signature, commitment, timeout)
end