Smart contract limitations in Ethereum & Fabric - ethereum

Question

I am trying to make a smart contract to achieve the following automatically. But I stuck in the implementation. How can I run the (2) Tx without having B to sign the Tx, ie: I want it to run automatically once (1) is activated and condition (2) is ready.
Pseudocode(one):
A send 50 to B (1)
if (B > 50) (2)
B send 10 to C (3)
The code above involves multiple owners, ie. A, B and C. Firstly, A actives the contract by running/signing Tx (1). Then the contract checks condition (2). Now but how can run(3) automatically without having to force B to sign?
Ultimately, is the contract able to sign (or proxy sign) on behave of B?
edit
What about below in any chaincode? Can it run automatically, ie without D has to sign using D's private key in (3)?
Pseudocode(two):
A send 50 to B (1)
if (something is true, say Z > 50) (2)
D send 10 to F (3)

Answer 1

Ultimately, is the contract able to sign (or proxy sign) on behave of B?
No.
A starts the transactions by sending necessary funds to the contract, and then the contract disperses funds according to the rules. So, A -> contract, contract -> B and possibly, contract -> C.
Although it's outside the question raised, it will possibly help you avoid refactoring later to observe the best practice of separating the two sends if B and/or C are untrusted contracts. You would just do the accounting in the deposit step, and then use a withdrawal pattern as B & C claim their entitlements (separate transactions).
Hope it helps.
Updated:
Here's a rough outline that might give you some ideas. I wasn't sure if the > 50 was all-time total or a single payment > 50. It's a contrived example that expects you to pass in two valid addresses for B & C so the contract knows their addresses.
You can send amounts from any address (A) and the contract will keep track of owedToB and owedToC.
You should be able to send a transaction to withdraw() from B or C to claim the balance owed.
It's a little time-consuming to set everything up for a full test so just presenting "as is".
pragma solidity ^0.4.6;
contract Royalty {
address public B;
address public C;
uint public owedToB;
uint public owedToC;
event LogPaymentReceived(address sender, uint amount);
event LogPaid(address recipient, uint amount);
// pass in two addresses, B & C for this simple constructor
function Royalty(address addressB, address addressC) {
B = addressB;
C = addressC;
}
function pay()
public
payable
returns(bool success)
{
owedToB += msg.value;
// You can do B.balance > 50 but beware how it drops below 50 after withdrawal
// A little more involved, but you can have totalReceipts AND totalPayments so owedToB is totalReceipts - totalPayments
// It all depends on the business terms you're trying to enforce.
if(msg.value > 50) {
owedToC += 10;
owedToB -= 10;
}
LogPaymentReceived(msg.sender, msg.value);
return true;
}
function withdraw()
public
returns(uint amountSent)
{
if(msg.sender != B && msg.sender != C) throw; // only B & C can withdraw
uint amount;
if(msg.sender == B) {
amount = owedToB;
owedToB = 0;
if(!B.send(amount)) throw;
LogPaid(B,amount);
return amount;
}
if(msg.sender == C) {
amount = owedToC;
owedToC = 0;
if(!C.send(amount)) throw;
LogPaid(C,amount);
return amount;
}
// we shouldn't make it this far
throw;
}
}