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

Merge pull request #1223 from jl777/jl777

Browse Source 
initial sudoku in cclib
This commit is contained in:
jl777
2019-01-29 01:17:42 -11:00
committed by GitHub
parent 424afde333 0d81615f61
commit d34e8c2439
11 changed files with 730 additions and 41 deletions
Download Patch File Download Diff File Expand all files Collapse all files

35
src/cc/CCcustom.cpp
View File

@@ -245,20 +245,45 @@ uint8_t CClibCCpriv[32] = { 0x57, 0xcf, 0x49, 0x71, 0x7d, 0xb4, 0x15, 0x1b, 0x4f
int32_t CClib_initcp(struct CCcontract_info *cp,uint8_t evalcode)
{
CPubKey pk; uint8_t pub33[33]; char CCaddr[64];
CPubKey pk; int32_t i; uint8_t pub33[33],check33[33],hash[32]; char CCaddr[64],checkaddr[64],str[67];
cp->evalcode = evalcode;
cp->ismyvin = IsCClibInput;
memcpy(cp->CCpriv,CClibCCpriv,32);
if ( evalcode == EVAL_FIRSTUSER ) // eventually make a hashchain for each evalcode
{
cp->evalcode = evalcode;
cp->ismyvin = IsCClibInput;
strcpy(cp->CChexstr,CClibCChexstr);
memcpy(cp->CCpriv,CClibCCpriv,32);
decode_hex(pub33,33,cp->CChexstr);
pk = buf2pk(pub33);
Getscriptaddress(cp->normaladdr,CScript() << ParseHex(HexStr(pk)) << OP_CHECKSIG);
if ( strcmp(cp->normaladdr,CClibNormaladdr) != 0 )
fprintf(stderr,"CClib_initcp addr mismatch %s vs %s\n",cp->normaladdr,CClibNormaladdr);
GetCCaddress(cp,cp->unspendableCCaddr,pk);
return(0);
if ( priv2addr(checkaddr,check33,cp->CCpriv) != 0 )
{
if ( buf2pk(check33) == pk && strcmp(checkaddr,cp->normaladdr) == 0 )
{
fprintf(stderr,"verified evalcode.%d %s %s\n",cp->evalcode,checkaddr,pubkey33_str(str,pub33));
return(0);
} else fprintf(stderr,"CClib_initcp mismatched privkey -> addr %s vs %s\n",checkaddr,cp->normaladdr);
}
}
else
{
for (i=EVAL_FIRSTUSER; i<evalcode; i++)
{
vcalc_sha256(0,hash,cp->CCpriv,32);
memcpy(cp->CCpriv,hash,32);
}
if ( priv2addr(cp->normaladdr,pub33,cp->CCpriv) != 0 )
{
pk = buf2pk(pub33);
for (i=0; i<33; i++)
sprintf(&cp->CChexstr[i*2],"%02x",pub33[i]);
cp->CChexstr[i*2] = 0;
GetCCaddress(cp,cp->unspendableCCaddr,pk);
printf("evalcode.%d initialized\n",evalcode);
return(0);
}
}
return(-1);
}

2
src/cc/CCinclude.h
View File

@@ -42,6 +42,7 @@ one other technical note is that komodod has the insight-explorer extensions bui
#include <cryptoconditions.h>
#include "../script/standard.h"
#include "../base58.h"
#include "../key.h"
#include "../core_io.h"
#include "../script/sign.h"
#include "../wallet/wallet.h"
@@ -179,6 +180,7 @@ int32_t oracle_format(uint256 *hashp,int64_t *valp,char *str,uint8_t fmt,uint8_t
CPubKey GetUnspendable(struct CCcontract_info *cp,uint8_t *unspendablepriv);
// CCutils
bool priv2addr(char *coinaddr,uint8_t buf33[33],uint8_t priv32[32]);
CPubKey buf2pk(uint8_t *buf33);
void endiancpy(uint8_t *dest,uint8_t *src,int32_t len);
uint256 DiceHashEntropy(uint256 &entropy,uint256 _txidpriv,int32_t entropyvout,int32_t usevout);

24
src/cc/CCutils.cpp
View File

@@ -442,6 +442,20 @@ bool PreventCC(Eval* eval,const CTransaction &tx,int32_t preventCCvins,int32_t n
return(true);
}
bool priv2addr(char *coinaddr,uint8_t *buf33,uint8_t priv32[32])
{
CKey priv; CPubKey pk; int32_t i; uint8_t *src;
priv.SetKey32(priv32);
pk = priv.GetPubKey();
if ( buf33 != 0 )
{
src = (uint8_t *)pk.begin();
for (i=0; i<33; i++)
buf33[i] = src[i];
}
return(Getscriptaddress(coinaddr, CScript() << ParseHex(HexStr(pk)) << OP_CHECKSIG));
}
std::vector<uint8_t> Mypubkey()
{
extern uint8_t NOTARY_PUBKEY33[33];
@@ -456,7 +470,7 @@ std::vector<uint8_t> Mypubkey()
bool Myprivkey(uint8_t myprivkey[])
{
char coinaddr[64]; std::string strAddress; char *dest; int32_t i,n; CBitcoinAddress address; CKeyID keyID; CKey vchSecret;
char coinaddr[64],checkaddr[64]; std::string strAddress; char *dest; int32_t i,n; CBitcoinAddress address; CKeyID keyID; CKey vchSecret; uint8_t buf33[33];
if ( Getscriptaddress(coinaddr,CScript() << Mypubkey() << OP_CHECKSIG) != 0 )
{
n = (int32_t)strlen(coinaddr);
@@ -477,7 +491,13 @@ bool Myprivkey(uint8_t myprivkey[])
fprintf(stderr,"0x%02x, ",myprivkey[i]);
fprintf(stderr," found privkey for %s!\n",dest);
}
return(true);
if ( priv2addr(checkaddr,buf33,myprivkey) != 0 )
{
if ( buf2pk(buf33) == Mypubkey() && strcmp(checkaddr,coinaddr) == 0 )
return(true);
else printf("mismatched privkey -> addr %s vs %s\n",checkaddr,coinaddr);
}
return(false);
}
#endif
}

2
src/cc/Makefile
View File

@@ -13,7 +13,7 @@ $(info $(OS))
TARGET = ../libcc.so
TARGET_DARWIN = ../libcc.dylib
TARGET_WIN = ../libcc.dll
SOURCES = cclib.cpp
SOURCES = cclib.cpp
#HEADERS = $(shell echo ../cryptoconditions/include/*.h)
all: $(TARGET)

82
src/cc/cclib.cpp
View File

@@ -28,24 +28,63 @@
#include "crosschain.h"
#define FAUCET2SIZE COIN
#define EVAL_FAUCET2 EVAL_FIRSTUSER
#define EVAL_SUDOKU 17
std::string MYCCLIBNAME = (char *)"sudoku";
char *CClib_name() { return((char *)MYCCLIBNAME.c_str()); }
struct CClib_rpcinfo
{
char *method,*help;
char *CCname,*method,*help;
int32_t numrequiredargs,maxargs; // frontloaded with required
uint8_t funcid;
uint8_t funcid,evalcode;
}
CClib_methods[] =
{
{ (char *)"faucet2_fund", (char *)"amount", 1, 1, 'F' },
{ (char *)"faucet2_get", (char *)"<no args>", 0, 0, 'G' },
{ (char *)"faucet2", (char *)"fund", (char *)"amount", 1, 1, 'F', EVAL_FAUCET2 },
{ (char *)"faucet2", (char *)"get", (char *)"<no args>", 0, 0, 'G', EVAL_FAUCET2 },
{ (char *)"sudoku", (char *)"gen", (char *)"amount", 1, 1, 'G', EVAL_SUDOKU },
{ (char *)"sudoku", (char *)"txidinfo", (char *)"txid", 1, 1, 'T', EVAL_SUDOKU },
{ (char *)"sudoku", (char *)"pending", (char *)"<no args>", 0, 0, 'U', EVAL_SUDOKU },
{ (char *)"sudoku", (char *)"solution", (char *)"solution timestamps[]", 2, 2, 'S', EVAL_SUDOKU },
};
std::string MYCCLIBNAME = (char *)"faucet2";
char *CClib_name() { return((char *)MYCCLIBNAME.c_str()); }
std::string CClib_rawtxgen(struct CCcontract_info *cp,uint8_t funcid,cJSON *params);
UniValue sudoku_txidinfo(uint64_t txfee,struct CCcontract_info *cp,cJSON *params);
UniValue sudoku_generate(uint64_t txfee,struct CCcontract_info *cp,cJSON *params);
UniValue sudoku_solution(uint64_t txfee,struct CCcontract_info *cp,cJSON *params);
UniValue sudoku_pending(uint64_t txfee,struct CCcontract_info *cp,cJSON *params);
UniValue CClib_method(struct CCcontract_info *cp,char *method,cJSON *params)
{
UniValue result(UniValue::VOBJ); uint64_t txfee = 10000;
if ( cp->evalcode == EVAL_SUDOKU )
{
if ( strcmp(method,"txidinfo") == 0 )
return(sudoku_txidinfo(txfee,cp,params));
else if ( strcmp(method,"gen") == 0 )
return(sudoku_generate(txfee,cp,params));
else if ( strcmp(method,"solution") == 0 )
return(sudoku_solution(txfee,cp,params));
else if ( strcmp(method,"pending") == 0 )
return(sudoku_pending(txfee,cp,params));
else
{
result.push_back(Pair("result","error"));
result.push_back(Pair("error","invalid sudoku method"));
result.push_back(Pair("method",method));
return(result);
}
}
else
{
result.push_back(Pair("result","error"));
result.push_back(Pair("error","only sudoku supported for now"));
result.push_back(Pair("evalcode",(int)cp->evalcode));
return(result);
}
}
UniValue CClib_info(struct CCcontract_info *cp)
{
@@ -55,6 +94,7 @@ UniValue CClib_info(struct CCcontract_info *cp)
for (i=0; i<sizeof(CClib_methods)/sizeof(*CClib_methods); i++)
{
UniValue obj(UniValue::VOBJ);
obj.push_back(Pair("evalcode",CClib_methods[i].evalcode));
if ( CClib_methods[i].funcid < ' ' || CClib_methods[i].funcid >= 128 )
obj.push_back(Pair("funcid",CClib_methods[i].funcid));
else
@@ -63,7 +103,8 @@ UniValue CClib_info(struct CCcontract_info *cp)
str[1] = 0;
obj.push_back(Pair("funcid",str));
}
obj.push_back(Pair("name",CClib_methods[i].method));
obj.push_back(Pair("name",CClib_methods[i].CCname));
obj.push_back(Pair("method",CClib_methods[i].method));
obj.push_back(Pair("help",CClib_methods[i].help));
obj.push_back(Pair("params_required",CClib_methods[i].numrequiredargs));
obj.push_back(Pair("params_max",CClib_methods[i].maxargs));
@@ -78,13 +119,16 @@ UniValue CClib(struct CCcontract_info *cp,char *method,cJSON *params)
UniValue result(UniValue::VOBJ); int32_t i; std::string rawtx;
for (i=0; i<sizeof(CClib_methods)/sizeof(*CClib_methods); i++)
{
if ( strcmp(method,CClib_methods[i].method) == 0 )
if ( cp->evalcode == CClib_methods[i].evalcode && strcmp(method,CClib_methods[i].method) == 0 )
{
result.push_back(Pair("result","success"));
result.push_back(Pair("method",CClib_methods[i].method));
rawtx = CClib_rawtxgen(cp,CClib_methods[i].funcid,params);
result.push_back(Pair("rawtx",rawtx));
return(result);
if ( cp->evalcode == EVAL_FAUCET2 )
{
result.push_back(Pair("result","success"));
result.push_back(Pair("method",CClib_methods[i].method));
rawtx = CClib_rawtxgen(cp,CClib_methods[i].funcid,params);
result.push_back(Pair("rawtx",rawtx));
return(result);
} else return(CClib_method(cp,method,params));
}
}
result.push_back(Pair("result","error"));
@@ -234,7 +278,6 @@ int64_t AddCClibInputs(struct CCcontract_info *cp,CMutableTransaction &mtx,CPubK
return(totalinputs);
}
std::string Faucet2Fund(struct CCcontract_info *cp,uint64_t txfee,int64_t funds)
{
CMutableTransaction mtx = CreateNewContextualCMutableTransaction(Params().GetConsensus(), komodo_nextheight());
@@ -289,14 +332,14 @@ std::string CClib_rawtxgen(struct CCcontract_info *cp,uint8_t funcid,cJSON *para
if ( inputs > nValue )
CCchange = (inputs - nValue - txfee);
if ( CCchange != 0 )
mtx.vout.push_back(MakeCC1vout(EVAL_FIRSTUSER,CCchange,cclibpk));
mtx.vout.push_back(MakeCC1vout(EVAL_FAUCET2,CCchange,cclibpk));
mtx.vout.push_back(CTxOut(nValue,CScript() << ParseHex(HexStr(mypk)) << OP_CHECKSIG));
fprintf(stderr,"start at %u\n",(uint32_t)time(NULL));
j = rand() & 0xfffffff;
for (i=0; i<1000000; i++,j++)
{
tmpmtx = mtx;
rawhex = FinalizeCCTx(-1LL,cp,tmpmtx,mypk,txfee,CScript() << OP_RETURN << E_MARSHAL(ss << (uint8_t)EVAL_FIRSTUSER << (uint8_t)'G' << j));
rawhex = FinalizeCCTx(-1LL,cp,tmpmtx,mypk,txfee,CScript() << OP_RETURN << E_MARSHAL(ss << (uint8_t)EVAL_FAUCET2 << (uint8_t)'G' << j));
if ( (len= (int32_t)rawhex.size()) > 0 && len < 65536 )
{
len >>= 1;
@@ -315,3 +358,6 @@ std::string CClib_rawtxgen(struct CCcontract_info *cp,uint8_t funcid,cJSON *para
} else fprintf(stderr,"cant find faucet inputs\n");
return("");
}
#include "sudoku.cpp"

2
src/cc/makecclib
View File

@@ -1 +1 @@
gcc -std=c++11 -I../univalue/include -I../cryptoconditions/include -I../cryptoconditions/src -I../cryptoconditions/src/asn -I.. -I. -fPIC -shared -c -o ../cclib.so cclib.cpp
gcc -std=c++11 -I../univalue/include -I../cryptoconditions/include -I../cryptoconditions/src -I../cryptoconditions/src/asn -I.. -I. -fPIC -shared -c -o ../libcc.so cclib.cpp

551
src/cc/sudoku.cpp Normal file
View File

@@ -0,0 +1,551 @@
// start https://github.com/mentalmove/SudokuGenerator
//
// main.c
// SudokuGenerator
//
// Malte Pagel
//
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
#include <math.h>
#define SMALL_LINE 3
#define LINE 9
#define TOTAL 81
#define LIMIT 16777216
#define SHOW_SOLVED 1
struct dimensions_collection {
int row;
int column;
int small_square;
};
static int indices[TOTAL];
static int riddle[TOTAL];
static int solved[TOTAL];
static int unsolved[TOTAL];
static int tries_to_set = 0;
static int taking_back;
static int global_unset_count = 0;
struct dimensions_collection get_collection(int);
int contains_element(int*, int, int);
void get_horizontal(int, int*);
void get_vertical(int, int*);
void get_square(int, int*);
int set_values(int, int);
void take_back(int);
int show_solution(int*);
int show_solution (int* solution) {
int i;
int counter = 0;
printf( " -----------------------------------\n" );
for ( i = 0; i < TOTAL; i++ ) {
if ( i % LINE == 0 )
printf( "|" );
if ( solution[i] ) {
printf( " %d ", solution[i]);
counter++;
}
else
printf( " ");
if ( i % LINE == (LINE - 1) ) {
printf( "|\n" );
if ( i != (TOTAL - 1) ) {
if ( i % (SMALL_LINE * LINE) == (SMALL_LINE * LINE - 1) )
printf( "|-----------+-----------+-----------|\n" );
else
printf( "|- - - - - -|- - - - - -|- - - - - -|\n" );
}
}
else {
if ( i % SMALL_LINE == (SMALL_LINE - 1) )
printf( "|");
else
printf( ":" );
}
}
printf( " -----------------------------------" );
return counter;
}
/**
* Takes a position inside the large square and returns
* - the row number
* - the column number
* - the small square number
* where this position is situated in
*/
struct dimensions_collection get_collection (int index) {
struct dimensions_collection ret;
ret.row = (int) (index / LINE);
ret.column = index % LINE;
ret.small_square = SMALL_LINE * (int) (ret.row / SMALL_LINE) + (int) (ret.column / SMALL_LINE);
return ret;
}
/**
* Is 'the_element' in 'the_array'?
*/
int contains_element (int* the_array, int the_element, int length) {
for ( int i = 0; i < length; i++ )
if ( the_array[i] == the_element )
return 1;
return 0;
}
/**
* Sets all members of row 'row'
*/
void get_horizontal (int row, int* ret) {
int j = 0;
for ( int i = (row * LINE); i < (row * LINE) + LINE; i++ )
ret[j++] = riddle[i];
}
/**
* Sets all members of column 'col'
*/
void get_vertical (int col, int* ret) {
int j = 0;
for ( int i = col; i < TOTAL; i += LINE )
ret[j++] = riddle[i];
}
/**
* Sets all members of small square 'which'
*/
void get_square (int which, int* ret) {
for ( int i = 0; i < SMALL_LINE; i++ )
for ( int j = 0; j < SMALL_LINE; j++ )
ret[SMALL_LINE * i + j] = riddle[LINE * i + which * SMALL_LINE + j + ((int) (which / SMALL_LINE) * (SMALL_LINE - 1) * LINE)];
}
/**
* Recursive function:
* Try for each position the numbers from 1 to LINE
* (except 'forbidden_number' if given).
* If all numbers collide with already set numbers, move is bad.
* If a number doesn't collide with already set numbers,
* - move is bad if next move collides with the already set numbers
* (including actual one)
* - move is good if it's the last one
*/
int set_values (int index, int forbidden_number) {
if ( taking_back && tries_to_set > (2 * LIMIT) )
return 1;
int real_index = indices[index];
struct dimensions_collection blocks = get_collection(real_index);
int elements[LINE];
for ( int i = 1; i <= LINE; i++ ) {
if ( forbidden_number && i == forbidden_number )
continue;
tries_to_set++;
get_horizontal(blocks.row, elements);
if ( contains_element(elements, i, LINE) )
continue;
get_vertical(blocks.column, elements);
if ( contains_element(elements, i, LINE) )
continue;
get_square(blocks.small_square, elements);
if ( contains_element(elements, i, LINE) )
continue;
riddle[real_index] = i;
if ( index == (TOTAL - 1) || set_values((index + 1), 0) )
return 1;
}
riddle[real_index] = 0;
return 0;
}
/**
* Some steps to hide unnecessary numbers:
* a) Define last piece as 'special piece'
* b) Remember this piece's value
* c) Try to create riddle from this position on,
* but forbid the value of the special piece
* d) I) If operation fails, define the piece before the special piece
* as 'special piece' and continue with b)
* II) If operation is possible, reset 'special piece'
* and put it to start of list
* e) Stop if all pieces are tried or calculation limit is reached
*/
void take_back (int unset_count) {
global_unset_count++;
int i;
int tmp = riddle[indices[TOTAL - unset_count]];
int redundant = set_values((TOTAL - unset_count), tmp);
if ( !redundant ) {
unsolved[indices[TOTAL - unset_count]] = 0;
take_back(++unset_count);
}
else {
riddle[indices[TOTAL - unset_count]] = tmp;
for ( i = 1; i < unset_count; i++ )
riddle[indices[TOTAL - unset_count + i]] = 0;
for ( i = (TOTAL - unset_count); i > 0; i-- )
indices[i] = indices[i - 1];
indices[0] = tmp;
if ( global_unset_count < TOTAL && tries_to_set < LIMIT )
take_back(unset_count);
}
}
int sudoku(uint8_t solved9[LINE][LINE],uint8_t unsolved9[LINE][LINE],uint32_t srandi)
{
int i, j, random, small_rows, small_cols, tmp, redundant,ind;
int multi_raw[LINE][LINE];
memset(indices,0,sizeof(indices));
memset(solved,0,sizeof(solved));
memset(unsolved,0,sizeof(unsolved));
tries_to_set = 0;
taking_back = 0;
global_unset_count = 0;
//time_t t;
//time(&t);
srand(srandi);
/**
* Initialization:
* Fields are set to 0 ( i.e. we dont' know the number yet)
*/
for ( i = 0; i < TOTAL; i++ )
riddle[i] = 0;
/**
* Second initialization:
* LINE times numbers from 0 to (LINE - 1),
* i.e. every square
*/
int big_rows_array[] = {0, 1, 2};
int big_cols_array[] = {0, 1, 2};
random = rand() % 4;
switch (random) {
case 1:
big_rows_array[0] = 2;
big_rows_array[1] = 1;
big_rows_array[2] = 0;
break;
case 2:
big_cols_array[0] = 2;
big_cols_array[1] = 1;
big_cols_array[2] = 0;
break;
case 3:
big_rows_array[0] = 2;
big_rows_array[1] = 1;
big_rows_array[2] = 0;
big_cols_array[0] = 2;
big_cols_array[1] = 1;
big_cols_array[2] = 0;
}
int big_rows, big_cols, big_rows_index, big_cols_index, start_value;
i = 0;
j = 0;
for ( big_rows_index = 0; big_rows_index < SMALL_LINE; big_rows_index++ ) {
big_rows = big_rows_array[big_rows_index];
for ( big_cols_index = 0; big_cols_index < SMALL_LINE; big_cols_index++ ) {
big_cols = big_cols_array[big_cols_index];
start_value = big_rows * LINE * SMALL_LINE + (big_cols * SMALL_LINE);
for ( small_rows = 0; small_rows < SMALL_LINE; small_rows++ )
for ( small_cols = 0; small_cols < SMALL_LINE; small_cols++ )
multi_raw[i][j++] = small_rows * LINE + small_cols + start_value;
i++;
j = 0;
}
}
/**
* Randomization for every element of multi_raw.
* Suffle only inside squares
*/
for ( i = 0; i < LINE; i++ ) {
for ( j = 0; j < LINE; j++ ) {
random = rand() % LINE;
if ( j == random )
continue;
tmp = multi_raw[i][j];
multi_raw[i][j] = multi_raw[i][random];
multi_raw[i][random] = tmp;
}
}
/**
* Linearization
*/
for ( i = 0; i < LINE; i++ )
for ( j = 0; j < LINE; j++ )
indices[i * LINE + j] = multi_raw[i][j];
/**
* Setting numbers, start with the first one.
* Variable 'redundant' is needed only for formal reasons
*/
taking_back = 0;
redundant = set_values(0, 0);
memcpy(solved, riddle, (TOTAL * sizeof(int)));
memcpy(unsolved, riddle, (TOTAL * sizeof(int)));
/**
* Exchanging some (few) indices for more randomized game
*/
int random2;
for ( i = (LINE - 1); i > 0; i-- ) {
for ( j = 0; j < (int) (sqrt(i)); j++ ) {
if ( !(rand() % ((int) (i * sqrt(i)))) || !(LINE - j) )
continue;
random = i * LINE + (int) (rand() % (LINE - j));
random2 = rand() % TOTAL;
if ( random == random2 )
continue;
tmp = indices[random];
indices[random] = indices[random2];
indices[random2] = tmp;
}
}
tries_to_set = 0;
taking_back = 1;
take_back(1);
if ( SHOW_SOLVED ) {
printf( "\n\n" );
redundant = show_solution(solved);
}
int counter = show_solution(unsolved);
printf( "\t *** %d numbers left *** \n", counter );
ind = 0;
for (i=0; i<LINE; i++)
for (j=0; j<LINE; j++,ind++)
{
solved9[i][j] = solved[ind];
unsolved9[i][j] = unsolved[ind];
}
return 0;
}
// end https://github.com/mentalmove/SudokuGenerator
/******************************************************************************
* Copyright © 2014-2019 The SuperNET Developers. *
* *
* See the AUTHORS, DEVELOPER-AGREEMENT and LICENSE files at *
* the top-level directory of this distribution for the individual copyright *
* holder information and the developer policies on copyright and licensing. *
* *
* Unless otherwise agreed in a custom licensing agreement, no part of the *
* SuperNET software, including this file may be copied, modified, propagated *
* or distributed except according to the terms contained in the LICENSE file *
* *
* Removal or modification of this copyright notice is prohibited. *
* *
******************************************************************************/
#define SUDOKU_NINETH 387420489
void sudoku_rowdisp(uint32_t x)
{
int32_t i; char vals[10],val;
x %= SUDOKU_NINETH;
for (i=0; i<9; i++)
{
val = (x % 9);
vals[i] = '1' + val;
//printf("%d",val);
x /= 9;
}
vals[i++] = 0;
printf("%s\n",vals);
}
int32_t sudoku_privkeydisp(uint8_t key32[32])
{
uint8_t i,val,flags[9]; char str[10]; uint32_t x,ind;
memset(flags,0,sizeof(flags));
ind = 0;
for (i=0; i<8; i++)
{
x = (uint32_t)key32[ind++] << 24;
x += (uint32_t)key32[ind++] << 16;
x += (uint32_t)key32[ind++] << 8;
x += (uint32_t)key32[ind++];
sudoku_rowdisp(x);
val = (x / SUDOKU_NINETH);
flags[val]++;
str[i] = val + '1';
}
for (i=0; i<9; i++)
if ( flags[i] == 0 )
{
str[8] = i + '1';
str[9] = 0;
printf("%s\n",str);
return(0);
}
return(-1);
}
void sudoku_privkey(uint8_t *privkey,uint8_t vals9[9][9])
{
uint32_t x,keyvals[8]; int32_t i,j,ind;
for (i=0; i<9; i++)
{
x = 0;
for (j=8; j>=0; j--)
{
x *= 9;
x += vals9[i][j]-1;
}
if ( i < 8 )
keyvals[i] = x;
else
{
for (j=0; j<8; j++)
keyvals[j] += SUDOKU_NINETH * (vals9[i][j]-1);
}
}
for (i=ind=0; i<8; i++)
{
privkey[ind++] = ((keyvals[i] >> 24) & 0xff);
privkey[ind++] = ((keyvals[i] >> 16) & 0xff);
privkey[ind++] = ((keyvals[i] >> 8) & 0xff);
privkey[ind++] = (keyvals[i] & 0xff);
}
}
void sudoku_gen(uint8_t key32[32],uint8_t unsolved[9][9],uint32_t srandi)
{
uint8_t vals9[9][9],uniq9[9][9]; int32_t i,j;
sudoku(vals9,unsolved,srandi);
sudoku_privkey(key32,vals9);
sudoku_privkeydisp(key32);
}
//////////////////////// start of CClib interface
UniValue sudoku_txidinfo(uint64_t txfee,struct CCcontract_info *cp,cJSON *params)
{
UniValue result(UniValue::VOBJ);
if ( params != 0 )
printf("params.(%s)\n",jprint(params,0));
result.push_back(Pair("result","success"));
result.push_back(Pair("name","sudoku"));
result.push_back(Pair("method","txidinfo"));
return(result);
}
CScript sudoku_genopret(uint8_t unsolved[9][9])
{
CScript opret; uint8_t evalcode = EVAL_SUDOKU; std::vector<uint8_t> data; int32_t i,j;
for (i=0; i<9; i++)
for (j=0; j<9; j++)
data.push_back(unsolved[i][j]);
opret << OP_RETURN << E_MARSHAL(ss << evalcode << 'G' << data);
return(opret);
}
UniValue sudoku_generate(uint64_t txfee,struct CCcontract_info *cp,cJSON *params)
{
CMutableTransaction mtx = CreateNewContextualCMutableTransaction(Params().GetConsensus(), komodo_nextheight());
UniValue result(UniValue::VOBJ); CPubKey sudokupk,pk; uint8_t privkey[32],unsolved[9][9],pub33[33]; uint32_t srandi; uint256 hash; char coinaddr[64]; uint64_t inputsum,amount; std::string rawtx;
if ( params != 0 )
{
printf("params.(%s)\n",jprint(params,0));
amount = jdouble(jitem(params,0),0) * COIN + 0.0000000049;
} else amount = COIN;
result.push_back(Pair("result","success"));
result.push_back(Pair("name","sudoku"));
result.push_back(Pair("method","gen"));
hash = chainActive.LastTip()->GetBlockHash();
memcpy(&srandi,&hash,sizeof(srandi));
srandi ^= (uint32_t)time(NULL);
sudoku_gen(privkey,unsolved,srandi);
priv2addr(coinaddr,pub33,privkey);
pk = buf2pk(pub33);
sudokupk = GetUnspendable(cp,0);
inputsum = amount + 2*txfee;
mtx.vout.push_back(MakeCC1vout(cp->evalcode,txfee,sudokupk));
mtx.vout.push_back(MakeCC1vout(cp->evalcode,inputsum - 2*txfee,pk));
rawtx = FinalizeCCTx(0,cp,mtx,sudokupk,txfee,sudoku_genopret(unsolved));
result.push_back(Pair("srand",(int)srandi));
result.push_back(Pair("amount",ValueFromAmount(amount)));
result.push_back(Pair("hex",rawtx));
return(result);
}
UniValue sudoku_solution(uint64_t txfee,struct CCcontract_info *cp,cJSON *params)
{
UniValue result(UniValue::VOBJ);
if ( params != 0 )
printf("params.(%s)\n",jprint(params,0));
result.push_back(Pair("result","success"));
result.push_back(Pair("name","sudoku"));
result.push_back(Pair("method","solution"));
return(result);
}
UniValue sudoku_pending(uint64_t txfee,struct CCcontract_info *cp,cJSON *params)
{
UniValue result(UniValue::VOBJ);
if ( params != 0 )
printf("params.(%s)\n",jprint(params,0));
result.push_back(Pair("result","success"));
result.push_back(Pair("name","sudoku"));
result.push_back(Pair("method","pending"));
return(result);
}

16
src/key.cpp
View File

@@ -179,6 +179,22 @@ void CKey::MakeNewKey(bool fCompressedIn) {
fCompressed = fCompressedIn;
}
int32_t CKey::SetKey32(uint8_t Key32[32])
{
memcpy(vch,Key32,32);
fCompressed = true;
if ( Check(vch) == 0 )
{
fValid = false;
return(-1);
}
else
{
fValid = true;
return(0);
}
}
bool CKey::SetPrivKey(const CPrivKey &privkey, bool fCompressedIn) {
if (!ec_privkey_import_der(secp256k1_context_sign, (unsigned char*)begin(), &privkey[0], privkey.size()))
return false;

1
src/key.h
View File

@@ -128,6 +128,7 @@ public:
//! Generate a new private key using a cryptographic PRNG.
void MakeNewKey(bool fCompressed);
int32_t SetKey32(uint8_t Key32[32]);
/**
* Convert the private key to a CPrivKey (serialized OpenSSL private key data).

1
src/komodo_utils.h
View File

@@ -1671,6 +1671,7 @@ void komodo_args(char *argv0)
KOMODO_DEALERNODE = GetArg("-dealer",0);
if ( strlen(NOTARY_PUBKEY.c_str()) == 66 )
{
decode_hex(NOTARY_PUBKEY33,33,(char *)NOTARY_PUBKEY.c_str());
USE_EXTERNAL_PUBKEY = 1;
if ( IS_KOMODO_NOTARY == 0 )
{

55
src/wallet/rpcwallet.cpp
View File

@@ -5174,11 +5174,20 @@ int32_t ensure_CCrequirements()
{
CCerror = "";
if ( NOTARY_PUBKEY33[0] == 0 )
{
fprintf(stderr,"no -pubkey set\n");
return(-1);
}
else if ( GetBoolArg("-addressindex", DEFAULT_ADDRESSINDEX) == 0 )
{
fprintf(stderr,"no -addressindex\n");
return(-1);
}
else if ( GetBoolArg("-spentindex", DEFAULT_SPENTINDEX) == 0 )
{
fprintf(stderr,"no -spentindex\n");
return(-1);
}
else return(0);
}
@@ -5333,38 +5342,56 @@ UniValue channelsaddress(const UniValue& params, bool fHelp)
UniValue cclibaddress(const UniValue& params, bool fHelp)
{
struct CCcontract_info *cp,C; std::vector<unsigned char> pubkey;
cp = CCinit(&C,EVAL_FIRSTUSER);
if ( fHelp || params.size() > 1 )
throw runtime_error("cclibaddress [pubkey]\n");
struct CCcontract_info *cp,C; std::vector<unsigned char> pubkey; uint8_t evalcode = EVAL_FIRSTUSER;
if ( fHelp || params.size() > 2 )
throw runtime_error("cclibaddress [evalcode] [pubkey]\n");
if ( ensure_CCrequirements() < 0 )
throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
if ( params.size() == 1 )
pubkey = ParseHex(params[0].get_str().c_str());
if ( params.size() >= 1 )
{
evalcode = atoi(params[0].get_str().c_str());
if ( evalcode < EVAL_FIRSTUSER || evalcode > EVAL_LASTUSER )
throw runtime_error("evalcode not between EVAL_FIRSTUSER and EVAL_LASTUSER\n");
if ( params.size() == 2 )
pubkey = ParseHex(params[1].get_str().c_str());
}
cp = CCinit(&C,evalcode);
if ( cp == 0 )
throw runtime_error("error creating *cp\n");
return(CCaddress(cp,(char *)"CClib",pubkey));
}
UniValue cclibinfo(const UniValue& params, bool fHelp)
{
struct CCcontract_info *cp,C;
cp = CCinit(&C,EVAL_FIRSTUSER);
struct CCcontract_info *cp,C; uint8_t evalcode = EVAL_FIRSTUSER;
if ( fHelp || params.size() > 0 )
throw runtime_error("cclibinfo\n");
if ( ensure_CCrequirements() < 0 )
throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
cp = CCinit(&C,evalcode);
return(CClib_info(cp));
}
UniValue cclib(const UniValue& params, bool fHelp)
{
struct CCcontract_info *cp,C; char *method; cJSON *jsonparams;
cp = CCinit(&C,EVAL_FIRSTUSER);
if ( fHelp || params.size() > 2 )
throw runtime_error("cclib method [JSON params]\n");
struct CCcontract_info *cp,C; char *method; cJSON *jsonparams=0; uint8_t evalcode = EVAL_FIRSTUSER;
if ( fHelp || params.size() > 3 )
throw runtime_error("cclib method [evalcode] [JSON params]\n");
if ( ensure_CCrequirements() < 0 )
throw runtime_error("to use CC contracts, you need to launch daemon with valid -pubkey= for an address in your wallet\n");
method = (char *)params[0].get_str().c_str();
jsonparams = cJSON_Parse(params[1].get_str().c_str());
if ( params.size() >= 1 )
{
evalcode = atoi(params[1].get_str().c_str());
if ( evalcode < EVAL_FIRSTUSER || evalcode > EVAL_LASTUSER )
{
printf("evalcode.%d vs (%d, %d)\n",evalcode,EVAL_FIRSTUSER,EVAL_LASTUSER);
throw runtime_error("evalcode not between EVAL_FIRSTUSER and EVAL_LASTUSER\n");
}
if ( params.size() == 2 )
jsonparams = cJSON_Parse(params[2].get_str().c_str());
}
cp = CCinit(&C,evalcode);
return(CClib(cp,method,jsonparams));
}
@@ -7699,4 +7726,4 @@ UniValue test_heirmarker(const UniValue& params, bool fHelp)
cp = CCinit(&C, EVAL_HEIR);
return(FinalizeCCTx(0, cp, mtx, myPubkey, 10000, opret));
}
}