algokit-utils 3.0.0b9__py3-none-any.whl → 3.0.0b11__py3-none-any.whl

algokit_utils/transactions/transaction_sender.py

@@ -59,15 +59,28 @@ class SendSingleTransactionResult:
     """
 
     transaction: TransactionWrapper  # Last transaction
+    """The last transaction"""
+
     confirmation: algosdk.v2client.algod.AlgodResponseType  # Last confirmation
+    """The last confirmation"""
 
     # Fields from SendAtomicTransactionComposerResults
     group_id: str
+    """The group ID"""
+
     tx_id: str | None = None
+    """The transaction ID"""
+
     tx_ids: list[str]  # Full array of transaction IDs
+    """The full array of transaction IDs"""
     transactions: list[TransactionWrapper]
+    """The full array of transactions"""
+
     confirmations: list[algosdk.v2client.algod.AlgodResponseType]
+    """The full array of confirmations"""
+
     returns: list[ABIReturn] | None = None
+    """The ABI return value if applicable"""
 
     @classmethod
     def from_composer_result(cls, result: SendAtomicTransactionComposerResults, index: int = -1) -> Self:
@@ -111,6 +124,7 @@ class SendSingleAssetCreateTransactionResult(SendSingleTransactionResult):
     """
 
     asset_id: int
+    """The ID of the newly created asset"""
 
 
 ABIReturnT = TypeVar("ABIReturnT")
@@ -124,6 +138,7 @@ class SendAppTransactionResult(SendSingleTransactionResult, Generic[ABIReturnT])
     """
 
     abi_return: ABIReturnT | None = None
+    """The ABI return value if applicable"""
 
 
 @dataclass(frozen=True)
@@ -134,7 +149,10 @@ class SendAppUpdateTransactionResult(SendAppTransactionResult[ABIReturnT]):
     """
 
     compiled_approval: Any | None = None
+    """The compiled approval program"""
+
     compiled_clear: Any | None = None
+    """The compiled clear state program"""
 
 
 @dataclass(frozen=True, kw_only=True)
@@ -145,7 +163,10 @@ class SendAppCreateTransactionResult(SendAppUpdateTransactionResult[ABIReturnT])
     """
 
     app_id: int
+    """The ID of the newly created application"""
+
     app_address: str
+    """The address of the newly created application"""
 
 
 class AlgorandClientTransactionSender:
@@ -171,6 +192,12 @@ class AlgorandClientTransactionSender:
         """Create a new transaction group.
 
         :return: A new TransactionComposer instance
+
+        :example:
+            >>> sender = AlgorandClientTransactionSender(new_group, asset_manager, app_manager, algod_client)
+            >>> composer = sender.new_group()
+            >>> composer(PaymentParams(sender="sender", receiver="receiver", amount=AlgoAmount(algo=1)))
+            >>> composer.send()
         """
         return self._new_group()
 
@@ -292,6 +319,33 @@ class AlgorandClientTransactionSender:
         :param params: Payment transaction parameters
         :param send_params: Send parameters
         :return: Result of the payment transaction
+
+        :example:
+            >>> result = algorand.send.payment(PaymentParams(
+            >>>  sender="SENDERADDRESS",
+            >>>  receiver="RECEIVERADDRESS",
+            >>>  amount=AlgoAmount(algo=4),
+            >>> ))
+
+            >>> # Advanced example
+            >>> result =  algorand.send.payment(PaymentParams(
+            >>>  amount=AlgoAmount(algo=4),
+            >>>  receiver="RECEIVERADDRESS",
+            >>>  sender="SENDERADDRESS",
+            >>>  close_remainder_to="CLOSEREMAINDERTOADDRESS",
+            >>>  lease="lease",
+            >>>  note="note",
+            >>>  rekey_to="REKEYTOADDRESS",
+            >>>  first_valid_round=1000,
+            >>>  validity_window=10,
+            >>>  extra_fee=AlgoAmount(micro_algo=1000),
+            >>>  static_fee=AlgoAmount(micro_algo=1000),
+            >>>  max_fee=AlgoAmount(micro_algo=3000),
+            >>>  signer=transactionSigner
+            >>> ), send_params=SendParams(
+            >>>  max_rounds_to_wait_for_confirmation=5,
+            >>>  suppress_log=True,
+            >>> ))
         """
         return self._send(
             lambda c: c.add_payment,
@@ -309,6 +363,47 @@ class AlgorandClientTransactionSender:
         :param params: Asset creation parameters
         :param send_params: Send parameters
         :return: Result containing the new asset ID
+
+        :example:
+            >>> result = algorand.send.asset_create(AssetCreateParams(
+            >>>  sender="SENDERADDRESS",
+            >>>  asset_name="ASSETNAME",
+            >>>  unit_name="UNITNAME",
+            >>>  total=1000,
+            >>> ))
+
+            >>> # Advanced example
+            >>> result = algorand.send.asset_create(AssetCreateParams(
+            >>>  sender="CREATORADDRESS",
+            >>>  total=100,
+            >>>  decimals=2,
+            >>>  asset_name="asset",
+            >>>  unit_name="unit",
+            >>>  url="url",
+            >>>  metadata_hash="metadataHash",
+            >>>  default_frozen=False,
+            >>>  manager="MANAGERADDRESS",
+            >>>  reserve="RESERVEADDRESS",
+            >>>  freeze="FREEZEADDRESS",
+            >>>  clawback="CLAWBACKADDRESS",
+            >>>  lease="lease",
+            >>>  note="note",
+            >>>  # You wouldn't normally set this field
+            >>>  first_valid_round=1000,
+            >>>  validity_window=10,
+            >>>  extra_fee=AlgoAmount(micro_algo=1000),
+            >>>  static_fee=AlgoAmount(micro_algo=1000),
+            >>>  # Max fee doesn't make sense with extraFee AND staticFee
+            >>>  #  already specified, but here for completeness
+            >>>  max_fee=AlgoAmount(micro_algo=3000),
+            >>>  # Signer only needed if you want to provide one,
+            >>>  #  generally you'd register it with AlgorandClient
+            >>>  #  against the sender and not need to pass it in
+            >>>  signer=transactionSigner
+            >>> ), send_params=SendParams(
+            >>>  max_rounds_to_wait_for_confirmation=5,
+            >>>  suppress_log=True,
+            >>> ))
         """
         result = self._send(
             lambda c: c.add_asset_create,
@@ -334,6 +429,33 @@ class AlgorandClientTransactionSender:
         :param params: Asset configuration parameters
         :param send_params: Send parameters
         :return: Result of the configuration transaction
+
+        :example:
+            >>> result = algorand.send.asset_config(AssetConfigParams(
+            >>>  sender="MANAGERADDRESS",
+            >>>  asset_id=123456,
+            >>>  manager="MANAGERADDRESS",
+            >>>  reserve="RESERVEADDRESS",
+            >>>  freeze="FREEZEADDRESS",
+            >>>  clawback="CLAWBACKADDRESS",
+            >>>  lease="lease",
+            >>>  note="note",
+            >>>  # You wouldn't normally set this field
+            >>>  first_valid_round=1000,
+            >>>  validity_window=10,
+            >>>  extra_fee=AlgoAmount(micro_algo=1000),
+            >>>  static_fee=AlgoAmount(micro_algo=1000),
+            >>>  # Max fee doesn't make sense with extraFee AND staticFee
+            >>>  #  already specified, but here for completeness
+            >>>  max_fee=AlgoAmount(micro_algo=3000),
+            >>>  # Signer only needed if you want to provide one,
+            >>>  #  generally you'd register it with AlgorandClient
+            >>>  #  against the sender and not need to pass it in
+            >>>  signer=transactionSigner
+            >>> ), send_params=SendParams(
+            >>>  max_rounds_to_wait_for_confirmation=5,
+            >>>  suppress_log=True,
+            >>> ))
         """
         return self._send(
             lambda c: c.add_asset_config,
@@ -350,6 +472,39 @@ class AlgorandClientTransactionSender:
         :param params: Asset freeze parameters
         :param send_params: Send parameters
         :return: Result of the freeze transaction
+
+        :example:
+            >>> result = algorand.send.asset_freeze(AssetFreezeParams(
+            >>>  sender="MANAGERADDRESS",
+            >>>  asset_id=123456,
+            >>>  account="ACCOUNTADDRESS",
+            >>>  frozen=True,
+            >>> ))
+
+            >>> # Advanced example
+            >>> result = algorand.send.asset_freeze(AssetFreezeParams(
+            >>>  sender="MANAGERADDRESS",
+            >>>  asset_id=123456,
+            >>>  account="ACCOUNTADDRESS",
+            >>>  frozen=True,
+            >>>  lease="lease",
+            >>>  note="note",
+            >>>  # You wouldn't normally set this field
+            >>>  first_valid_round=1000,
+            >>>  validity_window=10,
+            >>>  extra_fee=AlgoAmount(micro_algo=1000),
+            >>>  static_fee=AlgoAmount(micro_algo=1000),
+            >>>  # Max fee doesn't make sense with extraFee AND staticFee
+            >>>  #  already specified, but here for completeness
+            >>>  max_fee=AlgoAmount(micro_algo=3000),
+            >>>  # Signer only needed if you want to provide one,
+            >>>  #  generally you'd register it with AlgorandClient
+            >>>  #  against the sender and not need to pass it in
+            >>>  signer=transactionSigner
+            >>> ), send_params=SendParams(
+            >>>  max_rounds_to_wait_for_confirmation=5,
+            >>>  suppress_log=True,
+            >>> ))
         """
         return self._send(
             lambda c: c.add_asset_freeze,
@@ -366,6 +521,35 @@ class AlgorandClientTransactionSender:
         :param params: Asset destruction parameters
         :param send_params: Send parameters
         :return: Result of the destroy transaction
+
+        :example:
+            >>> result = algorand.send.asset_destroy(AssetDestroyParams(
+            >>>  sender="MANAGERADDRESS",
+            >>>  asset_id=123456,
+            >>> ))
+
+            >>> # Advanced example
+            >>> result = algorand.send.asset_destroy(AssetDestroyParams(
+            >>>  sender="MANAGERADDRESS",
+            >>>  asset_id=123456,
+            >>>  lease="lease",
+            >>>  note="note",
+            >>>  # You wouldn't normally set this field
+            >>>  first_valid_round=1000,
+            >>>  validity_window=10,
+            >>>  extra_fee=AlgoAmount(micro_algo=1000),
+            >>>  static_fee=AlgoAmount(micro_algo=1000),
+            >>>  # Max fee doesn't make sense with extraFee AND staticFee
+            >>>  #  already specified, but here for completeness
+            >>>  max_fee=AlgoAmount(micro_algo=3000),
+            >>>  # Signer only needed if you want to provide one,
+            >>>  #  generally you'd register it with AlgorandClient
+            >>>  #  against the sender and not need to pass it in
+            >>>  signer=transactionSigner
+            >>> ), send_params=SendParams(
+            >>>  max_rounds_to_wait_for_confirmation=5,
+            >>>  suppress_log=True,
+            >>> ))
         """
         return self._send(
             lambda c: c.add_asset_destroy,
@@ -382,6 +566,42 @@ class AlgorandClientTransactionSender:
         :param params: Asset transfer parameters
         :param send_params: Send parameters
         :return: Result of the transfer transaction
+
+        :example:
+            >>> result = algorand.send.asset_transfer(AssetTransferParams(
+            >>>  sender="HOLDERADDRESS",
+            >>>  asset_id=123456,
+            >>>  amount=1,
+            >>>  receiver="RECEIVERADDRESS",
+            >>> ))
+
+            >>> # Advanced example (with clawback)
+            >>> result = algorand.send.asset_transfer(AssetTransferParams(
+            >>>  sender="CLAWBACKADDRESS",
+            >>>  asset_id=123456,
+            >>>  amount=1,
+            >>>  receiver="RECEIVERADDRESS",
+            >>>  clawback_target="HOLDERADDRESS",
+            >>>  # This field needs to be used with caution
+            >>>  close_asset_to="ADDRESSTOCLOSETO",
+            >>>  lease="lease",
+            >>>  note="note",
+            >>>  # You wouldn't normally set this field
+            >>>  first_valid_round=1000,
+            >>>  validity_window=10,
+            >>>  extra_fee=AlgoAmount(micro_algo=1000),
+            >>>  static_fee=AlgoAmount(micro_algo=1000),
+            >>>  # Max fee doesn't make sense with extraFee AND staticFee
+            >>>  #  already specified, but here for completeness
+            >>>  max_fee=AlgoAmount(micro_algo=3000),
+            >>>  # Signer only needed if you want to provide one,
+            >>>  #  generally you'd register it with AlgorandClient
+            >>>  #  against the sender and not need to pass it in
+            >>>  signer=transactionSigner
+            >>> ), send_params=SendParams(
+            >>>  max_rounds_to_wait_for_confirmation=5,
+            >>>  suppress_log=True,
+            >>> ))
         """
         return self._send(
             lambda c: c.add_asset_transfer,
@@ -399,6 +619,35 @@ class AlgorandClientTransactionSender:
         :param params: Asset opt-in parameters
         :param send_params: Send parameters
         :return: Result of the opt-in transaction
+
+        :example:
+            >>> result = algorand.send.asset_opt_in(AssetOptInParams(
+            >>>  sender="SENDERADDRESS",
+            >>>  asset_id=123456,
+            >>> ))
+
+            >>> # Advanced example
+            >>> result = algorand.send.asset_opt_in(AssetOptInParams(
+            >>>  sender="SENDERADDRESS",
+            >>>  asset_id=123456,
+            >>>  lease="lease",
+            >>>  note="note",
+            >>>  # You wouldn't normally set this field
+            >>>  first_valid_round=1000,
+            >>>  validity_window=10,
+            >>>  extra_fee=AlgoAmount(micro_algo=1000),
+            >>>  static_fee=AlgoAmount(micro_algo=1000),
+            >>>  # Max fee doesn't make sense with extraFee AND staticFee
+            >>>  #  already specified, but here for completeness
+            >>>  max_fee=AlgoAmount(micro_algo=3000),
+            >>>  # Signer only needed if you want to provide one,
+            >>>  #  generally you'd register it with AlgorandClient
+            >>>  #  against the sender and not need to pass it in
+            >>>  signer=transactionSigner
+            >>> ), send_params=SendParams(
+            >>>  max_rounds_to_wait_for_confirmation=5,
+            >>>  suppress_log=True,
+            >>> ))
         """
         return self._send(
             lambda c: c.add_asset_opt_in,
@@ -422,6 +671,39 @@ class AlgorandClientTransactionSender:
         :param ensure_zero_balance: Check if account has zero balance before opt-out, defaults to True
         :raises ValueError: If account has non-zero balance or is not opted in
         :return: Result of the opt-out transaction
+
+        :example:
+            >>> result = algorand.send.asset_opt_out(AssetOptOutParams(
+            >>>  sender="SENDERADDRESS",
+            >>>  creator="CREATORADDRESS",
+            >>>  asset_id=123456,
+            >>>  ensure_zero_balance=True,
+            >>> ))
+
+            >>> # Advanced example
+            >>> result = algorand.send.asset_opt_out(AssetOptOutParams(
+            >>>  sender="SENDERADDRESS",
+            >>>  asset_id=123456,
+            >>>  creator="CREATORADDRESS",
+            >>>  ensure_zero_balance=True,
+            >>>  lease="lease",
+            >>>  note="note",
+            >>>  # You wouldn't normally set this field
+            >>>  first_valid_round=1000,
+            >>>  validity_window=10,
+            >>>  extra_fee=AlgoAmount(micro_algo=1000),
+            >>>  static_fee=AlgoAmount(micro_algo=1000),
+            >>>  # Max fee doesn't make sense with extraFee AND staticFee
+            >>>  #  already specified, but here for completeness
+            >>>  max_fee=AlgoAmount(micro_algo=3000),
+            >>>  # Signer only needed if you want to provide one,
+            >>>  #  generally you'd register it with AlgorandClient
+            >>>  #  against the sender and not need to pass it in
+            >>>  signer=transactionSigner
+            >>> ), send_params=SendParams(
+            >>>  max_rounds_to_wait_for_confirmation=5,
+            >>>  suppress_log=True,
+            >>> ))
         """
         if ensure_zero_balance:
             try:
@@ -461,6 +743,55 @@ class AlgorandClientTransactionSender:
         :param params: Application creation parameters
         :param send_params: Send parameters
         :return: Result containing the new application ID and address
+
+        :example:
+            >>> result = algorand.send.app_create(AppCreateParams(
+            >>>  sender="CREATORADDRESS",
+            >>>  approval_program="TEALCODE",
+            >>>  clear_state_program="TEALCODE",
+            >>> ))
+
+            >>> # Advanced example
+            >>> result = algorand.send.app_create(AppCreateParams(
+            >>>  sender="CREATORADDRESS",
+            >>>  approval_program="TEALCODE",
+            >>>  clear_state_program="TEALCODE",
+            >>> ))
+            >>> # algorand.send.appCreate(AppCreateParams(
+            >>> #  sender='CREATORADDRESS',
+            >>> #  approval_program="TEALCODE",
+            >>> #  clear_state_program="TEALCODE",
+            >>> #  schema={
+            >>> #    "global_ints": 1,
+            >>> #    "global_byte_slices": 2,
+            >>> #    "local_ints": 3,
+            >>> #    "local_byte_slices": 4
+            >>> #  },
+            >>> #  extra_program_pages: 1,
+            >>> #  on_complete: algosdk.transaction.OnComplete.OptInOC,
+            >>> #  args: [b'some_bytes']
+            >>> #  account_references: ["ACCOUNT_1"]
+            >>> #  app_references: [123, 1234]
+            >>> #  asset_references: [12345]
+            >>> #  box_references: ["box1", {app_id: 1234, name: "box2"}]
+            >>> #  lease: 'lease',
+            >>> #  note: 'note',
+            >>> #  # You wouldn't normally set this field
+            >>> #  first_valid_round: 1000,
+            >>> #  validity_window: 10,
+            >>> #  extra_fee: AlgoAmount(micro_algo=1000),
+            >>> #  static_fee: AlgoAmount(micro_algo=1000),
+            >>> #  # Max fee doesn't make sense with extraFee AND staticFee
+            >>> #  #  already specified, but here for completeness
+            >>> #  max_fee: AlgoAmount(micro_algo=3000),
+            >>> #  # Signer only needed if you want to provide one,
+            >>> #  #  generally you'd register it with AlgorandClient
+            >>> #  #  against the sender and not need to pass it in
+            >>> #  signer: transactionSigner
+            >>> #}, send_params=SendParams(
+            >>> #  max_rounds_to_wait_for_confirmation=5,
+            >>> #  suppress_log=True,
+            >>> #))
         """
         return self._send_app_create_call(lambda c: c.add_app_create)(params, send_params)
 
@@ -472,6 +803,43 @@ class AlgorandClientTransactionSender:
         :param params: Application update parameters
         :param send_params: Send parameters
         :return: Result containing the compiled programs
+
+        :example:
+            >>> # Basic example
+            >>> algorand.send.app_update(AppUpdateParams(
+            >>>  sender="CREATORADDRESS",
+            >>>  approval_program="TEALCODE",
+            >>>  clear_state_program="TEALCODE",
+            >>> ))
+            >>> # Advanced example
+            >>> algorand.send.app_update(AppUpdateParams(
+            >>>  sender="CREATORADDRESS",
+            >>>  approval_program="TEALCODE",
+            >>>  clear_state_program="TEALCODE",
+            >>>  on_complete=OnComplete.UpdateApplicationOC,
+            >>>  args=[b'some_bytes'],
+            >>>  account_references=["ACCOUNT_1"],
+            >>>  app_references=[123, 1234],
+            >>>  asset_references=[12345],
+            >>>  box_references=[...],
+            >>>  lease="lease",
+            >>>  note="note",
+            >>>  # You wouldn't normally set this field
+            >>>  first_valid_round=1000,
+            >>>  validity_window=10,
+            >>>  extra_fee=AlgoAmount(micro_algo=1000),
+            >>>  static_fee=AlgoAmount(micro_algo=1000),
+            >>>  # Max fee doesn't make sense with extraFee AND staticFee
+            >>>  #  already specified, but here for completeness
+            >>>  max_fee=AlgoAmount(micro_algo=3000),
+            >>>  # Signer only needed if you want to provide one,
+            >>>  #  generally you'd register it with AlgorandClient
+            >>>  #  against the sender and not need to pass it in
+            >>>  signer=transactionSigner
+            >>> ), send_params=SendParams(
+            >>>  max_rounds_to_wait_for_confirmation=5,
+            >>>  suppress_log=True,
+            >>> ))
         """
         return self._send_app_update_call(lambda c: c.add_app_update)(params, send_params)
 
@@ -483,6 +851,40 @@ class AlgorandClientTransactionSender:
         :param params: Application deletion parameters
         :param send_params: Send parameters
         :return: Result of the deletion transaction
+
+        :example:
+            >>> # Basic example
+            >>> algorand.send.app_delete(AppDeleteParams(
+            >>>  sender="CREATORADDRESS",
+            >>>  app_id=123456,
+            >>> ))
+            >>> # Advanced example
+            >>> algorand.send.app_delete(AppDeleteParams(
+            >>>  sender="CREATORADDRESS",
+            >>>  on_complete=OnComplete.DeleteApplicationOC,
+            >>>  args=[b'some_bytes'],
+            >>>  account_references=["ACCOUNT_1"],
+            >>>  app_references=[123, 1234],
+            >>>  asset_references=[12345],
+            >>>  box_references=[...],
+            >>>  lease="lease",
+            >>>  note="note",
+            >>>  # You wouldn't normally set this field
+            >>>  first_valid_round=1000,
+            >>>  validity_window=10,
+            >>>  extra_fee=AlgoAmount(micro_algo=1000),
+            >>>  static_fee=AlgoAmount(micro_algo=1000),
+            >>>  # Max fee doesn't make sense with extraFee AND staticFee
+            >>>  #  already specified, but here for completeness
+            >>>  max_fee=AlgoAmount(micro_algo=3000),
+            >>>  # Signer only needed if you want to provide one,
+            >>>  #  generally you'd register it with AlgorandClient
+            >>>  #  against the sender and not need to pass it in
+            >>>  signer=transactionSigner,
+            >>> ), send_params=SendParams(
+            >>>  max_rounds_to_wait_for_confirmation=5,
+            >>>  suppress_log=True,
+            >>> ))
         """
         return self._send_app_call(lambda c: c.add_app_delete)(params, send_params)
 
@@ -494,6 +896,40 @@ class AlgorandClientTransactionSender:
         :param params: Application call parameters
         :param send_params: Send parameters
         :return: Result containing any ABI return value
+
+        :example:
+            >>> # Basic example
+            >>> algorand.send.app_call(AppCallParams(
+            >>>  sender="CREATORADDRESS",
+            >>>  app_id=123456,
+            >>> ))
+            >>> # Advanced example
+            >>> algorand.send.app_call(AppCallParams(
+            >>>  sender="CREATORADDRESS",
+            >>>  on_complete=OnComplete.OptInOC,
+            >>>  args=[b'some_bytes'],
+            >>>  account_references=["ACCOUNT_1"],
+            >>>  app_references=[123, 1234],
+            >>>  asset_references=[12345],
+            >>>  box_references=[...],
+            >>>  lease="lease",
+            >>>  note="note",
+            >>>  # You wouldn't normally set this field
+            >>>  first_valid_round=1000,
+            >>>  validity_window=10,
+            >>>  extra_fee=AlgoAmount(micro_algo=1000),
+            >>>  static_fee=AlgoAmount(micro_algo=1000),
+            >>>  # Max fee doesn't make sense with extraFee AND staticFee
+            >>>  #  already specified, but here for completeness
+            >>>  max_fee=AlgoAmount(micro_algo=3000),
+            >>>  # Signer only needed if you want to provide one,
+            >>>  #  generally you'd register it with AlgorandClient
+            >>>  #  against the sender and not need to pass it in
+            >>>  signer=transactionSigner,
+            >>> ), send_params=SendParams(
+            >>>  max_rounds_to_wait_for_confirmation=5,
+            >>>  suppress_log=True,
+            >>> ))
         """
         return self._send_app_call(lambda c: c.add_app_call)(params, send_params)
 
@@ -505,6 +941,67 @@ class AlgorandClientTransactionSender:
         :param params: Method call parameters for application creation
         :param send_params: Send parameters
         :return: Result containing the new application ID and address
+
+        :example:
+            >>> # Note: you may prefer to use `algorand.client` to get an app client for more advanced functionality.
+            >>> #
+            >>> # @param params The parameters for the app creation transaction
+            >>> # Basic example
+            >>> method = algorand.abi.Method(
+            >>>   name='method',
+            >>>   args=[b'arg1'],
+            >>>   returns='string'
+            >>> )
+            >>> result = algorand.send.app_create_method_call({ sender: 'CREATORADDRESS',
+            >>>   approval_program: 'TEALCODE',
+            >>>   clear_state_program: 'TEALCODE',
+            >>>   method: method,
+            >>>   args: ["arg1_value"] })
+            >>> created_app_id = result.app_id
+            >>> ...
+            >>> # Advanced example
+            >>> method = algorand.abi.Method(
+            >>>   name='method',
+            >>>   args=[b'arg1'],
+            >>>   returns='string'
+            >>> )
+            >>> result = algorand.send.app_create_method_call({
+            >>>  sender: 'CREATORADDRESS',
+            >>>  method: method,
+            >>>  args: ["arg1_value"],
+            >>>  approval_program: "TEALCODE",
+            >>>  clear_state_program: "TEALCODE",
+            >>>  schema: {
+            >>>    "global_ints": 1,
+            >>>    "global_byte_slices": 2,
+            >>>    "local_ints": 3,
+            >>>    "local_byte_slices": 4
+            >>>  },
+            >>>  extra_program_pages: 1,
+            >>>  on_complete: algosdk.transaction.OnComplete.OptInOC,
+            >>>  args: [new Uint8Array(1, 2, 3, 4)],
+            >>>  account_references: ["ACCOUNT_1"],
+            >>>  app_references: [123, 1234],
+            >>>  asset_references: [12345],
+            >>>  box_references: [...],
+            >>>  lease: 'lease',
+            >>>  note: 'note',
+            >>>  # You wouldn't normally set this field
+            >>>  first_valid_round: 1000,
+            >>>  validity_window: 10,
+            >>>  extra_fee: AlgoAmount(micro_algo=1000),
+            >>>  static_fee: AlgoAmount(micro_algo=1000),
+            >>>  # Max fee doesn't make sense with extraFee AND staticFee
+            >>>  #  already specified, but here for completeness
+            >>>  max_fee: AlgoAmount(micro_algo=3000),
+            >>>  # Signer only needed if you want to provide one,
+            >>>  #  generally you'd register it with AlgorandClient
+            >>>  #  against the sender and not need to pass it in
+            >>>  signer: transactionSigner,
+            >>> }, send_params=SendParams(
+            >>>  max_rounds_to_wait_for_confirmation=5,
+            >>>  suppress_log=True,
+            >>> ))
         """
         return self._send_app_create_call(lambda c: c.add_app_create_method_call)(params, send_params)
 
@@ -516,6 +1013,44 @@ class AlgorandClientTransactionSender:
         :param params: Method call parameters for application update
         :param send_params: Send parameters
         :return: Result containing the compiled programs
+
+        :example:
+            # Basic example:
+            >>> method = algorand.abi.Method(
+            ...     name="updateMethod",
+            ...     args=[{"type": "string", "name": "arg1"}],
+            ...     returns="string"
+            ... )
+            >>> params = AppUpdateMethodCallParams(
+            ...     sender="CREATORADDRESS",
+            ...     app_id=123,
+            ...     method=method,
+            ...     args=["new_value"],
+            ...     approval_program="TEALCODE",
+            ...     clear_state_program="TEALCODE"
+            ... )
+            >>> result = algorand.send.app_update_method_call(params)
+            >>> print(result.compiled_approval, result.compiled_clear)
+
+            # Advanced example:
+            >>> method = algorand.abi.Method(
+            ...     name="updateMethod",
+            ...     args=[{"type": "string", "name": "arg1"}, {"type": "uint64", "name": "arg2"}],
+            ...     returns="string"
+            ... )
+            >>> params = AppUpdateMethodCallParams(
+            ...     sender="CREATORADDRESS",
+            ...     app_id=456,
+            ...     method=method,
+            ...     args=["new_value", 42],
+            ...     approval_program="TEALCODE_ADVANCED",
+            ...     clear_state_program="TEALCLEAR_ADVANCED",
+            ...     account_references=["ACCOUNT1", "ACCOUNT2"],
+            ...     app_references=[789],
+            ...     asset_references=[101112]
+            ... )
+            >>> result = algorand.send.app_update_method_call(params)
+            >>> print(result.compiled_approval, result.compiled_clear)
         """
         return self._send_app_update_call(lambda c: c.add_app_update_method_call)(params, send_params)
 
@@ -527,6 +1062,38 @@ class AlgorandClientTransactionSender:
         :param params: Method call parameters for application deletion
         :param send_params: Send parameters
         :return: Result of the deletion transaction
+
+        :example:
+            # Basic example:
+            >>> method = algorand.abi.Method(
+            ...     name="deleteMethod",
+            ...     args=[],
+            ...     returns="void"
+            ... )
+            >>> params = AppDeleteMethodCallParams(
+            ...     sender="CREATORADDRESS",
+            ...     app_id=123,
+            ...     method=method
+            ... )
+            >>> result = algorand.send.app_delete_method_call(params)
+            >>> print(result.tx_id)
+
+            # Advanced example:
+            >>> method = algorand.abi.Method(
+            ...     name="deleteMethod",
+            ...     args=[{"type": "uint64", "name": "confirmation"}],
+            ...     returns="void"
+            ... )
+            >>> params = AppDeleteMethodCallParams(
+            ...     sender="CREATORADDRESS",
+            ...     app_id=123,
+            ...     method=method,
+            ...     args=[1],
+            ...     account_references=["ACCOUNT1"],
+            ...     app_references=[456]
+            ... )
+            >>> result = algorand.send.app_delete_method_call(params)
+            >>> print(result.tx_id)
         """
         return self._send_app_call(lambda c: c.add_app_delete_method_call)(params, send_params)
 
@@ -538,6 +1105,40 @@ class AlgorandClientTransactionSender:
         :param params: Method call parameters
         :param send_params: Send parameters
         :return: Result containing any ABI return value
+
+        :example:
+            # Basic example:
+            >>> method = algorand.abi.Method(
+            ...     name="callMethod",
+            ...     args=[{"type": "uint64", "name": "arg1"}],
+            ...     returns="uint64"
+            ... )
+            >>> params = AppCallMethodCallParams(
+            ...     sender="CALLERADDRESS",
+            ...     app_id=123,
+            ...     method=method,
+            ...     args=[12345]
+            ... )
+            >>> result = algorand.send.app_call_method_call(params)
+            >>> print(result.abi_return)
+
+            # Advanced example:
+            >>> method = algorand.abi.Method(
+            ...     name="callMethod",
+            ...     args=[{"type": "uint64", "name": "arg1"}, {"type": "string", "name": "arg2"}],
+            ...     returns="uint64"
+            ... )
+            >>> params = AppCallMethodCallParams(
+            ...     sender="CALLERADDRESS",
+            ...     app_id=123,
+            ...     method=method,
+            ...     args=[12345, "extra"],
+            ...     account_references=["ACCOUNT1"],
+            ...     asset_references=[101112],
+            ...     app_references=[789]
+            ... )
+            >>> result = algorand.send.app_call_method_call(params)
+            >>> print(result.abi_return)
         """
         return self._send_app_call(lambda c: c.add_app_call_method_call)(params, send_params)
 
@@ -549,6 +1150,32 @@ class AlgorandClientTransactionSender:
         :param params: Key registration parameters
         :param send_params: Send parameters
         :return: Result of the registration transaction
+
+        :example:
+            # Basic example:
+            >>> params = OnlineKeyRegistrationParams(
+            ...     sender="ACCOUNTADDRESS",
+            ...     vote_key="VOTEKEY",
+            ...     selection_key="SELECTIONKEY",
+            ...     vote_first=1000,
+            ...     vote_last=2000,
+            ...     vote_key_dilution=10
+            ... )
+            >>> result = algorand.send.online_key_registration(params)
+            >>> print(result.tx_id)
+
+            # Advanced example:
+            >>> params = OnlineKeyRegistrationParams(
+            ...     sender="ACCOUNTADDRESS",
+            ...     vote_key="VOTEKEY",
+            ...     selection_key="SELECTIONKEY",
+            ...     vote_first=1000,
+            ...     vote_last=2100,
+            ...     vote_key_dilution=10,
+            ...     state_proof_key=b'\x01' * 64
+            ... )
+            >>> result = algorand.send.online_key_registration(params)
+            >>> print(result.tx_id)
         """
         return self._send(
             lambda c: c.add_online_key_registration,
@@ -565,6 +1192,24 @@ class AlgorandClientTransactionSender:
         :param params: Key registration parameters
         :param send_params: Send parameters
         :return: Result of the registration transaction
+
+        :example:
+            # Basic example:
+            >>> params = OfflineKeyRegistrationParams(
+            ...     sender="ACCOUNTADDRESS",
+            ...     prevent_account_from_ever_participating_again=True
+            ... )
+            >>> result = algorand.send.offline_key_registration(params)
+            >>> print(result.tx_id)
+
+            # Advanced example:
+            >>> params = OfflineKeyRegistrationParams(
+            ...     sender="ACCOUNTADDRESS",
+            ...     prevent_account_from_ever_participating_again=True,
+            ...     note=b'Offline registration'
+            ... )
+            >>> result = algorand.send.offline_key_registration(params)
+            >>> print(result.tx_id)
         """
         return self._send(
             lambda c: c.add_offline_key_registration,