solace 0.1.7 → 0.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ab3415933c7875971ad410ecc1d8d7487233a7eb58e9c3701f23babdaae9fbd5
-  data.tar.gz: a9ef2bbb03d7988487ae48bff51122dc45670e5ad6ef8c8d6154fa386d0a1281
+  metadata.gz: 2f6a793f450df697c4f216ab4e5a483d7a331f57a3fccb05ecd7c76e788fa4ed
+  data.tar.gz: 479fcb0c38b8e5ea8d82636922ab327ec68ae18455550658c79b06ddd11b2bbd
 SHA512:
-  metadata.gz: 869108bf70f8a9143e28dae425a5e843135aedfd78642c39683fd214ab4a3d1c847125e0e2f0fc60b1766ac45970dc8f14bfc512861db95b89cdaaedc593226d
-  data.tar.gz: 8ff9bcac1403007eb3dcc340587c76f4acb5dff266390621f16708589153644db16a16cdb0f08936f3d3a690c2943d78edd570735e9f0692eac6ffb62ee3c969
+  metadata.gz: ec35bdf08bf2ecdd235d25ec67f9c897a7a5c0a167c46d3f2dea8cfb21600b7c3523e236f9db644638fdb2aadd3b219a67296676d580d3ce2ef2ad1a9c8ebe00
+  data.tar.gz: 9647d86486a247042220f53b621591e2de5599868bb154350eb367a4d523301c60ac1735cc664c46ebb18e181f7095c9972748257d25373863d81c520ab7ba3a

data/lib/rubocop/cop/solace/exploded_hash.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Solace
+      # Every pair in a braced hash starts on its own line.
+      #
+      # A hash is read as a table: a reader scanning for one key, or diffing two
+      # of them, works down the left edge. Collapsing pairs onto a shared line
+      # hides a key mid-line and makes a one-key change show up as a rewritten
+      # line. Length is not the test — a short hash collapses just as badly as a
+      # long one, which is why the built-in layout cops are not enough: they only
+      # act once a hash is already multi-line.
+      #
+      # Only a hash written on one line is this cop's business. Once a hash spans
+      # lines, Layout/FirstHashElementLineBreak and Layout/MultilineHashKeyLineBreaks
+      # already break every pair onto its own line, and a second cop inserting the
+      # same break in the same correction loop leaves a blank line behind.
+      #
+      # Two more restrictions keep it from reaching where it does not belong. A
+      # hash of one pair is left inline, since it is already the only thing on
+      # its line. And only BRACED hashes are checked: a keyword argument list is
+      # a hash node too, and exploding it would break up every multi-argument
+      # call in the codebase.
+      #
+      # @example
+      #   # bad
+      #   page_id: { type: 'string', format: 'uuid' }
+      #
+      #   # good
+      #   page_id: {
+      #     type: 'string',
+      #     format: 'uuid'
+      #   }
+      #
+      #   # good — one pair, and a keyword argument list
+      #   { user: payload[:user_id] }
+      #   create(:user, name: 'Ada', email: 'ada@example.com')
+      class ExplodedHash < Base
+        extend AutoCorrector
+
+        MSG = 'Each pair in a hash starts on its own line.'
+
+        def on_hash(node)
+          pairs = braced_pairs(node)
+          return unless pairs
+
+          pairs.each { |pair| flag(pair) }
+        end
+
+        private
+
+        # Nil for anything this cop leaves alone: a hash already spanning lines,
+        # a keyword argument list, which carries no braces, and a hash of a
+        # single pair.
+        def braced_pairs(node)
+          return unless node.loc.begin
+          return if node.multiline?
+
+          pairs = node.pairs
+          pairs if pairs.size >= 2
+        end
+
+        # The break replaces the space in front of the pair rather than being
+        # inserted before it, or the old separator is left behind as trailing
+        # whitespace. Indentation is left to Layout/FirstHashElementIndentation
+        # and Layout/HashAlignment, which run in the same correction loop.
+        def flag(pair)
+          add_offense(pair) { |corrector| corrector.replace(leading_space(pair), "\n") }
+        end
+
+        def leading_space(pair)
+          range  = pair.source_range
+          source = range.source_buffer.source
+          start  = range.begin_pos
+          start -= 1 while start.positive? && [' ', "\t"].include?(source[start - 1])
+          Parser::Source::Range.new(range.source_buffer, start, range.begin_pos)
+        end
+      end
+    end
+  end
+end

data/lib/solace/accounts/address_lookup_table.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+module Solace
+  # On-chain account models — the account state living at an address, as opposed
+  # to the wire-level structures that reference it. Conventions for these types
+  # (fetching, deserializing, deriving) are expected to grow here.
+  module Accounts
+    # Models an on-chain Address Lookup Table account: its address, the metadata
+    # the program stores (authority, activation slots), and the full, ordered
+    # list of addresses it holds.
+    #
+    # This is distinct from {Solace::AddressLookupTable}, which is the *reference*
+    # a v0 message carries (a table account plus the writable/readonly index
+    # positions into it). A composer decides which of this account's addresses
+    # load — a v0 concern that needs the account context — and this object owns
+    # the table-local part: turning the addresses it contributes into that
+    # message reference.
+    #
+    # @example Register a table on a composer
+    #   table = Solace::Accounts::AddressLookupTable.new(account: address, addresses: on_chain_addresses)
+    #   table.reference(loaded_writable, loaded_readonly) # => Solace::AddressLookupTable or nil
+    #
+    # @example Read a table's on-chain state
+    #   table = Solace::Accounts::AddressLookupTable.fetch(address, connection: connection)
+    #   table&.addresses # => the stored addresses, or nil if the chain holds no such account
+    #
+    # @see Solace::AddressLookupTable
+    # @see Solace::TransactionComposer
+    # @since 0.1.8
+    class AddressLookupTable
+      # Byte offset at which the stored addresses begin — the program reserves a
+      # fixed-size metadata region ahead of them regardless of its contents.
+      META_SIZE = 56
+
+      # @!attribute [r] account
+      #   @return [String, nil] The lookup table's on-chain address
+      attr_reader :account
+
+      # @!attribute [r] addresses
+      #   @return [Array<String>] The full, ordered list of addresses stored in the table
+      attr_reader :addresses
+
+      # @!attribute [r] authority
+      #   @return [String, nil] The authority allowed to extend/close the table
+      attr_reader :authority
+
+      # @!attribute [r] deactivation_slot
+      #   @return [Integer, nil] The slot the table was deactivated in (max while active)
+      attr_reader :deactivation_slot
+
+      # @!attribute [r] last_extended_slot
+      #   @return [Integer, nil] The slot the table was last extended in
+      attr_reader :last_extended_slot
+
+      class << self
+        # Fetch a lookup table account from chain
+        #
+        # Like {Solace::Connection#get_account_info}, answers nil when the chain
+        # holds no account at the address; the caller decides whether that is an error.
+        #
+        # @param account [#to_s, PublicKey] The lookup table's on-chain address
+        # @param connection [Solace::Connection] The connection to read it through
+        # @return [AddressLookupTable, nil] The table with its address set, or nil
+        def fetch(account, connection:)
+          info = connection.get_account_info(account.to_s)
+          return unless info
+
+          base64, = info['data'] # the RPC answers [data, encoding]
+          deserialize(Utils::Codecs.base64_to_bytestream(base64), account: account)
+        end
+
+        # Deserialize an on-chain lookup table account
+        #
+        # The BufferLayout is:
+        #   - [State type (4 bytes, u32 LE)]
+        #   - [Deactivation slot (8 bytes, u64 LE)]
+        #   - [Last extended slot (8 bytes, u64 LE)]
+        #   - [Last extended start index (1 byte)]
+        #   - [Authority (Borsh Option<Pubkey>)]
+        #   - [Padding, up to {META_SIZE}]
+        #   - [Addresses (32 bytes each, to end of data)]
+        #
+        # The account data does not carry its own address, so pass it to have
+        # the table know where it lives.
+        #
+        # @param io [IO, StringIO] The account data to read from
+        # @param account [#to_s, PublicKey, nil] The lookup table's on-chain address
+        # @return [AddressLookupTable] The parsed table
+        def deserialize(io, account: nil)
+          Utils::Codecs.decode_le_u32(io) # state type (1 = lookup table); positional
+          deactivation_slot  = Utils::Codecs.decode_le_u64(io)
+          last_extended_slot = Utils::Codecs.decode_le_u64(io)
+
+          Utils::Codecs.decode_u8(io) # last extended start index; positional
+          authority = Utils::Codecs.decode_option_pubkey(io)
+
+          io.seek(META_SIZE) # addresses begin after the fixed-size metadata region
+
+          addresses = []
+          addresses << Utils::Codecs.decode_pubkey(io) until io.eof?
+
+          new(
+            account:            account,
+            deactivation_slot:  deactivation_slot,
+            last_extended_slot: last_extended_slot,
+            authority:          authority,
+            addresses:          addresses
+          )
+        end
+      end
+
+      # Initialize a lookup table account
+      #
+      # @param account [#to_s, PublicKey, nil] The lookup table's on-chain address
+      # @param addresses [Array<#to_s>, nil] The full, ordered address list; may be
+      #   omitted (the composer then loads nothing through this table)
+      # @param authority [String, nil] The table authority
+      # @param deactivation_slot [Integer, nil] The deactivation slot
+      # @param last_extended_slot [Integer, nil] The last extended slot
+      def initialize(account: nil, addresses: nil, authority: nil, deactivation_slot: nil, last_extended_slot: nil)
+        @account            = account&.to_s
+        @addresses          = Array(addresses).map(&:to_s)
+        @authority          = authority
+        @deactivation_slot  = deactivation_slot
+        @last_extended_slot = last_extended_slot
+      end
+
+      # Build the v0 message reference for the addresses this table contributes
+      #
+      # @param writable [Array<String>] Loaded writable pubkeys drawn from this table
+      # @param readonly [Array<String>] Loaded readonly pubkeys drawn from this table
+      # @return [Solace::AddressLookupTable, nil] The reference, or nil if it loads nothing
+      def reference(writable, readonly)
+        writable_indexes = positions_of(writable)
+        readonly_indexes = positions_of(readonly)
+        return if writable_indexes.empty? && readonly_indexes.empty?
+
+        Solace::AddressLookupTable.new.tap do |reference|
+          reference.account          = account
+          reference.writable_indexes = writable_indexes
+          reference.readonly_indexes = readonly_indexes
+        end
+      end
+
+      private
+
+      # Positions of the given pubkeys within this table's address list
+      #
+      # @param pubkeys [Array<String>] The pubkeys to locate
+      # @return [Array<Integer>] Their positions in {#addresses}
+      def positions_of(pubkeys)
+        pubkeys.filter_map { |pubkey| addresses.index(pubkey) }
+      end
+    end
+  end
+end

data/lib/solace/composers/address_lookup_table_program_create_composer.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Solace
+  module Composers
+    # Composer for creating an address lookup table.
+    #
+    # Resolves and orders the accounts for a `CreateLookupTable` instruction and
+    # delegates construction to
+    # `Instructions::AddressLookupTableProgram::CreateLookupTableInstruction`.
+    #
+    # The table address is a program-derived address of `[authority, recent_slot]`;
+    # derive it (and its bump) with {Solace::Utils::PDA} and pass both in.
+    #
+    # Required accounts:
+    # - **Table**: the uninitialized table account (writable, non-signer)
+    # - **Authority**: controls the table (readonly, signer)
+    # - **Payer**: funds the table's rent (writable, signer)
+    # - **System program** (readonly, non-signer)
+    #
+    # @example
+    #   composer = AddressLookupTableProgramCreateComposer.new(
+    #     table:       table_address,
+    #     authority:   authority,
+    #     payer:       payer,
+    #     recent_slot: recent_slot,
+    #     bump:        bump
+    #   )
+    #
+    # @see Instructions::AddressLookupTableProgram::CreateLookupTableInstruction
+    # @since 0.1.8
+    class AddressLookupTableProgramCreateComposer < Base
+      # @return [String] The table's on-chain address
+      def table
+        params[:table].to_s
+      end
+
+      # @return [String] The table authority
+      def authority
+        params[:authority].to_s
+      end
+
+      # @return [String] The rent payer
+      def payer
+        params[:payer].to_s
+      end
+
+      # @return [String] The system program id
+      def system_program
+        Solace::Constants::SYSTEM_PROGRAM_ID.to_s
+      end
+
+      # @return [String] The address lookup table program id
+      def lookup_table_program
+        Solace::Constants::ADDRESS_LOOKUP_TABLE_PROGRAM_ID.to_s
+      end
+
+      # @return [Integer] The slot used to derive the table address
+      def recent_slot
+        params[:recent_slot]
+      end
+
+      # @return [Integer] The bump seed for the table's program-derived address
+      def bump
+        params[:bump]
+      end
+
+      # Setup accounts required for the create lookup table instruction
+      #
+      # @return [void]
+      def setup_accounts
+        account_context.add_writable_nonsigner(table)
+        account_context.add_readonly_signer(authority)
+        account_context.add_writable_signer(payer)
+        account_context.add_readonly_nonsigner(system_program)
+        account_context.add_readonly_nonsigner(lookup_table_program)
+      end
+
+      # Build instruction with resolved account indices
+      #
+      # @param account_context [Utils::AccountContext] The account context
+      # @return [Solace::Instruction]
+      def build_instruction(account_context)
+        Solace::Instructions::AddressLookupTableProgram::CreateLookupTableInstruction.build(
+          recent_slot:          recent_slot,
+          bump:                 bump,
+          program_index:        account_context.index_of(lookup_table_program),
+          table_index:          account_context.index_of(table),
+          authority_index:      account_context.index_of(authority),
+          payer_index:          account_context.index_of(payer),
+          system_program_index: account_context.index_of(system_program)
+        )
+      end
+    end
+  end
+end

data/lib/solace/composers/address_lookup_table_program_extend_composer.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Solace
+  module Composers
+    # Composer for extending an address lookup table with new addresses.
+    #
+    # Resolves and orders the accounts for an `ExtendLookupTable` instruction and
+    # delegates construction to
+    # `Instructions::AddressLookupTableProgram::ExtendLookupTableInstruction`.
+    #
+    # Addresses appended here become usable one slot after the extend lands.
+    #
+    # Required accounts:
+    # - **Table**: the table account being extended (writable, non-signer)
+    # - **Authority**: controls the table (readonly, signer)
+    # - **Payer**: funds any additional rent (writable, signer)
+    # - **System program** (readonly, non-signer)
+    #
+    # @example
+    #   composer = AddressLookupTableProgramExtendComposer.new(
+    #     table:     table_address,
+    #     authority: authority,
+    #     payer:     payer,
+    #     addresses: [recipient1, recipient2]
+    #   )
+    #
+    # @see Instructions::AddressLookupTableProgram::ExtendLookupTableInstruction
+    # @since 0.1.8
+    class AddressLookupTableProgramExtendComposer < Base
+      # @return [String] The table's on-chain address
+      def table
+        params[:table].to_s
+      end
+
+      # @return [String] The table authority
+      def authority
+        params[:authority].to_s
+      end
+
+      # @return [String] The rent payer
+      def payer
+        params[:payer].to_s
+      end
+
+      # @return [String] The system program id
+      def system_program
+        Solace::Constants::SYSTEM_PROGRAM_ID.to_s
+      end
+
+      # @return [String] The address lookup table program id
+      def lookup_table_program
+        Solace::Constants::ADDRESS_LOOKUP_TABLE_PROGRAM_ID.to_s
+      end
+
+      # @return [Array<String>] The addresses to append to the table
+      def addresses
+        params[:addresses].map(&:to_s)
+      end
+
+      # Setup accounts required for the extend lookup table instruction
+      #
+      # @return [void]
+      def setup_accounts
+        account_context.add_writable_nonsigner(table)
+        account_context.add_readonly_signer(authority)
+        account_context.add_writable_signer(payer)
+        account_context.add_readonly_nonsigner(system_program)
+        account_context.add_readonly_nonsigner(lookup_table_program)
+      end
+
+      # Build instruction with resolved account indices
+      #
+      # @param account_context [Utils::AccountContext] The account context
+      # @return [Solace::Instruction]
+      def build_instruction(account_context)
+        Solace::Instructions::AddressLookupTableProgram::ExtendLookupTableInstruction.build(
+          addresses:            addresses,
+          program_index:        account_context.index_of(lookup_table_program),
+          table_index:          account_context.index_of(table),
+          authority_index:      account_context.index_of(authority),
+          payer_index:          account_context.index_of(payer),
+          system_program_index: account_context.index_of(system_program)
+        )
+      end
+    end
+  end
+end

data/lib/solace/composers/opaque_instruction_composer.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Solace
+  module Composers
+    # Composer for an instruction it does not interpret.
+    #
+    # Where every other composer derives its accounts' roles from domain
+    # arguments, this one is handed the program id, the accounts in order, the
+    # data, and an {Utils::AccountContext} declaring each account's role, and
+    # rebuilds the instruction by index against whatever context it is
+    # composed into. It is what {Solace::TransactionDecomposer} answers for
+    # each instruction of a transaction taken apart, and what a caller reaches
+    # for to rebuild one of those with an account swapped out.
+    #
+    # @example Rebuild a recovered instruction with a different rent payer
+    #   roles = Solace::Utils::AccountContext.new
+    #   roles.merge_from(recovered.account_context)
+    #   roles.add_writable_signer(sponsor)
+    #
+    #   composer = Solace::Composers::OpaqueInstructionComposer.new(
+    #     program_id: recovered.program_id,
+    #     accounts:   [sponsor, *recovered.accounts.drop(1)],
+    #     data:       recovered.data,
+    #     roles:      roles
+    #   )
+    #
+    # @since 0.1.9
+    class OpaqueInstructionComposer < Base
+      # The program the instruction invokes
+      #
+      # @return [String] The program id
+      def program_id
+        params[:program_id].to_s
+      end
+
+      # The accounts the instruction touches, in order
+      #
+      # @return [Array<String>] The pubkeys
+      def accounts
+        @accounts ||= params[:accounts].map(&:to_s)
+      end
+
+      # The instruction data, untouched
+      #
+      # @return [Array<Integer>] The data bytes
+      def data
+        params[:data]
+      end
+
+      # The context declaring each account's role
+      #
+      # @return [Utils::AccountContext]
+      def roles
+        params[:roles]
+      end
+
+      # Declare every account with the role given for it, plus the program
+      #
+      # @return [void]
+      # @raise [ArgumentError] When an account has no role declared
+      def setup_accounts
+        accounts.each do |pubkey|
+          raise ArgumentError, "No role declared for account #{pubkey}" unless roles.pubkey_account_map.key?(pubkey)
+
+          account_context.merge_account(pubkey, signer: roles.signer?(pubkey), writable: roles.writable?(pubkey))
+        end
+
+        account_context.add_readonly_nonsigner(program_id)
+      end
+
+      # Build the instruction with indices resolved against the given context
+      #
+      # @param account_context [Utils::AccountContext] The account context
+      # @return [Solace::Instruction]
+      def build_instruction(account_context)
+        Solace::Instruction.new.tap do |instruction|
+          instruction.program_index = account_context.index_of(program_id)
+          instruction.accounts      = accounts.map { |pubkey| account_context.index_of(pubkey) }
+          instruction.data          = data
+        end
+      end
+    end
+  end
+end

data/lib/solace/connection.rb

@@ -168,6 +168,16 @@ module Solace
       @rpc_client.rpc_request('getBlockHeight', [{ commitment: commitment }])['result']
     end
 
+    # Get the current slot from the Solana node
+    #
+    # @param commitment [String] The commitment level for the request
+    # @return [Integer] The current slot
+    #
+    # @since 0.1.8
+    def get_slot(commitment: default_options[:commitment])
+      @rpc_client.rpc_request('getSlot', [{ commitment: commitment }])['result']
+    end
+
     # Get the minimum required lamports for rent exemption
     #
     # @param space [Integer] Number of bytes to allocate for the account

data/lib/solace/errors/address_lookup_table_not_found.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Solace
+  module Errors
+    # Raised when an address lookup table a transaction references does not
+    # exist on chain. A message that loads addresses through a table cannot be
+    # taken apart without the table's address list, so a missing table is an
+    # error rather than an empty list.
+    #
+    # @example
+    #   begin
+    #     Solace::TransactionDecomposer.new(connection: connection).decompose_transaction(transaction)
+    #   rescue Solace::Errors::AddressLookupTableNotFound => e
+    #     puts "missing table: #{e.account}"
+    #   end
+    #
+    # @since 0.1.9
+    class AddressLookupTableNotFound < Error
+      # @return [String] The lookup table's on-chain address
+      attr_reader :account
+
+      # @param account [String] The lookup table's on-chain address
+      def initialize(account)
+        super("address lookup table #{account} not found on chain")
+        @account = account
+      end
+    end
+  end
+end

data/lib/solace/errors/rpc_error.rb

@@ -47,7 +47,13 @@ module Solace
       end
 
       # @return [Hash] The error as a hash
-      def to_h = { code: rpc_code, message: rpc_message, data: rpc_data }
+      def to_h
+        {
+          code:    rpc_code,
+          message: rpc_message,
+          data:    rpc_data
+        }
+      end
     end
   end
 end

data/lib/solace/errors.rb

@@ -21,5 +21,6 @@ module Solace
     require 'solace/errors/http_error'
     require 'solace/errors/parse_error'
     require 'solace/errors/confirmation_timeout'
+    require 'solace/errors/address_lookup_table_not_found'
   end
 end

data/lib/solace/instructions/address_lookup_table_program/create_lookup_table_instruction.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Solace
+  module Instructions
+    # The AddressLookupTableProgram module contains instruction builders for the
+    # Address Lookup Table program.
+    #
+    # Address lookup tables let a versioned (v0) transaction reference accounts by
+    # a compact table index instead of a full 32-byte key, so a single transaction
+    # can touch far more accounts than the legacy format allows.
+    #
+    # @see https://docs.solana.com/developing/lookup-tables
+    # @since 0.1.8
+    module AddressLookupTableProgram
+      # Instruction for creating a new (uninitialized) address lookup table.
+      #
+      # The table's address is a program-derived address of `[authority, recent_slot]`;
+      # the caller supplies the derived address and its bump seed.
+      #
+      # @example Build a CreateLookupTable instruction
+      #   instruction = Solace::Instructions::AddressLookupTableProgram::CreateLookupTableInstruction.build(
+      #     recent_slot:          123,
+      #     bump:                 254,
+      #     program_index:        4,
+      #     table_index:          1,
+      #     authority_index:      0,
+      #     payer_index:          0,
+      #     system_program_index: 3
+      #   )
+      #
+      # @since 0.1.8
+      class CreateLookupTableInstruction
+        # Instruction discriminator for CreateLookupTable (u32 LE)
+        INSTRUCTION_ID = [0, 0, 0, 0].freeze
+
+        # Builds a Solace::Instruction for creating a lookup table
+        #
+        # @param recent_slot [Integer] The slot used to derive the table address
+        # @param bump [Integer] The bump seed for the table's program-derived address
+        # @param program_index [Integer] Index of the lookup table program
+        # @param table_index [Integer] Index of the (uninitialized) table account
+        # @param authority_index [Integer] Index of the table authority (signer)
+        # @param payer_index [Integer] Index of the rent payer (writable signer)
+        # @param system_program_index [Integer] Index of the system program
+        # @return [Solace::Instruction]
+        def self.build(
+          recent_slot:,
+          bump:,
+          program_index:,
+          table_index:,
+          authority_index:,
+          payer_index:,
+          system_program_index:
+        )
+          Instruction.new.tap do |ix|
+            ix.program_index = program_index
+            ix.accounts      = [table_index, authority_index, payer_index, system_program_index]
+            ix.data          = data(recent_slot, bump)
+          end
+        end
+
+        # Instruction data for a create lookup table instruction
+        #
+        # The BufferLayout is:
+        #   - [Instruction discriminator (4 bytes, u32 LE)]
+        #   - [Recent slot (8 bytes, u64 LE)]
+        #   - [Bump seed (1 byte)]
+        #
+        # @param recent_slot [Integer] The slot used to derive the table address
+        # @param bump [Integer] The bump seed
+        # @return [Array<Integer>]
+        def self.data(recent_slot, bump)
+          INSTRUCTION_ID +
+            Utils::Codecs.encode_le_u64(recent_slot).bytes +
+            [bump]
+        end
+      end
+    end
+  end
+end