add script & multisig paths, fmt & constants

Author: Tlazypanda

aptos_sdk/async_client.py

@@ -3,6 +3,7 @@
 
 import asyncio
 import logging
+import secrets
 import time
 from dataclasses import dataclass
 from typing import Any, Dict, List, Optional
@@ -18,11 +19,12 @@
 from .transactions import (
     EntryFunction,
     MultiAgentRawTransaction,
+    OrderlessPayload,
     RawTransaction,
+    Script,
     SignedTransaction,
     TransactionArgument,
     TransactionPayload,
-    OrderlessPayload,
 )
 from .type_tag import StructTag, TypeTag
 
@@ -530,29 +532,40 @@ async def submit_and_wait_for_bcs_transaction(
         txn_hash = await self.submit_bcs_transaction(signed_transaction)
         await self.wait_for_transaction(txn_hash)
         return await self.transaction_by_hash(txn_hash)
-    
+
     async def submit_orderless_transaction(
-    self,
-    sender: Account,
-    payload: TransactionPayload,
-    nonce: Optional[int] = None,
-    wait: bool = False
-    ) -> str:        
-        
+        self,
+        sender: Account,
+        payload: TransactionPayload,
+        nonce: Optional[int] = None,
+        multisig_address: Optional[AccountAddress] = None,
+        wait: bool = False,
+    ) -> str:
+
         if nonce is None:
-            raise ValueError("Nonce required for orderless")
-        
-        if not isinstance(payload.value, EntryFunction):
-            raise ValueError("Only EntryFunction supported for orderless")
-        
+            nonce = secrets.randbits(64)
+
+            # Extract executable from payload (can be None for multisig voting)
+        executable = payload.value if payload.value else None
+
+        if executable is not None and not isinstance(
+            executable, (EntryFunction, Script)
+        ):
+            raise ValueError(
+                "Orderless transactions only support EntryFunction and Script payloads"
+            )
+
+        # Create orderless payload
+        orderless = OrderlessPayload(executable, nonce, multisig_address)
+
         orderless = OrderlessPayload(payload.value, nonce)
-        
+
         chain_id = await self.chain_id()
 
-        # Orderless transactions typically have shorter expiration windows (e.g., 30 seconds)
+        # Orderless transactions typically have shorter expiration windows (60 seconds)
         # Use a much shorter TTL than regular transactions
-        orderless_expiration_ttl = 30  # 30 seconds
-        
+        orderless_expiration_ttl = 60
+
         raw_txn = RawTransaction(
             sender=sender.address(),
             sequence_number=0xDEADBEEF,
@@ -562,15 +575,15 @@ async def submit_orderless_transaction(
             expiration_timestamps_secs=int(time.time()) + orderless_expiration_ttl,
             chain_id=chain_id,
         )
-        
+
         authenticator = sender.sign_transaction(raw_txn)
         signed_txn = SignedTransaction(raw_txn, authenticator)
-        
+
         tx_hash = await self.submit_bcs_transaction(signed_txn)
-        
+
         if wait:
             await self.wait_for_transaction(tx_hash)
-        
+
         return tx_hash
 
     async def transaction_pending(self, txn_hash: str) -> bool:

aptos_sdk/transactions.py

@@ -253,7 +253,7 @@ class TransactionPayload:
     SCRIPT: int = 0
     MODULE_BUNDLE: int = 1
     SCRIPT_FUNCTION: int = 2
-    INNER_PAYLOAD: int = 4 
+    INNER_PAYLOAD: int = 4
 
     variant: int
     value: Any
@@ -265,7 +265,7 @@ def __init__(self, payload: Any):
             self.variant = TransactionPayload.MODULE_BUNDLE
         elif isinstance(payload, EntryFunction):
             self.variant = TransactionPayload.SCRIPT_FUNCTION
-        elif isinstance(payload, OrderlessPayload):  
+        elif isinstance(payload, OrderlessPayload):
             self.variant = TransactionPayload.INNER_PAYLOAD
         else:
             raise Exception("Invalid type")
@@ -298,6 +298,7 @@ def serialize(self, serializer: Serializer) -> None:
         serializer.uleb128(self.variant)
         self.value.serialize(serializer)
 
+
 class ModuleBundle:
     def __init__(self):
         raise NotImplementedError
@@ -479,45 +480,95 @@ def serialize(self, serializer: Serializer) -> None:
         serializer.sequence(self.ty_args, Serializer.struct)
         serializer.sequence(self.args, Serializer.to_bytes)
 
+
 class OrderlessPayload:
     """Orderless transaction payload wrapper"""
-    
-    def __init__(self, entry_function: EntryFunction, nonce: int):
-        self.entry_function = entry_function
+
+    # OrderlessTransactionPayload variants
+    ORDERLESS_V1: int = 0
+
+    # Executable variants
+    EXECUTABLE_SCRIPT: int = 0
+    EXECUTABLE_ENTRY_FUNCTION: int = 1
+    EXECUTABLE_EMPTY: int = 2  # For multisig voting without execution
+
+    # ExtraConfig variants
+    EXTRA_CONFIG_V1: int = 0
+
+    def __init__(
+        self,
+        executable: Optional[Union[Script, EntryFunction]],
+        nonce: int,
+        multisig_address: Optional[AccountAddress] = None,
+    ):
+        """
+        Create an orderless transaction payload.
+
+        :param executable: Script or EntryFunction to execute. None for multisig voting.
+        :param nonce: Unique nonce for replay protection
+        :param multisig_address: Address of multisig account (required for multisig transactions)
+        """
+        if executable is not None and not isinstance(
+            executable, (Script, EntryFunction)
+        ):
+            raise ValueError("Executable must be either Script or EntryFunction")
+
+        # If no executable, must be multisig voting
+        if executable is None and multisig_address is None:
+            raise ValueError("Either executable or multisig_address must be provided")
+
+        self.executable = executable
         self.nonce = nonce
-    
+        self.multisig_address = multisig_address
+
     def serialize(self, serializer: Serializer):
         """Serialize orderless payload WITHOUT the outer variant (TransactionPayload handles that)"""
-        
+
         # OrderlessTransactionPayload::V1 variant
-        serializer.uleb128(0)
-        
-        # Executable::EntryFunction variant
-        serializer.uleb128(1)
-        
-        # Serialize the entry function
-        self.entry_function.serialize(serializer)
-        
+        serializer.uleb128(OrderlessPayload.ORDERLESS_V1)
+
+        # Executable variant
+        if self.executable is None:
+            # Empty executable for multisig voting
+            serializer.uleb128(OrderlessPayload.EXECUTABLE_EMPTY)
+        elif isinstance(self.executable, Script):
+            serializer.uleb128(OrderlessPayload.EXECUTABLE_SCRIPT)
+            self.executable.serialize(serializer)
+        elif isinstance(self.executable, EntryFunction):
+            serializer.uleb128(OrderlessPayload.EXECUTABLE_ENTRY_FUNCTION)
+            self.executable.serialize(serializer)
+        else:
+            raise ValueError("Invalid executable type")
+
         # ExtraConfig::V1 variant
-        serializer.uleb128(0)
-        
-        # Option<MultisigAddress> - None
-        serializer.bool(False)
-        
+        serializer.uleb128(OrderlessPayload.EXTRA_CONFIG_V1)
+
+        # Option<MultisigAddress>
+        if self.multisig_address is not None:
+            serializer.bool(True)  # Some
+            self.multisig_address.serialize(serializer)
+        else:
+            serializer.bool(False)  # None
+
         # Option<u64> nonce - Some
         serializer.bool(True)
         serializer.u64(self.nonce)
-    
+
     def __eq__(self, other: object) -> bool:
         if not isinstance(other, OrderlessPayload):
             return NotImplemented
         return (
-            self.entry_function == other.entry_function 
+            self.executable == other.executable
             and self.nonce == other.nonce
+            and self.multisig_address == other.multisig_address
         )
-    
+
     def __str__(self):
-        return f"OrderlessPayload(nonce={self.nonce}, {self.entry_function})"
+        multisig_str = (
+            f", multisig={self.multisig_address}" if self.multisig_address else ""
+        )
+        return f"OrderlessPayload(nonce={self.nonce}, {self.executable}{multisig_str})"
+
 
 class ModuleId:
     address: AccountAddress
@@ -939,4 +990,4 @@ def test_deserialize_raw_transaction_multi_agent(self):
         raw_txn_with_data.serialize(ser)
         self.assertEqual(ser.output().hex(), input_ma)
 
-        self.assertTrue(isinstance(raw_txn_with_data, MultiAgentRawTransaction))
+        self.assertTrue(isinstance(raw_txn_with_data, MultiAgentRawTransaction))