order_and_execute() TypeError on transactions with multiple signatures

[moratb]

The Bug

UltraApiClient.order_and_execute() fails on transactions with multiple signature slots (common with larger swap amounts).

Error:

TypeError: argument 'keypairs': failed to extract enum Signer
'Signature' object cannot be converted to 'Keypair'

Root Cause

Bug in JupiterClient._sign_versioned_transaction() (lines 87-99):

signers = list(versioned_transaction.signatures)  # List of Signature objects
signers[wallet_index] = wallet  # ❌ Puts Keypair into Signature list - TYPE MISMATCH

return VersionedTransaction(versioned_transaction.message, signers)  # Fails!

The issue: The code replaces a Signature with a Keypair object, creating a mixed-type list. This works for single-signature transactions but fails for multi-signature transactions.

Reproduce

from jup_python_sdk.clients.ultra_api_client import UltraApiClient
from jup_python_sdk.models.ultra_api.ultra_order_request_model import UltraOrderRequest

client = UltraApiClient(private_key_env_var="PRIVATE_KEY")

order_request = UltraOrderRequest(
    input_mint="85VBFQZC9TZkfaptBWjvUw7YbZjy52A6mjtPGjstQAmQ",
    output_mint="EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
    amount=100000000,  # Large amounts trigger multi-signature transactions
    taker=client._get_public_key()
)

client.order_and_execute(order_request)  # ❌ TypeError

Fix

Replace _sign_versioned_transaction() in jupiter_client.py:

def _sign_versioned_transaction(
    self, versioned_transaction: VersionedTransaction
) -> VersionedTransaction:
    wallet = Keypair.from_bytes(self._load_private_key_bytes())
    
    # Actually sign the message to create a Signature object
    my_signature = wallet.sign_message(bytes(versioned_transaction.message))
    
    account_keys = versioned_transaction.message.account_keys
    wallet_index = account_keys.index(wallet.pubkey())
    
    # Replace with Signature (not Keypair)
    signatures = list(versioned_transaction.signatures)
    signatures[wallet_index] = my_signature
    
    # Use populate() method with all Signature objects
    return VersionedTransaction.populate(
        versioned_transaction.message,
        signatures
    )

Key change: Sign the message to create a Signature object, then use .populate() instead of the constructor. This maintains type consistency: all elements remain Signature objects.

Workaround

Use separate order() and execute() calls with manual signing

    order_request = UltraOrderRequest(
        input_mint=in_address,
        output_mint=out_address,
        amount=in_amount,
        taker=self.address
    )
    
    order_response = self.client.order(order_request)
    request_id = order_response["requestId"]
    
    ## manual signing of the transaction
    tx_bytes = base64.b64decode(order_response["transaction"])
    raw_tx = VersionedTransaction.from_bytes(tx_bytes)
    wallet = Keypair.from_bytes(self.client._load_private_key_bytes())
    my_signature = wallet.sign_message(message.to_bytes_versioned(raw_tx.message))
    wallet_index = raw_tx.message.account_keys.index(wallet.pubkey())
    signatures = list(raw_tx.signatures)
    signatures[wallet_index] = my_signature
    signed_tx = VersionedTransaction.populate(raw_tx.message, signatures)
    signed_transaction = base64.b64encode(bytes(signed_tx)).decode("utf-8")
    
    execute_request = UltraExecuteRequest(
        request_id=request_id,
        signed_transaction=signed_transaction
    )
    
    client_response = self.client.execute(execute_request)
    tx_signature = str(client_response["signature"])

Environment

• Python: 3.13.5
• jup-python-sdk: 1.1.0
• solders: 0.26.0

[cmoutafidis]

GM, I made an attempt to fix this, fix is on version 1.1.1, could you check and let me know?

[moratb]

@cmoutafidis

Thanks for the fix attempt! Unfortunately, it still produces invalid signatures that get rejected by Jupiter's Ultra API with 422 Unprocessable Entity errors.

i think the issue might be here on line 96 (this somehow produces different bytes than what Jupiter's API expects.)

message_bytes = bytes(versioned_transaction.message)

instead maybe from solders.message import to_bytes_versioned has to be used ?

e.g.

from solders.message import to_bytes_versioned

method1_bytes = to_bytes_versioned(raw_tx.message)  
method2_bytes = bytes(raw_tx.message)             

print(f"to_bytes_versioned(): {len(method1_bytes)} bytes")
# Output: 740 bytes, starts with 80010003092fdd9173fc4c75d5a7f189...

print(f"bytes():              {len(method2_bytes)} bytes")
# Output: 739 bytes, starts with 010003092fdd9173fc4c75d5a7f189...