solana-ruby-kit 0.1.0 → 0.1.5

data/lib/solana/ruby/kit/instruction_plans/transaction_plan_result.rb

@@ -0,0 +1,117 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative '../errors'
+require_relative '../transaction_messages/transaction_message'
+require_relative '../transactions/transaction'
+
+module Solana::Ruby::Kit
+  module InstructionPlans
+    extend T::Sig
+
+    # ── Result status types ───────────────────────────────────────────────────
+    #
+    # Each single transaction produces one of three statuses:
+    #   successful: { kind: :successful, transaction:, context: }
+    #   failed:     { kind: :failed,     error: }
+    #   canceled:   { kind: :canceled }
+    #
+    # Mirrors TypeScript's TransactionPlanResultStatus union.
+
+    class SuccessfulStatus < T::Struct
+      const :transaction, Transactions::Transaction
+      const :context,     T::Hash[T.untyped, T.untyped]
+      def kind = :successful
+    end
+
+    class FailedStatus < T::Struct
+      const :error, SolanaError
+      def kind = :failed
+    end
+
+    class CanceledStatus < T::Struct
+      def kind = :canceled
+    end
+
+    # ── Result plan types ──────────────────────────────────────────────────────
+
+    class SingleTransactionPlanResult < T::Struct
+      const :message, TransactionMessages::TransactionMessage
+      const :status,  T.untyped  # SuccessfulStatus | FailedStatus | CanceledStatus
+      def kind = :single
+    end
+
+    class SequentialTransactionPlanResult < T::Struct
+      const :plans,     T::Array[T.untyped]  # Array[TransactionPlanResult]
+      const :divisible, T::Boolean
+      def kind = :sequential
+    end
+
+    class ParallelTransactionPlanResult < T::Struct
+      const :plans, T::Array[T.untyped]  # Array[TransactionPlanResult]
+      def kind = :parallel
+    end
+
+    module_function
+
+    # ── Result factory helpers ────────────────────────────────────────────────
+
+    # Mirrors `sequentialTransactionPlanResult(plans)`.
+    sig { params(plans: T::Array[T.untyped]).returns(SequentialTransactionPlanResult) }
+    def sequential_transaction_plan_result(plans)
+      SequentialTransactionPlanResult.new(plans: plans, divisible: true)
+    end
+
+    # Mirrors `nonDivisibleSequentialTransactionPlanResult(plans)`.
+    sig { params(plans: T::Array[T.untyped]).returns(SequentialTransactionPlanResult) }
+    def non_divisible_sequential_transaction_plan_result(plans)
+      SequentialTransactionPlanResult.new(plans: plans, divisible: false)
+    end
+
+    # Mirrors `parallelTransactionPlanResult(plans)`.
+    sig { params(plans: T::Array[T.untyped]).returns(ParallelTransactionPlanResult) }
+    def parallel_transaction_plan_result(plans)
+      ParallelTransactionPlanResult.new(plans: plans)
+    end
+
+    # Mirrors `successfulSingleTransactionPlanResult(message, transaction, context)`.
+    sig do
+      params(
+        message:     TransactionMessages::TransactionMessage,
+        transaction: Transactions::Transaction,
+        context:     T::Hash[T.untyped, T.untyped]
+      ).returns(SingleTransactionPlanResult)
+    end
+    def successful_single_transaction_plan_result(message, transaction, context = {})
+      SingleTransactionPlanResult.new(
+        message: message,
+        status:  SuccessfulStatus.new(transaction: transaction, context: context)
+      )
+    end
+
+    # Mirrors `failedSingleTransactionPlanResult(message, error)`.
+    sig do
+      params(
+        message: TransactionMessages::TransactionMessage,
+        error:   SolanaError
+      ).returns(SingleTransactionPlanResult)
+    end
+    def failed_single_transaction_plan_result(message, error)
+      SingleTransactionPlanResult.new(
+        message: message,
+        status:  FailedStatus.new(error: error)
+      )
+    end
+
+    # Mirrors `canceledSingleTransactionPlanResult(message)`.
+    sig do
+      params(message: TransactionMessages::TransactionMessage).returns(SingleTransactionPlanResult)
+    end
+    def canceled_single_transaction_plan_result(message)
+      SingleTransactionPlanResult.new(
+        message: message,
+        status:  CanceledStatus.new
+      )
+    end
+  end
+end

data/lib/solana/ruby/kit/instruction_plans/transaction_planner.rb

@@ -0,0 +1,264 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative '../errors'
+require_relative '../transaction_messages/transaction_message'
+require_relative '../transactions/compiler'
+require_relative 'instruction_plan'
+require_relative 'transaction_plan'
+
+module Solana::Ruby::Kit
+  module InstructionPlans
+    extend T::Sig
+
+    # Creates a TransactionPlanner — a callable that converts an InstructionPlan
+    # into a TransactionPlan by packing instructions into transaction messages.
+    #
+    # Configuration:
+    #   create_transaction_message: -> { TransactionMessage }
+    #     Called whenever a new (empty) message is needed. Must return a message
+    #     with at least a fee payer and blockhash already set.
+    #
+    #   on_transaction_message_updated: ->(message) { TransactionMessage }  (optional)
+    #     Called after instructions are appended to a message. Must return the
+    #     (possibly further updated) message. Defaults to identity.
+    #
+    # The returned planner is a lambda: planner.call(instruction_plan) -> TransactionPlan
+    #
+    # Mirrors `createTransactionPlanner(config)` from @solana/instruction-plans.
+    # NOTE: Ruby translation is synchronous; abort-signal support is omitted.
+    sig do
+      params(
+        create_transaction_message:     T.untyped,
+        on_transaction_message_updated: T.untyped
+      ).returns(T.untyped)
+    end
+    def create_transaction_planner(
+      create_transaction_message:,
+      on_transaction_message_updated: ->(msg) { msg }
+    )
+      ctx = {
+        create_transaction_message:     create_transaction_message,
+        on_transaction_message_updated: on_transaction_message_updated
+      }
+
+      ->(instruction_plan) {
+        mutable = planner_traverse(instruction_plan, ctx.merge(parent: nil, parent_candidates: []))
+        Kernel.raise SolanaError.new(SolanaError::INSTRUCTION_PLANS__EMPTY_INSTRUCTION_PLAN) unless mutable
+        planner_freeze(mutable)
+      }
+    end
+
+    module_function :create_transaction_planner
+
+    # ── Private helpers ────────────────────────────────────────────────────────
+
+    module_function
+
+    def planner_traverse(plan, ctx)
+      case plan.kind
+      when :sequential     then planner_traverse_sequential(plan, ctx)
+      when :parallel       then planner_traverse_parallel(plan, ctx)
+      when :single         then planner_traverse_single(plan, ctx)
+      when :message_packer then planner_traverse_message_packer(plan, ctx)
+      else
+        Kernel.raise SolanaError.new(
+          SolanaError::INVARIANT_VIOLATION__INVALID_INSTRUCTION_PLAN_KIND,
+          { kind: plan.kind }
+        )
+      end
+    end
+
+    def planner_traverse_sequential(plan, ctx)
+      must_fit_in_parent = ctx[:parent] && (ctx[:parent].kind == :parallel || !plan.divisible)
+
+      if must_fit_in_parent
+        candidate = planner_select_and_mutate_candidate(ctx, ctx[:parent_candidates]) do |msg|
+          planner_fit_entire_plan(plan, msg, ctx)
+        end
+        return nil if candidate
+      end
+
+      candidate = (!must_fit_in_parent && !ctx[:parent_candidates].empty?) ? ctx[:parent_candidates][0] : nil
+      tx_plans  = []
+
+      plan.plans.each do |sub_plan|
+        sub_ctx = ctx.merge(parent: plan, parent_candidates: candidate ? [candidate] : [])
+        tx_plan = planner_traverse(sub_plan, sub_ctx)
+        next unless tx_plan
+
+        candidate = planner_get_sequential_candidate(tx_plan)
+        new_plans =
+          tx_plan[:kind] == :sequential && (tx_plan[:divisible] || !plan.divisible) \
+            ? tx_plan[:plans] \
+            : [tx_plan]
+        tx_plans.concat(new_plans)
+      end
+
+      return nil          if tx_plans.empty?
+      return tx_plans[0]  if tx_plans.length == 1
+      { kind: :sequential, divisible: plan.divisible, plans: tx_plans }
+    end
+
+    def planner_traverse_parallel(plan, ctx)
+      candidates = ctx[:parent_candidates].dup
+      tx_plans   = []
+
+      sorted = plan.plans.sort_by { |p| p.kind == :message_packer ? 1 : 0 }
+
+      sorted.each do |sub_plan|
+        sub_ctx = ctx.merge(parent: plan, parent_candidates: candidates)
+        tx_plan = planner_traverse(sub_plan, sub_ctx)
+        next unless tx_plan
+
+        candidates.concat(planner_get_parallel_candidates(tx_plan))
+        new_plans = tx_plan[:kind] == :parallel ? tx_plan[:plans] : [tx_plan]
+        tx_plans.concat(new_plans)
+      end
+
+      return nil          if tx_plans.empty?
+      return tx_plans[0]  if tx_plans.length == 1
+      { kind: :parallel, plans: tx_plans }
+    end
+
+    def planner_traverse_single(plan, ctx)
+      predicate = ->(msg) { TransactionMessages.append_instructions(msg, [plan.instruction]) }
+      candidate = planner_select_and_mutate_candidate(ctx, ctx[:parent_candidates], &predicate)
+      return nil if candidate
+
+      msg = planner_create_new_message(ctx, &predicate)
+      { kind: :single, message: msg }
+    end
+
+    def planner_traverse_message_packer(plan, ctx)
+      packer     = plan.get_message_packer.call
+      tx_plans   = []
+      candidates = ctx[:parent_candidates].dup
+
+      until packer.done?
+        predicate = ->(msg) { packer.pack_message_to_capacity(msg) }
+        candidate = planner_select_and_mutate_candidate(ctx, candidates, &predicate)
+        unless candidate
+          msg      = planner_create_new_message(ctx, &predicate)
+          new_plan = { kind: :single, message: msg }
+          tx_plans << new_plan
+          candidates << new_plan
+        end
+      end
+
+      return nil          if tx_plans.empty?
+      return tx_plans[0]  if tx_plans.length == 1
+
+      if ctx[:parent]&.kind == :parallel
+        { kind: :parallel, plans: tx_plans }
+      else
+        divisible = ctx[:parent]&.kind == :sequential ? ctx[:parent].divisible : true
+        { kind: :sequential, divisible: divisible, plans: tx_plans }
+      end
+    end
+
+    def planner_select_and_mutate_candidate(ctx, candidates, &predicate)
+      candidates.each do |candidate|
+        begin
+          updated = ctx[:on_transaction_message_updated].call(predicate.call(candidate[:message]))
+          if Transactions.get_transaction_message_size(updated) <= Transactions::TRANSACTION_SIZE_LIMIT
+            candidate[:message] = updated
+            return candidate
+          end
+        rescue SolanaError => e
+          next if e.code == SolanaError::INSTRUCTION_PLANS__MESSAGE_CANNOT_ACCOMMODATE_PLAN
+          Kernel.raise
+        end
+      end
+      nil
+    end
+
+    def planner_create_new_message(ctx, &predicate)
+      new_msg      = ctx[:create_transaction_message].call
+      updated_msg  = ctx[:on_transaction_message_updated].call(predicate.call(new_msg))
+      updated_size = Transactions.get_transaction_message_size(updated_msg)
+
+      if updated_size > Transactions::TRANSACTION_SIZE_LIMIT
+        new_size = Transactions.get_transaction_message_size(new_msg)
+        Kernel.raise SolanaError.new(
+          SolanaError::INSTRUCTION_PLANS__MESSAGE_CANNOT_ACCOMMODATE_PLAN,
+          { num_bytes_required: updated_size - new_size,
+            num_free_bytes:     Transactions::TRANSACTION_SIZE_LIMIT - new_size }
+        )
+      end
+
+      updated_msg
+    end
+
+    def planner_fit_entire_plan(plan, message, ctx)
+      case plan.kind
+      when :sequential, :parallel
+        plan.plans.reduce(message) { |msg, sub| planner_fit_entire_plan(sub, msg, ctx) }
+      when :single
+        updated  = TransactionMessages.append_instructions(message, [plan.instruction])
+        new_size = Transactions.get_transaction_message_size(updated)
+        if new_size > Transactions::TRANSACTION_SIZE_LIMIT
+          base_size = Transactions.get_transaction_message_size(message)
+          Kernel.raise SolanaError.new(
+            SolanaError::INSTRUCTION_PLANS__MESSAGE_CANNOT_ACCOMMODATE_PLAN,
+            { num_bytes_required: new_size - base_size,
+              num_free_bytes:     Transactions::TRANSACTION_SIZE_LIMIT - base_size }
+          )
+        end
+        updated
+      when :message_packer
+        packer = plan.get_message_packer.call
+        msg    = message
+        msg    = packer.pack_message_to_capacity(msg) until packer.done?
+        msg
+      else
+        Kernel.raise SolanaError.new(
+          SolanaError::INVARIANT_VIOLATION__INVALID_INSTRUCTION_PLAN_KIND,
+          { kind: plan.kind }
+        )
+      end
+    end
+
+    def planner_get_sequential_candidate(plan)
+      return plan if plan[:kind] == :single
+      return nil  unless plan[:kind] == :sequential && plan[:plans]&.any?
+      planner_get_sequential_candidate(plan[:plans].last)
+    end
+
+    def planner_get_parallel_candidates(plan)
+      return [plan] if plan[:kind] == :single
+      (plan[:plans] || []).flat_map { |p| planner_get_parallel_candidates(p) }
+    end
+
+    def planner_freeze(plan)
+      case plan[:kind]
+      when :single
+        single_transaction_plan(plan[:message])
+      when :sequential
+        frozen_plans = plan[:plans].map { |p| planner_freeze(p) }
+        plan[:divisible] \
+          ? sequential_transaction_plan(frozen_plans) \
+          : non_divisible_sequential_transaction_plan(frozen_plans)
+      when :parallel
+        parallel_transaction_plan(plan[:plans].map { |p| planner_freeze(p) })
+      else
+        Kernel.raise SolanaError.new(
+          SolanaError::INVARIANT_VIOLATION__INVALID_TRANSACTION_PLAN_KIND,
+          { kind: plan[:kind] }
+        )
+      end
+    end
+
+    private_class_method :planner_traverse
+    private_class_method :planner_traverse_sequential
+    private_class_method :planner_traverse_parallel
+    private_class_method :planner_traverse_single
+    private_class_method :planner_traverse_message_packer
+    private_class_method :planner_select_and_mutate_candidate
+    private_class_method :planner_create_new_message
+    private_class_method :planner_fit_entire_plan
+    private_class_method :planner_get_sequential_candidate
+    private_class_method :planner_get_parallel_candidates
+    private_class_method :planner_freeze
+  end
+end

data/lib/solana/ruby/kit/instruction_plans.rb

@@ -3,45 +3,8 @@
 
 # Mirrors @solana/instruction-plans.
 # An InstructionPlan describes operations that may span multiple transactions.
-require_relative 'instruction_plans/plans'
-
-module Solana::Ruby::Kit
-  module InstructionPlans
-    extend T::Sig
-
-    module_function
-
-    # Build a plan that wraps a single instruction.
-    sig { params(instruction: Instructions::Instruction).returns(SingleInstructionPlan) }
-    def single_instruction_plan(instruction)
-      SingleInstructionPlan.new(instruction: instruction)
-    end
-
-    # Build a sequential plan from an array of sub-plans.
-    sig { params(steps: T::Array[T.untyped], divisible: T::Boolean).returns(SequentialInstructionPlan) }
-    def sequential_instruction_plan(steps, divisible: false)
-      SequentialInstructionPlan.new(steps: steps, divisible: divisible)
-    end
-
-    # Build a parallel plan from an array of sub-plans.
-    sig { params(plans: T::Array[T.untyped]).returns(ParallelInstructionPlan) }
-    def parallel_instruction_plan(plans)
-      ParallelInstructionPlan.new(plans: plans)
-    end
-
-    # Flatten a plan tree into a single ordered Array of Instructions.
-    sig { params(plan: T.untyped).returns(T::Array[Instructions::Instruction]) }
-    def flatten_instruction_plan(plan)
-      case plan
-      when SingleInstructionPlan
-        [plan.instruction]
-      when SequentialInstructionPlan
-        plan.steps.flat_map { |s| flatten_instruction_plan(s) }
-      when ParallelInstructionPlan
-        plan.plans.flat_map { |p| flatten_instruction_plan(p) }
-      else
-        Kernel.raise ArgumentError, "Unknown InstructionPlan type: #{plan.class}"
-      end
-    end
-  end
-end
+require_relative 'instruction_plans/instruction_plan'
+require_relative 'instruction_plans/transaction_plan'
+require_relative 'instruction_plans/transaction_plan_result'
+require_relative 'instruction_plans/transaction_planner'
+require_relative 'instruction_plans/transaction_plan_executor'

data/lib/solana/ruby/kit/programs/associated_token_account.rb

@@ -0,0 +1,133 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative '../addresses/address'
+require_relative '../addresses/program_derived_address'
+require_relative '../instructions/instruction'
+require_relative '../instructions/accounts'
+
+module Solana::Ruby::Kit
+  module Programs
+    # Ruby interface for the SPL Associated Token Account on-chain program.
+    #
+    # An Associated Token Account (ATA) is a Program Derived Address that holds
+    # SPL token balances for a given wallet + mint pair.  The ATA address is
+    # deterministic: given a wallet and a mint, there is exactly one "canonical"
+    # token account for that combination.
+    #
+    # Seeds used for PDA derivation (all raw 32-byte address buffers):
+    #   [ wallet_bytes, token_program_bytes, mint_bytes ]
+    # Program: PROGRAM_ID (the Associated Token Account program)
+    #
+    # Reference: https://github.com/solana-program/associated-token-account
+    module AssociatedTokenAccount
+      extend T::Sig
+
+      # SPL Associated Token Account program.
+      PROGRAM_ID = T.let(
+        Addresses::Address.new('ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL'),
+        Addresses::Address
+      )
+
+      # Original SPL Token program (spl-token).
+      TOKEN_PROGRAM_ID = T.let(
+        Addresses::Address.new('TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA'),
+        Addresses::Address
+      )
+
+      # Token Extensions program (spl-token-2022).
+      TOKEN_2022_PROGRAM_ID = T.let(
+        Addresses::Address.new('TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb'),
+        Addresses::Address
+      )
+
+      # Solana System Program.
+      SYSTEM_PROGRAM_ID = T.let(
+        Addresses::Address.new('11111111111111111111111111111111'),
+        Addresses::Address
+      )
+
+      module_function
+
+      # Derives the canonical Associated Token Account address (a PDA) for a
+      # given wallet and mint.
+      #
+      # @param wallet           [Addresses::Address]  the account that will own the ATA
+      # @param mint             [Addresses::Address]  the token mint
+      # @param token_program_id [Addresses::Address]  TOKEN_PROGRAM_ID or TOKEN_2022_PROGRAM_ID
+      # @return [Addresses::ProgramDerivedAddress]    the ATA address + bump seed
+      sig do
+        params(
+          wallet:           Addresses::Address,
+          mint:             Addresses::Address,
+          token_program_id: Addresses::Address
+        ).returns(Addresses::ProgramDerivedAddress)
+      end
+      def get_associated_token_address(wallet:, mint:, token_program_id: TOKEN_PROGRAM_ID)
+        wallet_bytes        = Addresses.decode_address(wallet)
+        token_program_bytes = Addresses.decode_address(token_program_id)
+        mint_bytes          = Addresses.decode_address(mint)
+
+        Addresses.get_program_derived_address(
+          program_address: PROGRAM_ID,
+          seeds:           [wallet_bytes, token_program_bytes, mint_bytes]
+        )
+      end
+
+      # Builds an instruction that creates an Associated Token Account.
+      #
+      # Account layout expected by the on-chain program (in order):
+      #   0. payer                    — writable, signer (funds the rent)
+      #   1. associated_token_account — writable (the new ATA; derived via PDA)
+      #   2. wallet                   — readonly  (the ATA's owner)
+      #   3. mint                     — readonly
+      #   4. system_program           — readonly
+      #   5. token_program            — readonly
+      #
+      # Instruction data:
+      #   nil / empty  →  "Create"         (fails if the ATA already exists)
+      #   "\x01"       →  "CreateIdempotent" (no-op if already initialised)
+      #
+      # @param payer            [Addresses::Address]  pays for rent
+      # @param wallet           [Addresses::Address]  will own the ATA
+      # @param mint             [Addresses::Address]  token mint
+      # @param token_program_id [Addresses::Address]  which token program to use
+      # @param idempotent       [Boolean]             use the idempotent variant
+      # @return [Instructions::Instruction]
+      sig do
+        params(
+          payer:            Addresses::Address,
+          wallet:           Addresses::Address,
+          mint:             Addresses::Address,
+          token_program_id: Addresses::Address,
+          idempotent:       T::Boolean
+        ).returns(Instructions::Instruction)
+      end
+      def create_instruction(
+        payer:,
+        wallet:,
+        mint:,
+        token_program_id: TOKEN_PROGRAM_ID,
+        idempotent: false
+      )
+        ata = get_associated_token_address(wallet: wallet, mint: mint, token_program_id: token_program_id)
+
+        # Discriminator: none for "Create", 0x01 for "CreateIdempotent"
+        data = idempotent ? "\x01".b : nil
+
+        Instructions::Instruction.new(
+          program_address: PROGRAM_ID,
+          accounts: [
+            Instructions.writable_signer_account(payer),          # 0 payer
+            Instructions.writable_account(ata.address),            # 1 ATA to create
+            Instructions.readonly_account(wallet),                  # 2 owner (readonly)
+            Instructions.readonly_account(mint),                    # 3 mint
+            Instructions.readonly_account(SYSTEM_PROGRAM_ID),      # 4 System Program
+            Instructions.readonly_account(token_program_id),       # 5 Token Program
+          ],
+          data: data
+        )
+      end
+    end
+  end
+end

data/lib/solana/ruby/kit/programs/system_program.rb

@@ -0,0 +1,69 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative '../addresses/address'
+require_relative '../instructions/instruction'
+require_relative '../instructions/accounts'
+
+module Solana::Ruby::Kit
+  module Programs
+    # Ruby interface for the Solana System Program (11111111111111111111111111111111).
+    #
+    # The System Program is responsible for creating accounts, transferring SOL,
+    # and other low-level operations.  Instruction data uses little-endian encoding:
+    # a u32 discriminator identifying the instruction variant, followed by any
+    # instruction-specific fields.
+    #
+    # Reference: https://github.com/solana-program/system
+    module SystemProgram
+      extend T::Sig
+
+      # The System Program address (all zeros, encoded in base58).
+      PROGRAM_ID = T.let(
+        Addresses::Address.new('11111111111111111111111111111111'),
+        Addresses::Address
+      )
+
+      # Instruction discriminators (u32 little-endian).
+      DISCRIMINATOR_TRANSFER = T.let(2, Integer)
+
+      module_function
+
+      # Builds a System Program Transfer instruction that moves +lamports+ from
+      # +sender+ to +recipient+.
+      #
+      # Instruction data layout (12 bytes):
+      #   [0..3]  u32 LE  — discriminator (2)
+      #   [4..11] u64 LE  — lamports
+      #
+      # Accounts:
+      #   0. sender    — writable, signer (source of SOL)
+      #   1. recipient — writable         (destination)
+      #
+      # @param sender    [Addresses::Address]
+      # @param recipient [Addresses::Address]
+      # @param lamports  [Integer]  amount to transfer (1 SOL = 1_000_000_000 lamports)
+      # @return [Instructions::Instruction]
+      sig do
+        params(
+          sender:    Addresses::Address,
+          recipient: Addresses::Address,
+          lamports:  Integer
+        ).returns(Instructions::Instruction)
+      end
+      def transfer_instruction(sender:, recipient:, lamports:)
+        # Pack as: u32 LE discriminator || u64 LE lamports
+        data = [DISCRIMINATOR_TRANSFER, lamports].pack('VQ<').b
+
+        Instructions::Instruction.new(
+          program_address: PROGRAM_ID,
+          accounts: [
+            Instructions.writable_signer_account(sender),    # 0 sender
+            Instructions.writable_account(recipient),         # 1 recipient
+          ],
+          data: data
+        )
+      end
+    end
+  end
+end

data/lib/solana/ruby/kit/programs.rb

@@ -3,6 +3,8 @@
 
 # Mirrors @solana/programs — helpers for inspecting custom program errors
 # returned in Solana transaction failures.
+require_relative 'programs/associated_token_account'
+require_relative 'programs/system_program'
 #
 # A program error in a transaction result looks like:
 #   { "InstructionError" => [0, { "Custom" => 1234 }] }

data/lib/solana/ruby/kit/rpc/api/send_transaction.rb

@@ -3,6 +3,7 @@
 
 require 'base64'
 require_relative '../../keys/signatures'
+require_relative '../../transactions/compiler'
 
 module Solana::Ruby::Kit
   module Rpc
@@ -43,7 +44,7 @@ module Solana::Ruby::Kit
               transaction
             else
               # Assume it responds to .message_bytes (Transactions::Transaction)
-              Base64.strict_encode64(transaction.message_bytes)
+              Base64.strict_encode64(Transactions.wire_encode_transaction(transaction))
             end
 
           config = { 'encoding' => 'base64' }