public static object resolvePaymentByConditions(byte[] resolvePayRequestBs)
{
PbChain.ResolvePayByConditionsRequest resolvePayRequest = new PbChain.ResolvePayByConditionsRequest();
resolvePayRequest = (PbChain.ResolvePayByConditionsRequest)Helper.Deserialize(resolvePayRequestBs);
PbEntity.ConditionalPay pay = Helper.Deserialize(resolvePayRequest.condPay) as PbEntity.ConditionalPay;
PbEntity.TransferFunction function = pay.transferFunc;
byte funcType = function.logicType;
BigInteger amount = 0;
PbEntity.TransferFunctionType TransferFunctionType = PbEntity.getTransferFunctionType();
if (funcType == TransferFunctionType.BOOLEAN_AND)
{
amount = _calculateBooleanAndPayment(pay, resolvePayRequest.hashPreimages);
}
else if (funcType == TransferFunctionType.BOOLEAN_OR)
{
amount = _calculateBooleanOrPayment(pay, resolvePayRequest.hashPreimages);
}
else if (_isNumericLogic(funcType))
{
amount = _calculateNumericLogicPayment(pay, resolvePayRequest.hashPreimages, funcType);
}
else
{
BasicMethods.assert(false, "error");
}
byte[] payHash = SmartContract.Sha256(resolvePayRequest.condPay);
_resolvePayment(pay, payHash, amount);
return(true);
}
private static bool _isNumericLogic(byte _funcType)
{
PbEntity.TransferFunctionType TransferFunctionType = PbEntity.getTransferFunctionType();
return(_funcType == TransferFunctionType.NUMERIC_ADD || _funcType == TransferFunctionType.NUMERIC_MAX || _funcType == TransferFunctionType.NUMERIC_MIN);
}
private static BigInteger _calculateNumericLogicPayment(PbEntity.ConditionalPay _pay, byte[][] _preimages, byte _funcType)
{
int j = 0;
BigInteger amount = 0;
bool hasContracCond = false;
PbEntity.ConditionType ConditionType = PbEntity.getConditionType();
PbEntity.TransferFunctionType TransferFunctionType = PbEntity.getTransferFunctionType();
PbEntity.Condition[] conditions = _pay.conditions;
for (var i = 0; i < conditions.Length; i++)
{
PbEntity.Condition cond = _pay.conditions[i];
if (cond.conditionType == ConditionType.HASH_LOCK)
{
BasicMethods.assert(SmartContract.Sha256(_preimages[j]) == cond.hashLock, "wrong preimage");
j++;
}
else if (
cond.conditionType == ConditionType.DEPLOYED_CONTRACT ||
cond.conditionType == ConditionType.VIRTUAL_CONTRACT
)
{
byte[] numericCondHash = _getCondAddress(cond);
DynamicCallContract dyncall = (DynamicCallContract)numericCondHash.ToDelegate();
BasicMethods.assert((bool)dyncall("isFinalized", new object[] { cond.argsQueryFinalization }), "Condition is not finalized");
BigInteger outcome = (BigInteger)dyncall("getOutcome", new object[] { cond.argsQueryOutcome });
if (_funcType == TransferFunctionType.NUMERIC_ADD)
{
amount = amount + outcome;
}
else if (_funcType == TransferFunctionType.NUMERIC_MAX)
{
amount = max(amount, outcome);
}
else if (_funcType == TransferFunctionType.NUMERIC_MIN)
{
if (hasContracCond)
{
amount = min(amount, outcome);
}
else
{
amount = outcome;
}
}
else
{
BasicMethods.assert(false, "error");
}
hasContracCond = true;
}
else
{
BasicMethods.assert(false, "condition type error");
}
}
PbEntity.TransferFunction transferFunction = _pay.transferFunc;
PbEntity.TokenTransfer tokenTransfer = transferFunction.maxTransfer;
PbEntity.AccountAmtPair accountAmtPair = tokenTransfer.receiver;
if (hasContracCond)
{
BasicMethods.assert(amount <= accountAmtPair.amt, "exceed max transfer amount");
return(amount);
}
else
{
return(accountAmtPair.amt);
}
}
