Module: Solana::Ruby::Kit::Rpc::Api::GetTransactionsForAddress

Extended by:
T::Sig
Included in:
Client
Defined in:
lib/solana/ruby/kit/rpc/api/get_transactions_for_address.rb

Overview

Returns confirmed transactions that load the given address, with server-side filtering, sorting, and cursor-based pagination.

This combines the discovery step of getSignaturesForAddress with filtering and pagination the server applies itself. Note: check your RPC provider for support for this method.

Mirrors TypeScript's GetTransactionsForAddressApi.getTransactionsForAddress. See https://solana.com/docs/rpc/http/gettransactionsforaddress

Constant Summary collapse

FILTER_KEYS =

Maps the snake_case keys of a Ruby filters hash onto the wire names. Comparison operators (:eq, :gt, :gte, :lt, :lte) pass through as-is.

T.let(
  {
    block_time:     'blockTime',
    signature:      'signature',
    slot:           'slot',
    status:         'status',
    token_accounts: 'tokenAccounts'
  }.freeze,
  T::Hash[Symbol, String]
)
COMPARISON_KEYS = 
T.let(%i[eq gt gte lt lte].freeze, T::Array[Symbol])

Instance Method Summary collapse

Instance Method Details

#get_transactions_for_address(address, transaction_details: :signatures, encoding: nil, max_supported_transaction_version: nil, commitment: nil, filters: nil, limit: nil, min_context_slot: nil, pagination_token: nil, sort_order: nil) ⇒ Object 



107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
 
# File 'lib/solana/ruby/kit/rpc/api/get_transactions_for_address.rb', line 107

def get_transactions_for_address(
  address,
  transaction_details:               :signatures,
  encoding:                          nil,
  max_supported_transaction_version: nil,
  commitment:                        nil,
  filters:                           nil,
  limit:                             nil,
  min_context_slot:                  nil,
  pagination_token:                  nil,
  sort_order:                        nil
)
  unless %i[signatures full].include?(transaction_details)
    Kernel.raise ArgumentError, "transaction_details must be :signatures or :full, got #{transaction_details.inspect}"
  end

  # The RPC rejects `processed` for this method; TypeScript encodes that
  # as `Exclude<Commitment, 'processed'>`, so fail fast here too.
  if commitment == :processed
    Kernel.raise ArgumentError, 'getTransactionsForAddress does not support the :processed commitment'
  end

  if transaction_details == :signatures
    if encoding
      Kernel.raise ArgumentError, 'encoding is only valid with transaction_details: :full'
    end
    if max_supported_transaction_version
      Kernel.raise ArgumentError, 'max_supported_transaction_version is only valid with transaction_details: :full'
    end
  end

  config = { 'transactionDetails' => transaction_details.to_s }
  config['encoding']                       = encoding if encoding
  config['maxSupportedTransactionVersion'] = max_supported_transaction_version if max_supported_transaction_version
  config['commitment']                     = commitment.to_s if commitment
  config['limit']                          = limit if limit
  config['minContextSlot']                 = min_context_slot if min_context_slot
  config['paginationToken']                = pagination_token if pagination_token
  config['sortOrder']                      = sort_order.to_s if sort_order
  config['filters']                        = build_filters(filters) if filters && !filters.empty?

  raw  = transport.request('getTransactionsForAddress', [address, config])
  rows = raw['data'] || []

  data = if transaction_details == :full
           # Returned verbatim so each element can be fed to
           # TransactionIntrospection.decode_transaction_from_rpc_response.
           rows
         else
           rows.map do |tx|
             TransactionsForAddressSignature.new(
               block_time:          tx['blockTime'],
               confirmation_status: tx['confirmationStatus']&.to_sym,
               err:                 tx['err'],
               memo:                tx['memo'],
               signature:           tx['signature'],
               slot:                Kernel.Integer(tx['slot']),
               transaction_index:   tx['transactionIndex'] && Kernel.Integer(tx['transactionIndex'])
             )
           end
         end

  TransactionsForAddressPage.new(data: data, pagination_token: raw['paginationToken'])
end