feat: implement API for contracts to initiate outgoing transfers

Author: SIDDHANTCOOKIE

minichain/contract.py

@@ -45,6 +45,17 @@ def _safe_exec_worker(code, globals_dict, context_dict, result_queue, gas_limit)
         except (OSError, ValueError) as e:
             logger.warning("Failed to set resource limits: %s", e)
 
+        transfers = []
+        
+        def transfer_out(address, amount):
+            if not isinstance(amount, int) or amount <= 0:
+                raise ValueError("Invalid transfer amount")
+            if not isinstance(address, str):
+                raise ValueError("Invalid address type")
+            transfers.append({"to": address, "amount": amount})
+            
+        globals_dict["__builtins__"]["transfer_out"] = transfer_out
+
         meter = GasMeter(gas_limit)
         sys.settrace(meter.trace_calls)
 
@@ -54,7 +65,7 @@ def _safe_exec_worker(code, globals_dict, context_dict, result_queue, gas_limit)
             sys.settrace(None)
 
         gas_used = meter.initial_gas - meter.gas
-        result_queue.put({"status": "success", "storage": context_dict.get("storage"), "gas_used": gas_used})
+        result_queue.put({"status": "success", "storage": context_dict.get("storage"), "transfers": transfers, "gas_used": gas_used})
     except OutOfGasException as e:
         result_queue.put({"status": "error", "error": "Out of gas!", "gas_used": gas_limit})
     except Exception as e:
@@ -172,13 +183,7 @@ def execute(self, contract_address, sender_address, payload, amount, gas_limit):
                 logger.error("Contract storage not JSON serializable")
                 return {"success": False, "gas_used": result.get("gas_used", gas_limit), "error": "Storage not JSON serializable"}
 
-            # Commit updated storage only after successful execution
-            self.state.update_contract_storage(
-                contract_address,
-                result["storage"]
-            )
-
-            return {"success": True, "gas_used": result["gas_used"], "error": None}
+            return {"success": True, "gas_used": result["gas_used"], "transfers": result.get("transfers", []), "storage": result["storage"], "error": None}
 
         except Exception as e:
             logger.error("Contract Execution Failed", exc_info=True)

minichain/state.py

@@ -157,6 +157,23 @@ def apply_transaction(self, tx):
                 sender['balance'] += tx.amount # Refund amount
                 return Receipt(tx.tx_id, status=0, error_message=result.get("error", "Execution failed"), gas_used=gas_used)
 
+            transfers = result.get("transfers", [])
+            total_transferred_out = sum(t["amount"] for t in transfers)
+
+            if total_transferred_out > receiver['balance']:
+                # Rollback transfer if execution attempts to spend more than balance
+                receiver['balance'] -= tx.amount
+                sender['balance'] += tx.amount # Refund amount
+                return Receipt(tx.tx_id, status=0, error_message="Insufficient contract balance for transfers", gas_used=gas_used)
+
+            # Execution & transfers valid: commit state changes atomically
+            self.update_contract_storage(tx.receiver, result["storage"])
+            
+            receiver['balance'] -= total_transferred_out
+            for t in transfers:
+                target_acc = self.get_account(t["to"])
+                target_acc['balance'] += t["amount"]
+
             return Receipt(tx.tx_id, status=1, gas_used=gas_used)
 
         # LOGIC BRANCH 3: Regular Transfer

tests/test_contract_transfers.py

@@ -0,0 +1,105 @@
+import unittest
+from nacl.signing import SigningKey
+from nacl.encoding import HexEncoder
+from minichain.state import State
+from minichain.block import Transaction
+
+class TestContractTransfers(unittest.TestCase):
+    def setUp(self):
+        self.state = State()
+        self.sender_sk = SigningKey.generate()
+        self.sender_pk = self.sender_sk.verify_key.encode(encoder=HexEncoder).decode()
+        
+        self.target_pk = SigningKey.generate().verify_key.encode(encoder=HexEncoder).decode()
+        
+        # Credit sender with enough balance to deploy and call
+        self.state.credit_mining_reward(self.sender_pk, 10000)
+
+    def _sign(self, tx):
+        tx.sign(self.sender_sk)
+        return tx
+
+    def test_successful_transfer_out(self):
+        # 1. Deploy Contract
+        code = """
+target = msg['data']['target']
+transfer_out(target, 50)
+transfer_out(target, 25)
+"""
+        deploy_tx = self._sign(Transaction(self.sender_pk, None, amount=100, nonce=0, data=code, fee=1000))
+        receipt = self.state.apply_transaction(deploy_tx)
+        self.assertEqual(receipt.status, 1)
+        contract_addr = receipt.contract_address
+
+        # Sender sent 100 to contract, plus 10 fee
+        self.assertEqual(self.state.get_account(contract_addr)['balance'], 100)
+        self.assertEqual(self.state.get_account(self.target_pk)['balance'], 0)
+
+        # 2. Call Contract to transfer out 75 coins
+        call_tx = self._sign(Transaction(self.sender_pk, contract_addr, amount=0, nonce=1, data={"target": self.target_pk}, fee=1000))
+        receipt2 = self.state.apply_transaction(call_tx)
+        
+        self.assertEqual(receipt2.status, 1)
+        
+        # Contract balance should be 100 - 75 = 25
+        self.assertEqual(self.state.get_account(contract_addr)['balance'], 25)
+        
+        # Target should have 75
+        self.assertEqual(self.state.get_account(self.target_pk)['balance'], 75)
+
+    def test_failed_transfer_out_insufficient_balance(self):
+        # 1. Deploy Contract
+        code = """
+target = msg['data']['target']
+# Try to transfer 500, but contract only has 100
+transfer_out(target, 500)
+storage['malicious_state'] = 'corrupted'
+"""
+        deploy_tx = self._sign(Transaction(self.sender_pk, None, amount=100, nonce=0, data=code, fee=1000))
+        receipt = self.state.apply_transaction(deploy_tx)
+        self.assertEqual(receipt.status, 1)
+        contract_addr = receipt.contract_address
+
+        # 2. Call Contract
+        call_tx = self._sign(Transaction(self.sender_pk, contract_addr, amount=0, nonce=1, data={"target": self.target_pk}, fee=1000))
+        receipt2 = self.state.apply_transaction(call_tx)
+        
+        # Should fail with status 0
+        self.assertEqual(receipt2.status, 0)
+        self.assertEqual(receipt2.error_message, "Insufficient contract balance for transfers")
+
+        # State should be completely rolled back (target balance 0, contract balance remains 100)
+        self.assertEqual(self.state.get_account(contract_addr)['balance'], 100)
+        self.assertEqual(self.state.get_account(self.target_pk)['balance'], 0)
+        
+        # Storage should NOT be updated
+        self.assertEqual(self.state.get_account(contract_addr)['storage'], {})
+
+    def test_transfer_with_incoming_funds(self):
+        # 1. Deploy Contract (0 initial balance)
+        code = """
+target = msg['data']['target']
+# We use the incoming funds to instantly transfer out!
+transfer_out(target, msg['value'])
+"""
+        deploy_tx = self._sign(Transaction(self.sender_pk, None, amount=0, nonce=0, data=code, fee=1000))
+        receipt = self.state.apply_transaction(deploy_tx)
+        self.assertEqual(receipt.status, 1)
+        contract_addr = receipt.contract_address
+
+        self.assertEqual(self.state.get_account(contract_addr)['balance'], 0)
+
+        # 2. Call Contract sending 50 coins
+        call_tx = self._sign(Transaction(self.sender_pk, contract_addr, amount=50, nonce=1, data={"target": self.target_pk}, fee=1000))
+        receipt2 = self.state.apply_transaction(call_tx)
+        
+        self.assertEqual(receipt2.status, 1)
+        
+        # Contract balance should be 0 (received 50, sent 50)
+        self.assertEqual(self.state.get_account(contract_addr)['balance'], 0)
+        
+        # Target should have exactly 50
+        self.assertEqual(self.state.get_account(self.target_pk)['balance'], 50)
+
+if __name__ == '__main__':
+    unittest.main()