solana-ruby-kit 8.2.0 → 8.3.0

data/lib/solana/ruby/kit/transactions/transaction.rb

@@ -34,12 +34,32 @@ module Solana::Ruby::Kit
       const :signatures,    T::Hash[String, T.nilable(String)]
     end
 
-    module_function
+    # Either transaction struct.
+    #
+    # Because `FullySignedTransaction` is a *parallel* struct rather than a
+    # subclass of `Transaction` (T::Struct is final), it is not a subtype of it,
+    # and a signature naming only `Transaction` rejects it. That matters for
+    # nearly everything below, because `sign_transaction` returns a
+    # `FullySignedTransaction` and encoding, inspecting or sending one is the
+    # ordinary next step — `wire_encode_transaction(sign_transaction(...))` is
+    # the single most common two-call sequence in the whole library.
+    #
+    # TypeScript has no such problem: `FullySignedTransaction` there is
+    # `Transaction & { readonly [brand] }`, an intersection that *is* assignable
+    # to `Transaction`. This alias is the Ruby equivalent of that assignability.
+    #
+    # Use it for any parameter that reads a transaction. Use `Transaction`
+    # alone only where the value is specifically an unsigned or partially
+    # signed one, and `FullySignedTransaction` alone only as a return type
+    # asserting that signing happened.
+    AnyTransaction = T.type_alias { T.any(Transaction, FullySignedTransaction) }
+
+    extend self
 
     # Returns the base58-encoded signature that uniquely identifies a transaction.
     # This is the fee payer's signature (first entry in the signatures map).
     # Mirrors `getSignatureFromTransaction(transaction)`.
-    sig { params(transaction: Transaction).returns(Keys::Signature) }
+    sig { params(transaction: AnyTransaction).returns(Keys::Signature) }
     def get_signature_from_transaction(transaction)
       sig_bytes = transaction.signatures.values.first
       Kernel.raise SolanaError.new(:SOLANA_ERROR__TRANSACTION__FEE_PAYER_SIGNATURE_MISSING) unless sig_bytes
@@ -49,14 +69,14 @@ module Solana::Ruby::Kit
 
     # Returns true if every slot in the signatures map is filled.
     # Mirrors `isFullySignedTransaction(transaction)`.
-    sig { params(transaction: Transaction).returns(T::Boolean) }
+    sig { params(transaction: AnyTransaction).returns(T::Boolean) }
     def fully_signed_transaction?(transaction)
       transaction.signatures.values.all? { |sig| !sig.nil? }
     end
 
     # Raises SolanaError unless every signer slot is filled.
     # Mirrors `assertIsFullySignedTransaction(transaction)`.
-    sig { params(transaction: Transaction).void }
+    sig { params(transaction: AnyTransaction).void }
     def assert_fully_signed_transaction!(transaction)
       missing = transaction.signatures.filter_map { |addr, sig| addr if sig.nil? }
       return if missing.empty?
@@ -69,14 +89,14 @@ module Solana::Ruby::Kit
 
     # Returns true if the wire-encoded transaction fits within TRANSACTION_SIZE_LIMIT.
     # Mirrors `isTransactionWithinSizeLimit(transaction)`.
-    sig { params(transaction: Transaction).returns(T::Boolean) }
+    sig { params(transaction: AnyTransaction).returns(T::Boolean) }
     def within_size_limit?(transaction)
       wire_encode_transaction(transaction).bytesize <= TRANSACTION_SIZE_LIMIT
     end
 
     # Raises SolanaError if the wire-encoded transaction exceeds TRANSACTION_SIZE_LIMIT.
     # Mirrors `assertIsTransactionWithinSizeLimit(transaction)`.
-    sig { params(transaction: Transaction).void }
+    sig { params(transaction: AnyTransaction).void }
     def assert_within_size_limit!(transaction)
       actual = wire_encode_transaction(transaction).bytesize
       return if actual <= TRANSACTION_SIZE_LIMIT
@@ -90,14 +110,14 @@ module Solana::Ruby::Kit
     # Returns true if the transaction is both fully signed and within the size limit.
     # Mirrors `isSendableTransaction(transaction)`.
     # sendableTransaction = FullySignedTransaction & TransactionWithinSizeLimit
-    sig { params(transaction: Transaction).returns(T::Boolean) }
+    sig { params(transaction: AnyTransaction).returns(T::Boolean) }
     def sendable_transaction?(transaction)
       fully_signed_transaction?(transaction) && within_size_limit?(transaction)
     end
 
     # Raises SolanaError unless the transaction is fully signed and within size limit.
     # Mirrors `assertIsSendableTransaction(transaction)`.
-    sig { params(transaction: Transaction).void }
+    sig { params(transaction: AnyTransaction).void }
     def assert_sendable_transaction!(transaction)
       assert_fully_signed_transaction!(transaction)
       assert_within_size_limit!(transaction)
@@ -112,7 +132,7 @@ module Solana::Ruby::Kit
     sig do
       params(
         signing_keys: T::Array[T.untyped],  # Array<RbNaCl::SigningKey>
-        transaction:  Transaction
+        transaction:  AnyTransaction
       ).returns(Transaction)
     end
     def partially_sign_transaction(signing_keys, transaction)
@@ -155,7 +175,7 @@ module Solana::Ruby::Kit
     sig do
       params(
         signing_keys: T::Array[T.untyped],
-        transaction:  Transaction
+        transaction:  AnyTransaction
       ).returns(FullySignedTransaction)
     end
     def sign_transaction(signing_keys, transaction)

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

@@ -4,7 +4,7 @@
 module Solana
   module Ruby
     module Kit
-      VERSION = '8.2.0'
+      VERSION = '8.3.0'
     end
   end
 end

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

@@ -54,7 +54,7 @@ module Solana::Ruby::Kit
     DISCONNECT                = T.let('standard:disconnect',           String)
     EVENTS                    = T.let('standard:events',               String)
 
-    module_function
+    extend self
 
     # ── Wire-format decoder ───────────────────────────────────────────────────
 
@@ -165,7 +165,7 @@ module Solana::Ruby::Kit
     # any signature does not verify.  Nil (unfilled) slots are skipped silently;
     # use +Transactions.assert_fully_signed_transaction!+ to enforce that all
     # required signers have signed.
-    sig { params(transaction: Transactions::Transaction).void }
+    sig { params(transaction: Transactions::AnyTransaction).void }
     def verify_transaction_signatures!(transaction)
       transaction.signatures.each do |addr_str, sig_raw|
         next if sig_raw.nil?
@@ -201,7 +201,7 @@ module Solana::Ruby::Kit
     # Returns +true+ if +address+ has provided a cryptographically valid
     # signature for +transaction+; +false+ if the slot is absent, nil, or the
     # signature does not verify against +transaction.message_bytes+.
-    sig { params(transaction: Transactions::Transaction, address: Addresses::Address).returns(T::Boolean) }
+    sig { params(transaction: Transactions::AnyTransaction, address: Addresses::Address).returns(T::Boolean) }
     def signed_by?(transaction, address)
       sig_raw = transaction.signatures[address.value]
       return false if sig_raw.nil?

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: solana-ruby-kit
 version: !ruby/object:Gem::Version
-  version: 8.2.0
+  version: 8.3.0
 platform: ruby
 authors:
 - Paul Zupan, Idhra Inc.