DragonX/dragonx
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 2 Wiki Activity

Delete more CCs #381

Browse Source
This commit is contained in:
Duke
2024-02-10 23:06:56 -05:00
parent b41785a684
commit 7791d50230
5 changed files with 7 additions and 1060 deletions
Download Patch File Download Diff File Expand all files Collapse all files

203
src/test-hush/test_cryptoconditions.cpp
View File

@@ -1,203 +0,0 @@
// Copyright (c) 2016-2023 The Hush developers
// Distributed under the GPLv3 software license, see the accompanying
// file COPYING or https://www.gnu.org/licenses/gpl-3.0.en.html
#include <cryptoconditions.h>
#include <gtest/gtest.h>
#include "base58.h"
#include "key.h"
#include "script/cc.h"
#include "cc/eval.h"
#include "primitives/transaction.h"
#include "script/interpreter.h"
#include "script/serverchecker.h"
#include "testutils.h"
class CCTest : public ::testing::Test {
public:
void CCSign(CMutableTransaction &tx, CC *cond) {
tx.vin.resize(1);
PrecomputedTransactionData txdata(tx);
uint256 sighash = SignatureHash(CCPubKey(cond), tx, 0, SIGHASH_ALL, 0, 0, &txdata);
int out = cc_signTreeSecp256k1Msg32(cond, notaryKey.begin(), sighash.begin());
tx.vin[0].scriptSig = CCSig(cond);
}
protected:
virtual void SetUp() {
// enable CC
ASSETCHAINS_CC = 1;
}
};
TEST_F(CCTest, testIsPayToCryptoCondition)
{
CScript s = CScript() << VCH("a", 1);
ASSERT_FALSE(s.IsPayToCryptoCondition());
s = CScript() << VCH("a", 1) << OP_CHECKCRYPTOCONDITION;
ASSERT_TRUE(s.IsPayToCryptoCondition());
s = CScript() << OP_CHECKCRYPTOCONDITION;
ASSERT_FALSE(s.IsPayToCryptoCondition());
}
TEST_F(CCTest, testMayAcceptCryptoCondition)
{
CC *cond;
// ok
CCFromJson(cond, R"!!(
{ "type": "threshold-sha-256",
"threshold": 2,
"subfulfillments": [
{ "type": "secp256k1-sha-256", "publicKey": "0205a8ad0c1dbc515f149af377981aab58b836af008d4d7ab21bd76faf80550b47" }
]
})!!");
ASSERT_TRUE(CCPubKey(cond).MayAcceptCryptoCondition());
// prefix not allowed
CCFromJson(cond, R"!!(
{ "type": "prefix-sha-256",
"prefix": "abc",
"maxMessageLength": 10,
"subfulfillment":
{ "type": "secp256k1-sha-256", "publicKey": "0205a8ad0c1dbc515f149af377981aab58b836af008d4d7ab21bd76faf80550b47" }
})!!");
ASSERT_FALSE(CCPubKey(cond).MayAcceptCryptoCondition());
// has no signature nodes
CCFromJson(cond, R"!!(
{ "type": "threshold-sha-256",
"threshold": 1,
"subfulfillments": [
{ "type": "eval-sha-256", "code": "" },
{ "type": "eval-sha-256", "code": "" }
]
})!!");
ASSERT_FALSE(CCPubKey(cond).MayAcceptCryptoCondition());
}
static bool CCVerify(const CMutableTransaction &mtxTo, const CC *cond) {
CAmount amount;
ScriptError error;
CTransaction txTo(mtxTo);
PrecomputedTransactionData txdata(txTo);
auto checker = ServerTransactionSignatureChecker(&txTo, 0, amount, false, txdata);
return VerifyScript(CCSig(cond), CCPubKey(cond), 0, checker, 0, &error);
};
TEST_F(CCTest, testVerifyCryptoCondition)
{
CC *cond;
CMutableTransaction mtxTo;
// ok
cond = CCNewSecp256k1(notaryKey.GetPubKey());
CCFromJson(cond, R"!!({
"type": "secp256k1-sha-256",
"publicKey": "0205a8ad0c1dbc515f149af377981aab58b836af008d4d7ab21bd76faf80550b47"
})!!");
CCSign(mtxTo, cond);
ASSERT_TRUE(CCVerify(mtxTo, cond));
// has signature nodes
CCFromJson(cond, R"!!({
"type": "threshold-sha-256",
"threshold": 1,
"subfulfillments": [
{ "type": "preimage-sha-256", "preimage": "" },
{ "type": "secp256k1-sha-256", "publicKey": "0205a8ad0c1dbc515f149af377981aab58b836af008d4d7ab21bd76faf80550b47" }
]
})!!");
cond->threshold = 2;
CCSign(mtxTo, cond);
ASSERT_TRUE(CCVerify(mtxTo, cond));
// no signatures; the preimage will get encoded as a fulfillment because it's cheaper
// and the secp256k1 node will get encoded as a condition
cond->threshold = 1;
ASSERT_FALSE(CCVerify(mtxTo, cond));
// here the signature is set wrong
cond->threshold = 2;
ASSERT_TRUE(CCVerify(mtxTo, cond));
memset(cond->subconditions[1]->signature, 0, 32);
ASSERT_FALSE(CCVerify(mtxTo, cond));
}
extern Eval* EVAL_TEST;
TEST_F(CCTest, testVerifyEvalCondition)
{
class EvalMock : public Eval
{
public:
bool Dispatch(const CC *cond, const CTransaction &txTo, unsigned int nIn)
{ return cond->code[0] ? Valid() : Invalid(""); }
};
EvalMock eval;
EVAL_TEST = &eval;
CC *cond;
CMutableTransaction mtxTo;
// ok
cond = CCNewThreshold(2, { CCNewSecp256k1(notaryKey.GetPubKey()), CCNewEval({1}) });
CCSign(mtxTo, cond);
ASSERT_TRUE(CCVerify(mtxTo, cond));
cond->subconditions[1]->code[0] = 0;
ASSERT_FALSE(CCVerify(mtxTo, cond));
}
TEST_F(CCTest, testCryptoConditionsDisabled)
{
CC *cond;
ScriptError error;
CMutableTransaction mtxTo;
// ok
CCFromJson(cond, R"!!({
"type": "secp256k1-sha-256",
"publicKey": "0205a8ad0c1dbc515f149af377981aab58b836af008d4d7ab21bd76faf80550b47"
})!!");
CCSign(mtxTo, cond);
ASSERT_TRUE(CCVerify(mtxTo, cond));
ASSETCHAINS_CC = 0;
ASSERT_FALSE(CCVerify(mtxTo, cond));
}
TEST_F(CCTest, testLargeCondition)
{
CC *cond;
ScriptError error;
CMutableTransaction mtxTo;
std::vector<CC*> ccs;
for (int i=0; i<18; i++) {
ccs.push_back(CCNewSecp256k1(notaryKey.GetPubKey()));
}
cond = CCNewThreshold(16, ccs);
CCSign(mtxTo, cond);
EXPECT_EQ("(16 of 5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,A5,A5)",
CCShowStructure(CCPrune(cond)));
EXPECT_EQ(1744, CCSig(cond).size());
ASSERT_TRUE(CCVerify(mtxTo, cond));
}

597
src/test-hush/test_eval_bet.cpp
View File

@@ -1,597 +0,0 @@
// Copyright (c) 2016-2023 The Hush developers
// Distributed under the GPLv3 software license, see the accompanying
// file COPYING or https://www.gnu.org/licenses/gpl-3.0.en.html
#include <cryptoconditions.h>
#include <gtest/gtest.h>
#include "cc/betprotocol.h"
#include "cc/eval.h"
#include "base58.h"
#include "key.h"
#include "main.h"
#include "script/cc.h"
#include "primitives/transaction.h"
#include "script/interpreter.h"
#include "script/serverchecker.h"
#include "testutils.h"
extern Eval* EVAL_TEST;
namespace TestBet {
static std::vector<CKey> playerSecrets;
static std::vector<CPubKey> players;
static int Dealer = 0, Player1 = 1, Player2 = 2;
int CCSign(CMutableTransaction &tx, unsigned int nIn, CC *cond, std::vector<int> keyIds) {
PrecomputedTransactionData txdata(tx);
uint256 sighash = SignatureHash(CCPubKey(cond), tx, nIn, SIGHASH_ALL, 0, 0, &txdata);
int nSigned = 0;
for (int i=0; i<keyIds.size(); i++)
nSigned += cc_signTreeSecp256k1Msg32(cond, playerSecrets[keyIds[i]].begin(), sighash.begin());
tx.vin[nIn].scriptSig = CCSig(cond);
return nSigned;
}
int TestCC(CMutableTransaction &mtxTo, unsigned int nIn, CC *cond)
{
CAmount amount;
ScriptError error;
CTransaction txTo(mtxTo);
PrecomputedTransactionData txdata(txTo);
auto checker = ServerTransactionSignatureChecker(&txTo, nIn, amount, false, txdata);
return VerifyScript(txTo.vin[nIn].scriptSig, CCPubKey(cond), 0, checker, 0, &error);
}
#define ASSERT_CC(tx, nIn, cond) if (!TestCC(tx, nIn, cond)) FAIL();
class MockVM : public AppVM
{
public:
std::pair<int,std::vector<CTxOut>> evaluate(
std::vector<unsigned char> header, std::vector<unsigned char> body)
{
std::vector<CTxOut> outs;
if (memcmp(header.data(), "BetHeader", 9)) {
printf("Wrong VM header\n");
return std::make_pair(0, outs);
}
outs.push_back(CTxOut(2, CScript() << OP_RETURN << body.size()));
return std::make_pair(body.size(), outs);
}
};
const EvalCode EVAL_DISPUTEBET = 0xf2;
class EvalMock : public Eval
{
public:
uint256 MoM;
int currentHeight;
std::map<uint256, CTransaction> txs;
std::map<uint256, CBlockIndex> blocks;
std::map<uint256, std::vector<CTransaction>> spends;
bool Dispatch(const CC *cond, const CTransaction &txTo, unsigned int nIn)
{
EvalCode ecode = cond->code[0];
std::vector<uint8_t> vparams(cond->code+1, cond->code+cond->codeLength);
if (ecode == EVAL_DISPUTEBET) {
MockVM vm;
return DisputePayout(vm, vparams, txTo, nIn);
}
if (ecode == EVAL_IMPORTPAYOUT) {
return ImportPayout(vparams, txTo, nIn);
}
return Invalid("invalid-code");
}
bool GetSpendsConfirmed(uint256 hash, std::vector<CTransaction> &spendsOut) const
{
auto r = spends.find(hash);
if (r != spends.end()) {
spendsOut = r->second;
return true;
}
return false;
}
bool GetTxUnconfirmed(const uint256 &hash, CTransaction &txOut, uint256 &hashBlock) const
{
auto r = txs.find(hash);
if (r != txs.end()) {
txOut = r->second;
if (blocks.count(hash) > 0)
hashBlock = hash;
return true;
}
return false;
}
unsigned int GetCurrentHeight() const { return currentHeight; }
bool GetBlock(uint256 hash, CBlockIndex& blockIdx) const
{
auto r = blocks.find(hash);
if (r == blocks.end()) return false;
blockIdx = r->second;
return true;
}
bool GetNotarizationData(uint256 notarizationHash, NotarizationData &data) const
{
if (notarizationHash == NotarizationHash()) {
data.MoM = MoM;
return true;
}
return false;
}
static uint256 NotarizationHash()
{
uint256 h;
h.begin()[0] = 123;
return h;
}
};
/*
* Generates example data that we will test with and shows how to call BetProtocol.
*/
class ExampleBet
{
public:
BetProtocol bet;
CAmount totalPayout;
ExampleBet() : bet(BetProtocol(EVAL_DISPUTEBET, players, 2, VCH("BetHeader", 9))), totalPayout(100) {}
~ExampleBet() {};
CTransaction SessionTx()
{
return CTransaction(bet.MakeSessionTx(1));
}
CC* DisputeCond()
{
return bet.MakeDisputeCond();
}
CC* PayoutCond()
{
return bet.MakePayoutCond(SessionTx().GetHash());
}
CTransaction StakeTx()
{
return CTransaction(bet.MakeStakeTx(totalPayout, SessionTx().GetHash()));
}
std::vector<unsigned char> PlayerState(int playerIdx)
{
std::vector<unsigned char> state;
for (int i=0; i<playerIdx+1; i++) state.push_back(1);
return state;
}
std::vector<CTxOut> Payouts(int playerIdx)
{
return MockVM().evaluate(bet.vmParams, PlayerState(playerIdx)).second;
}
CMutableTransaction DisputeTx(int playerIdx)
{
return bet.MakeDisputeTx(SessionTx().GetHash(), SerializeHash(Payouts(playerIdx)));
}
CMutableTransaction PostEvidenceTx(int playerIdx)
{
return bet.MakePostEvidenceTx(SessionTx().GetHash(), playerIdx, PlayerState(playerIdx));
}
CMutableTransaction AgreePayoutTx()
{
std::vector<CTxOut> v;
return bet.MakeAgreePayoutTx(v, uint256());
}
MoMProof GetMoMProof()
{
int nIndex = 5;
std::vector<uint256> vBranch;
vBranch.resize(3);
return {MerkleBranch(nIndex, vBranch), EvalMock::NotarizationHash()};
}
CMutableTransaction ImportPayoutTx()
{
CMutableTransaction disputeTx = DisputeTx(Player2);
return bet.MakeImportPayoutTx(Payouts(Player2), disputeTx, uint256(), GetMoMProof());
}
EvalMock SetEvalMock(int currentHeight)
{
EvalMock eval;
CTransaction sessionTx = SessionTx();
eval.txs[sessionTx.GetHash()] = sessionTx;
CBlockIndex sessionBlock;
sessionBlock.SetHeight(10);
eval.blocks[sessionTx.GetHash()] = sessionBlock;
std::vector<CTransaction> sessionSpends;
sessionSpends.push_back(CTransaction(PostEvidenceTx(Dealer)));
sessionSpends.push_back(CTransaction()); // Invalid, should be ignored
sessionSpends.push_back(CTransaction(PostEvidenceTx(Player2)));
eval.spends[sessionTx.GetHash()] = sessionSpends;
eval.currentHeight = currentHeight;
MoMProof proof = GetMoMProof();
eval.MoM = proof.branch.Exec(DisputeTx(Player2).GetHash());
EVAL_TEST = &eval;
return eval;
}
};
ExampleBet ebet;
class TestBet : public ::testing::Test {
protected:
static void SetUpTestCase() {
// Make playerSecrets
CBitcoinSecret vchSecret;
auto addKey = [&] (std::string k) { vchSecret.SetString(k); playerSecrets.push_back(vchSecret.GetKey()); };
addKey("UwFBKf4d6wC3yqdnk3LoGrFjy7gwxrWerBT8jTFamrBbem8wSw9L");
addKey("Up6GpWwrmx2VpqF8rD3snJXToKT56Dzc8YSoL24osXnfNdCucaMR");
addKey("UxEHwki3A95PSHHVRzE2N67eHTeoUcqLkovxp6yDPVViv54skF8c");
// Make playerpubkeys
for (int i=0; i<playerSecrets.size(); i++) players.push_back(playerSecrets[i].GetPubKey());
// enable CC
ASSETCHAINS_CC = 1;
}
virtual void SetUp() {
EVAL_TEST = 0;
ebet = ExampleBet();
}
};
TEST_F(TestBet, testMakeSessionTx)
{
CTransaction sessionTx = ebet.SessionTx();
EXPECT_EQ(0, sessionTx.vin.size());
EXPECT_EQ(4, sessionTx.vout.size());
EXPECT_EQ(CCPubKey(ebet.DisputeCond()), sessionTx.vout[0].scriptPubKey);
for (int i=0; i<players.size(); i++)
EXPECT_EQ(CCPubKey(CCNewSecp256k1(players[i])), sessionTx.vout[i+1].scriptPubKey);
}
TEST_F(TestBet, testMakeDisputeCond)
{
CC *disputeCond = ebet.DisputeCond();
EXPECT_EQ("(2 of 15,(1 of 5,5,5))", CCShowStructure(disputeCond));
CC *evalCond = disputeCond->subconditions[0];
uint8_t target[100];
sprintf((char*)target, "%c\x02\tBetHeader", EVAL_DISPUTEBET);
EXPECT_EQ(0, memcmp(target, evalCond->code, 12));
for (int i=0; i<players.size(); i++)
EXPECT_EQ(CCPubKey(CCNewSecp256k1(players[i])),
CCPubKey(disputeCond->subconditions[1]->subconditions[i]));
}
TEST_F(TestBet, testSignDisputeCond)
{
// Only one key needed to dispute
CMutableTransaction disputeTx = ebet.DisputeTx(Player1);
CC *disputeCond = ebet.DisputeCond();
EXPECT_EQ(1, CCSign(disputeTx, 0, disputeCond, {Player1}));
EXPECT_EQ(1, cc_isFulfilled(disputeCond->subconditions[0]));
EXPECT_EQ(1, cc_isFulfilled(disputeCond->subconditions[1]));
EXPECT_EQ(0, cc_isFulfilled(disputeCond->subconditions[1]->subconditions[0]));
EXPECT_EQ(1, cc_isFulfilled(disputeCond->subconditions[1]->subconditions[1]));
EXPECT_EQ(0, cc_isFulfilled(disputeCond->subconditions[1]->subconditions[2]));
EXPECT_EQ(1, cc_isFulfilled(disputeCond));
}
TEST_F(TestBet, testDispute)
{
EvalMock eval = ebet.SetEvalMock(12);
// Only one key needed to dispute
CMutableTransaction disputeTx = ebet.DisputeTx(Player2);
CC *disputeCond = ebet.DisputeCond();
EXPECT_EQ(1, CCSign(disputeTx, 0, disputeCond, {Player2}));
// Success
EXPECT_TRUE(TestCC(disputeTx, 0, disputeCond));
// Set result hash to 0 and check false
uint256 nonsense;
disputeTx.vout[0].scriptPubKey = CScript() << OP_RETURN << E_MARSHAL(ss << nonsense);
EXPECT_EQ(1, CCSign(disputeTx, 0, disputeCond, {Player2}));
EXPECT_FALSE(TestCC(disputeTx, 0, disputeCond));
EXPECT_EQ("wrong-payout", eval.state.GetRejectReason());
}
TEST_F(TestBet, testDisputeInvalidOutput)
{
EvalMock eval = ebet.SetEvalMock(11);
// Only one key needed to dispute
CMutableTransaction disputeTx = ebet.DisputeTx(Dealer);
CC *disputeCond = ebet.DisputeCond();
// invalid payout hash
std::vector<unsigned char> invalidHash = {0,1,2};
disputeTx.vout[0].scriptPubKey = CScript() << OP_RETURN << invalidHash;
ASSERT_EQ(1, CCSign(disputeTx, 0, disputeCond, {Player1}));
EXPECT_FALSE(TestCC(disputeTx, 0, disputeCond));
EXPECT_EQ("invalid-payout-hash", eval.state.GetRejectReason());
// no vout at all
disputeTx.vout.resize(0);
ASSERT_EQ(1, CCSign(disputeTx, 0, disputeCond, {Player1}));
EXPECT_FALSE(TestCC(disputeTx, 0, disputeCond));
EXPECT_EQ("no-vouts", eval.state.GetRejectReason());
}
TEST_F(TestBet, testDisputeEarly)
{
EvalMock eval = ebet.SetEvalMock(11);
// Only one key needed to dispute
CMutableTransaction disputeTx = ebet.DisputeTx(Dealer);
CC *disputeCond = ebet.DisputeCond();
EXPECT_EQ(1, CCSign(disputeTx, 0, disputeCond, {Player1}));
EXPECT_FALSE(TestCC(disputeTx, 0, disputeCond));
EXPECT_EQ("dispute-too-soon", eval.state.GetRejectReason());
}
TEST_F(TestBet, testDisputeInvalidParams)
{
EvalMock eval = ebet.SetEvalMock(12);
CMutableTransaction disputeTx = ebet.DisputeTx(Player2);
CC *disputeCond = ebet.DisputeCond();
CC *evalCond = disputeCond->subconditions[0];
// too long
evalCond->code = (unsigned char*) realloc(evalCond->code, ++evalCond->codeLength);
ASSERT_EQ(1, CCSign(disputeTx, 0, disputeCond, {Player2}));
EXPECT_FALSE(TestCC(disputeTx, 0, disputeCond));
EXPECT_EQ("malformed-params", eval.state.GetRejectReason());
// too short
eval.state = CValidationState();
evalCond->codeLength = 1;
ASSERT_EQ(1, CCSign(disputeTx, 0, disputeCond, {Player2}));
EXPECT_FALSE(TestCC(disputeTx, 0, disputeCond));
EXPECT_EQ("malformed-params", eval.state.GetRejectReason());
// is fine
eval.state = CValidationState();
evalCond->codeLength = 12;
ASSERT_EQ(1, CCSign(disputeTx, 0, disputeCond, {Player2}));
EXPECT_TRUE(TestCC(disputeTx, 0, disputeCond));
}
TEST_F(TestBet, testDisputeInvalidEvidence)
{
EvalMock eval = ebet.SetEvalMock(12);
CMutableTransaction disputeTx = ebet.DisputeTx(Player2);
CC *disputeCond = ebet.DisputeCond();
CCSign(disputeTx, 0, disputeCond, {Player2});
CMutableTransaction mtx;
mtx.vout.resize(1);
mtx.vout[0].scriptPubKey = CScript();
eval.spends[ebet.SessionTx().GetHash()][1] = CTransaction(mtx);
ASSERT_TRUE(TestCC(disputeTx, 0, disputeCond));
mtx.vout[0].scriptPubKey << OP_RETURN;
eval.spends[ebet.SessionTx().GetHash()][1] = CTransaction(mtx);
ASSERT_TRUE(TestCC(disputeTx, 0, disputeCond));
mtx.vout[0].scriptPubKey = CScript() << 0;
eval.spends[ebet.SessionTx().GetHash()][1] = CTransaction(mtx);
ASSERT_TRUE(TestCC(disputeTx, 0, disputeCond));
eval.spends[ebet.SessionTx().GetHash()].resize(1);
eval.spends[ebet.SessionTx().GetHash()][0] = CTransaction();
ASSERT_FALSE(TestCC(disputeTx, 0, disputeCond));
EXPECT_EQ("no-evidence", eval.state.GetRejectReason());
}
TEST_F(TestBet, testMakeStakeTx)
{
CTransaction stakeTx = ebet.StakeTx();
EXPECT_EQ(0, stakeTx.vin.size());
EXPECT_EQ(1, stakeTx.vout.size());
EXPECT_EQ(ebet.totalPayout, stakeTx.vout[0].nValue);
EXPECT_EQ(CCPubKey(ebet.PayoutCond()), stakeTx.vout[0].scriptPubKey);
}
TEST_F(TestBet, testMakePayoutCond)
{
CC *payoutCond = ebet.PayoutCond();
EXPECT_EQ("(1 of (3 of 5,5,5),(2 of (1 of 5,5,5),15))", CCShowStructure(payoutCond));
EXPECT_EQ(0, memcmp(payoutCond->subconditions[1]->subconditions[1]->code+1,
ebet.SessionTx().GetHash().begin(), 32));
}
TEST_F(TestBet, testSignPayout)
{
CMutableTransaction payoutTx = ebet.AgreePayoutTx();
CC *payoutCond = ebet.PayoutCond();
EXPECT_EQ(0, cc_isFulfilled(payoutCond->subconditions[0]));
EXPECT_EQ(0, cc_isFulfilled(payoutCond->subconditions[1]));
EXPECT_EQ(0, cc_isFulfilled(payoutCond));
EXPECT_EQ(2, CCSign(payoutTx, 0, payoutCond, {Player1}));
EXPECT_EQ(0, cc_isFulfilled(payoutCond->subconditions[0]));
EXPECT_EQ(1, cc_isFulfilled(payoutCond->subconditions[1]));
EXPECT_EQ(1, cc_isFulfilled(payoutCond));
EXPECT_EQ(2, CCSign(payoutTx, 0, payoutCond, {Player2}));
EXPECT_EQ(0, cc_isFulfilled(payoutCond->subconditions[0]));
EXPECT_EQ(2, CCSign(payoutTx, 0, payoutCond, {Dealer}));
EXPECT_EQ(1, cc_isFulfilled(payoutCond->subconditions[0]));
}
TEST_F(TestBet, testAgreePayout)
{
EvalMock eval = ebet.SetEvalMock(12);
CMutableTransaction payoutTx = ebet.AgreePayoutTx();
CC *payoutCond = ebet.PayoutCond();
EXPECT_EQ(2, CCSign(payoutTx, 0, payoutCond, {Dealer}));
EXPECT_FALSE(TestCC(payoutTx, 0, payoutCond));
EXPECT_EQ("(1 of (2 of (1 of 5,A5,A5),15),A2)",
CCShowStructure(CCPrune(payoutCond)));
EXPECT_EQ(2, CCSign(payoutTx, 0, payoutCond, {Player1}));
EXPECT_FALSE(TestCC(payoutTx, 0, payoutCond));
EXPECT_EQ("(1 of (2 of (1 of 5,A5,A5),15),A2)",
CCShowStructure(CCPrune(payoutCond)));
EXPECT_EQ(2, CCSign(payoutTx, 0, payoutCond, {Player2}));
EXPECT_TRUE( TestCC(payoutTx, 0, payoutCond));
EXPECT_EQ("(1 of (3 of 5,5,5),A2)",
CCShowStructure(CCPrune(payoutCond)));
}
TEST_F(TestBet, testImportPayout)
{
EvalMock eval = ebet.SetEvalMock(12);
CMutableTransaction importTx = ebet.ImportPayoutTx();
CC *payoutCond = ebet.PayoutCond();
EXPECT_EQ(2, CCSign(importTx, 0, payoutCond, {Player2}));
EXPECT_TRUE(TestCC(importTx, 0, payoutCond));
}
TEST_F(TestBet, testImportPayoutFewVouts)
{
EvalMock eval = ebet.SetEvalMock(12);
CMutableTransaction importTx = ebet.ImportPayoutTx();
importTx.vout.resize(0);
CC *payoutCond = ebet.PayoutCond();
EXPECT_EQ(2, CCSign(importTx, 0, payoutCond, {Player2}));
EXPECT_FALSE(TestCC(importTx, 0, payoutCond));
EXPECT_EQ("no-vouts", eval.state.GetRejectReason());
}
TEST_F(TestBet, testImportPayoutInvalidPayload)
{
EvalMock eval = ebet.SetEvalMock(12);
CMutableTransaction importTx = ebet.ImportPayoutTx();
importTx.vout[0].scriptPubKey.pop_back();
CC *payoutCond = ebet.PayoutCond();
EXPECT_EQ(2, CCSign(importTx, 0, payoutCond, {Player2}));
EXPECT_FALSE(TestCC(importTx, 0, payoutCond));
EXPECT_EQ("invalid-payload", eval.state.GetRejectReason());
}
TEST_F(TestBet, testImportPayoutWrongPayouts)
{
EvalMock eval = ebet.SetEvalMock(12);
CMutableTransaction importTx = ebet.ImportPayoutTx();
importTx.vout[1].nValue = 7;
CC *payoutCond = ebet.PayoutCond();
EXPECT_EQ(2, CCSign(importTx, 0, payoutCond, {Player2}));
ASSERT_FALSE(TestCC(importTx, 0, payoutCond));
EXPECT_EQ("wrong-payouts", eval.state.GetRejectReason());
}
TEST_F(TestBet, testImportPayoutMangleSessionId)
{
EvalMock eval = ebet.SetEvalMock(12);
CMutableTransaction importTx = ebet.ImportPayoutTx();
CC *payoutCond = ebet.PayoutCond();
payoutCond->subconditions[1]->subconditions[1]->codeLength = 31;
EXPECT_EQ(2, CCSign(importTx, 0, payoutCond, {Player2}));
ASSERT_FALSE(TestCC(importTx, 0, payoutCond));
EXPECT_EQ("malformed-params", eval.state.GetRejectReason());
payoutCond = ebet.PayoutCond();
memset(payoutCond->subconditions[1]->subconditions[1]->code+1, 1, 32);
EXPECT_EQ(2, CCSign(importTx, 0, payoutCond, {Player2}));
ASSERT_FALSE(TestCC(importTx, 0, payoutCond));
EXPECT_EQ("wrong-session", eval.state.GetRejectReason());
}
TEST_F(TestBet, testImportPayoutInvalidNotarizationHash)
{
EvalMock eval = ebet.SetEvalMock(12);
MoMProof proof = ebet.GetMoMProof();
proof.notarizationHash = uint256();
CMutableTransaction importTx = ebet.bet.MakeImportPayoutTx(
ebet.Payouts(Player2), ebet.DisputeTx(Player2), uint256(), proof);
CC *payoutCond = ebet.PayoutCond();
EXPECT_EQ(2, CCSign(importTx, 0, payoutCond, {Player2}));
EXPECT_FALSE(TestCC(importTx, 0, payoutCond));
EXPECT_EQ("coudnt-load-mom", eval.state.GetRejectReason());
}
TEST_F(TestBet, testImportPayoutMomFail)
{
EvalMock eval = ebet.SetEvalMock(12);
MoMProof proof = ebet.GetMoMProof();
proof.branch.nIndex ^= 1;
CMutableTransaction importTx = ebet.bet.MakeImportPayoutTx(
ebet.Payouts(Player2), ebet.DisputeTx(Player2), uint256(), proof);
CC *payoutCond = ebet.PayoutCond();
EXPECT_EQ(2, CCSign(importTx, 0, payoutCond, {Player2}));
EXPECT_FALSE(TestCC(importTx, 0, payoutCond));
EXPECT_EQ("mom-check-fail", eval.state.GetRejectReason());
}
} /* namespace TestBet */