Merge pull request #21 from jl777/jl777

Jl777

depends/packages/boost.mk

@@ -1,9 +1,8 @@
-
 package=boost
-$(package)_version=1_66_0
+$(package)_version=1_69_0
-$(package)_download_path=https://dl.bintray.com/boostorg/release/1.66.0/source
+$(package)_download_path=https://dl.bintray.com/boostorg/release/1.69.0/source
 $(package)_file_name=$(package)_$($(package)_version).tar.bz2
-$(package)_sha256_hash=5721818253e6a0989583192f96782c4a98eb6204965316df9f5ad75819225ca9
+$(package)_sha256_hash=8f32d4617390d1c2d16f26a27ab60d97807b35440d45891fa340fc2648b04406
 
 define $(package)_set_vars
 $(package)_config_opts_release=variant=release

depends/packages/libsodium.mk

@@ -1,12 +1,3 @@
-ifeq ($(build_os),darwin)
-package=libsodium
-$(package)_version=1.0.11
-$(package)_download_path=https://supernetorg.bintray.com/misc
-$(package)_file_name=libsodium-1.0.11.tar.gz
-$(package)_sha256_hash=a14549db3c49f6ae2170cbbf4664bd48ace50681045e8dbea7c8d9fb96f9c765
-$(package)_dependencies=
-$(package)_config_opts=
-else
 package=libsodium
 $(package)_version=1.0.15
 $(package)_download_path=https://download.libsodium.org/libsodium/releases/old
@@ -14,6 +5,13 @@ $(package)_file_name=$(package)-$($(package)_version).tar.gz
 $(package)_sha256_hash=fb6a9e879a2f674592e4328c5d9f79f082405ee4bb05cb6e679b90afe9e178f4
 $(package)_dependencies=
 $(package)_config_opts=
+
+ifeq ($(build_os),darwin)
+define $(package)_set_vars
+  $(package)_build_env=MACOSX_DEPLOYMENT_TARGET="10.11"
+  $(package)_cc=clang
+  $(package)_cxx=clang++
+endef
 endif
 
 define $(package)_preprocess_cmds

depends/packages/openssl.mk

@@ -1,8 +1,8 @@
 package=openssl
-$(package)_version=1.1.0h
+$(package)_version=1.1.1a
 $(package)_download_path=https://www.openssl.org/source
 $(package)_file_name=$(package)-$($(package)_version).tar.gz
-$(package)_sha256_hash=5835626cde9e99656585fc7aaa2302a73a7e1340bf8c14fd635a62c66802a517
+$(package)_sha256_hash=fc20130f8b7cbd2fb918b2f14e2f429e109c31ddd0fb38fc5d71d9ffed3f9f41
 
 define $(package)_set_vars
 $(package)_config_env=AR="$($(package)_ar)" RANLIB="$($(package)_ranlib)" CC="$($(package)_cc)"
@@ -92,7 +92,7 @@ $(package)_config_opts_i686_mingw32=mingw
 endef
 
 define $(package)_preprocess_cmds
-  sed -i.old "/define DATE/d" util/mkbuildinf.pl && \
+  sed -i.old 's/built on: $date/built on: not available/' util/mkbuildinf.pl && \
   sed -i.old "s|\"engines\", \"apps\", \"test\"|\"engines\"|" Configure
 endef
 

depends/packages/rust.mk

@@ -1,13 +1,13 @@
 package=rust
-$(package)_version=1.28.0
+$(package)_version=1.32.0
 $(package)_download_path=https://static.rust-lang.org/dist
 
 $(package)_file_name_linux=rust-$($(package)_version)-x86_64-unknown-linux-gnu.tar.gz
-$(package)_sha256_hash_linux=2a1390340db1d24a9498036884e6b2748e9b4b057fc5219694e298bdaa37b810
+$(package)_sha256_hash_linux=e024698320d76b74daf0e6e71be3681a1e7923122e3ebd03673fcac3ecc23810
 $(package)_file_name_darwin=rust-$($(package)_version)-x86_64-apple-darwin.tar.gz
-$(package)_sha256_hash_darwin=5d7a70ed4701fe9410041c1eea025c95cad97e5b3d8acc46426f9ac4f9f02393
+$(package)_sha256_hash_darwin=f0dfba507192f9b5c330b5984ba71d57d434475f3d62bd44a39201e36fa76304
 $(package)_file_name_mingw32=rust-$($(package)_version)-x86_64-pc-windows-gnu.tar.gz
-$(package)_sha256_hash_mingw32=55c07426f791c51c8a2b6934b35784175c4abb4e03f123f3e847109c4dc1ad8b
+$(package)_sha256_hash_mingw32=358e1435347c67dbf33aa9cad6fe501a833d6633ed5d5aa1863d5dffa0349be9
 
 ifeq ($(build_os),darwin)
 $(package)_file_name=$($(package)_file_name_darwin)

src/Makefile.am

@@ -575,11 +575,13 @@ komodod_LDADD += \
 
 if TARGET_DARWIN
 komodod_LDADD += libcc.dylib $(LIBSECP256K1)
+endif
+if TARGET_WINDOWS
+komodod_LDADD += libcc.dll $(LIBSECP256K1)
 else
 komodod_LDADD += libcc.so $(LIBSECP256K1)
 endif
 
-
 if ENABLE_PROTON
 komodod_LDADD += $(LIBBITCOIN_PROTON) $(PROTON_LIBS)
 endif

src/cc/cclib.cpp

@@ -584,14 +584,6 @@ uint256 juint256(cJSON *obj)
 
 #else
 #include "sudoku.cpp"
-#define USE_BASIC_CONFIG
-#define ENABLE_MODULE_MUSIG
-#include "../secp256k1/src/basic-config.h"
-#include "../secp256k1/include/secp256k1.h"
-#include "../secp256k1/src/ecmult.h"
-#include "../secp256k1/src/ecmult_gen.h"
-
-typedef struct { unsigned char data[64]; } secp256k1_schnorrsig;
 
 /*
 #include "../secp256k1/src/util.h"
@@ -623,17 +615,6 @@ return 0; \
 } while(0)*/
 
 //#include "../secp256k1/src/secp256k1.c"
-struct secp256k1_context_struct {
-    secp256k1_ecmult_context ecmult_ctx;
-    secp256k1_ecmult_gen_context ecmult_gen_ctx;
-    secp256k1_callback illegal_callback;
-    secp256k1_callback error_callback;
-};
-
-extern "C" int secp256k1_ecmult_multi_var(const secp256k1_ecmult_context *ctx, secp256k1_scratch *scratch, secp256k1_gej *r, const secp256k1_scalar *inp_g_sc, secp256k1_ecmult_multi_callback cb, void *cbdata, size_t n);
-extern "C" int secp256k1_schnorrsig_verify(const secp256k1_context* ctx, const secp256k1_schnorrsig *sig, const unsigned char *msg32, const secp256k1_pubkey *pk);
-extern "C" int secp256k1_schnorrsig_parse(const secp256k1_context* ctx, secp256k1_schnorrsig* sig, const unsigned char *in64);
-
 #include "musig.cpp"
 #endif
 

src/cc/makerogue

@@ -1,7 +1,30 @@
 #!/bin/sh
 cd rogue;
-./configure
+
-make; cd ..
+if [ "$HOST" = "x86_64-w64-mingw32" ]; then
+  echo building rogue.exe...
+  mkdir ncurses && cd ncurses
+  wget https://invisible-island.net/datafiles/release/mingw32.zip
+  unzip mingw32.zip && delete mingw32.zip
+  cd ..
+  if make -f Makefile_win "$@"; then
+    echo rogue.exe build SUCCESSFUL
+    cd ..
+  else
+    echo rogue.exe build FAILED
+  exit 1
+  fi
+else
+  echo building rogue...
+  ./configure
+  if make "$@"; then
+    echo rogue build SUCCESSFUL
+    cd ..
+  else
+    echo rogue build FAILED
+    exit 1
+  fi
+fi
 
 if make -f Makefile_rogue "$@"; then
   echo ROGUE BUILD SUCCESSFUL

src/cc/musig.cpp

@@ -13,8 +13,74 @@
  *                                                                            *
  ******************************************************************************/
 
+/* first make a combined pk:
+./c cclib combine 18 \"[%2202aff51dad774a1c612dc82e63f85f07b992b665836b0f0efbcb26ee679f4f4848%22,%22039433dc3749aece1bd568f374a45da3b0bc6856990d7da3cd175399577940a775%22]\"
+{
+    "pkhash": "5be117f3c5ce87e7dc6882c24b8231e0652ee82054bf7b9f94aef1f45e055cba",
+    "combined_pk": "032ddac56613cd0667b589bd7f32b665e2d2ce0247e337a5a0bca6c72e3d9d057b",
+    "result": "success"
+}
+*/
 
+/* second, send 0.777 coins to the combined_pk
+ ./c cclib send 18 \"[%22032ddac56613cd0667b589bd7f32b665e2d2ce0247e337a5a0bca6c72e3d9d057b%22,0.777]\"
+ {
+ "hex": "0400008085202f8901bf7afcbbab7a5e1ba20c8010325e199305afa7d15b4bc86a589a512201d39924000000004847304402203e0cff8aaa831dd990afd979bbc0a648316f77407cb5e02780d18e0670f5172a0220283d5c52d0406b10c508cc2b19dd6dbe2420e7c5cf431a1d41072d0eec28edb901ffffffff03b0c2a10400000000302ea22c8020c71ddb3aac7f9b9e4bdacf032aaa8b8e4433c4ff9f8a43cebb9c1f5da96928a48103120c008203000401cca91e223700000000232102aff51dad774a1c612dc82e63f85f07b992b665836b0f0efbcb26ee679f4f4848ac0000000000000000266a24127821032ddac56613cd0667b589bd7f32b665e2d2ce0247e337a5a0bca6c72e3d9d057b00000000900000000000000000000000000000",
+ "txid": "cb5309ed249da95e2b5696eb763a8736e2fff1d14922ada737b931494ca3d2be",
+ "result": "success"
+ }
+ 
+ {
+ "value": 0.77710000,
+ "valueZat": 77710000,
+ "n": 0,
+ "scriptPubKey": {
+ "asm": "a22c8020c71ddb3aac7f9b9e4bdacf032aaa8b8e4433c4ff9f8a43cebb9c1f5da96928a48103120c008203000401 OP_CHECKCRYPTOCONDITION",
+ "hex": "2ea22c8020c71ddb3aac7f9b9e4bdacf032aaa8b8e4433c4ff9f8a43cebb9c1f5da96928a48103120c008203000401cc",
+ "reqSigs": 1,
+ "type": "cryptocondition",
+ "addresses": [
+ "RKWS7jxyjPX9iaJttk8iMKf1AumanKypez"
+ ]
+ }
+ change script: 2102aff51dad774a1c612dc82e63f85f07b992b665836b0f0efbcb26ee679f4f4848ac
+ 
+ sendtxid: cb5309ed249da95e2b5696eb763a8736e2fff1d14922ada737b931494ca3d2be
+ 
+ broadcast sendtxid and wait for it to be confirmed. then get the msg we need to sign:
+ 
+ ./c cclib calcmsg 18 \"[%22cb5309ed249da95e2b5696eb763a8736e2fff1d14922ada737b931494ca3d2be%22,%222102aff51dad774a1c612dc82e63f85f07b992b665836b0f0efbcb26ee679f4f4848ac%22]\"
+ 
+ {
+ "result": "success",
+ "msg": "63b799913d4c9487f321b32d6ae8614f653f38e0b50d4df4bc1d36339ea18485"
+ }
+
+*/
+
+
+#define USE_BASIC_CONFIG
+#define ENABLE_MODULE_MUSIG
+#include "../secp256k1/src/basic-config.h"
 #include "../secp256k1/include/secp256k1.h"
+#include "../secp256k1/src/ecmult.h"
+#include "../secp256k1/src/ecmult_gen.h"
+
+typedef struct { unsigned char data[64]; } secp256k1_schnorrsig;
+struct secp256k1_context_struct {
+    secp256k1_ecmult_context ecmult_ctx;
+    secp256k1_ecmult_gen_context ecmult_gen_ctx;
+    secp256k1_callback illegal_callback;
+    secp256k1_callback error_callback;
+};
+
+extern "C" int secp256k1_ecmult_multi_var(const secp256k1_ecmult_context *ctx, secp256k1_scratch *scratch, secp256k1_gej *r, const secp256k1_scalar *inp_g_sc, secp256k1_ecmult_multi_callback cb, void *cbdata, size_t n);
+extern "C" int secp256k1_schnorrsig_verify(const secp256k1_context* ctx, const secp256k1_schnorrsig *sig, const unsigned char *msg32, const secp256k1_pubkey *pk);
+extern "C" int secp256k1_schnorrsig_parse(const secp256k1_context* ctx, secp256k1_schnorrsig* sig, const unsigned char *in64);
+extern "C" int secp256k1_musig_pubkey_combine(const secp256k1_context* ctx, secp256k1_scratch_space *scratch, secp256k1_pubkey *combined_pk, unsigned char *pk_hash32, const secp256k1_pubkey *pubkeys, size_t n_pubkeys);
+
+
+//#include "../secp256k1/include/secp256k1.h"
 //#include "../secp256k1/include/secp256k1_schnorrsig.h"
 #include "../secp256k1/include/secp256k1_musig.h"
 
@@ -62,7 +128,6 @@ int32_t musig_msghash(uint8_t *msg,uint256 prevhash,int32_t prevn,CTxOut vout,CP
 {
     CScript data; uint256 hash; int32_t len = 0;
     data << E_MARSHAL(ss << prevhash << prevn << vout << pk);
-fprintf(stderr,"data size %d\n",(int32_t)data.size());
     hash = Hash(data.begin(),data.end());
     memcpy(msg,&hash,sizeof(hash));
     return(0);
@@ -110,15 +175,79 @@ UniValue musig_calcmsg(uint64_t txfee,struct CCcontract_info *cp,cJSON *params)
 
 UniValue musig_combine(uint64_t txfee,struct CCcontract_info *cp,cJSON *params)
 {
-    UniValue result(UniValue::VOBJ);
+    static secp256k1_context *ctx;
-    result.push_back(Pair("result","success"));
+    size_t clen = CPubKey::PUBLIC_KEY_SIZE;
-    return(result);
+    UniValue result(UniValue::VOBJ); CPubKey pk; int32_t i,n; uint8_t pkhash[32]; char *hexstr,str[67]; secp256k1_pubkey combined_pk,spk; std::vector<secp256k1_pubkey> pubkeys;
+    if ( ctx == 0 )
+        ctx = secp256k1_context_create(SECP256K1_CONTEXT_SIGN | SECP256K1_CONTEXT_VERIFY);
+    if ( params != 0 && (n= cJSON_GetArraySize(params)) > 0 )
+    {
+        //fprintf(stderr,"n.%d args.(%s)\n",n,jprint(params,0));
+        for (i=0; i<n; i++)
+        {
+            if ( (hexstr= jstr(jitem(params,i),0)) != 0 && is_hexstr(hexstr,0) == 66 )
+            {
+                CPubKey pk(ParseHex(hexstr));
+                if ( secp256k1_ec_pubkey_parse(ctx,&spk,pk.begin(),33) > 0 )
+                    pubkeys.push_back(spk);
+                else return(cclib_error(result,"error parsing pk"));
+            } else return(cclib_error(result,"all pubkeys must be 33 bytes hexdata"));
+        }
+        if ( secp256k1_musig_pubkey_combine(ctx,NULL,&combined_pk,pkhash,&pubkeys[0],n) > 0 )
+        {
+            if ( secp256k1_ec_pubkey_serialize(ctx,(uint8_t *)pk.begin(),&clen,&combined_pk,SECP256K1_EC_COMPRESSED) > 0 && clen == 33 )
+            {
+                for (i=0; i<32; i++)
+                    sprintf(&str[i<<1],"%02x",pkhash[i]);
+                str[64] = 0;
+                result.push_back(Pair("pkhash",str));
+                
+                for (i=0; i<33; i++)
+                    sprintf(&str[i<<1],"%02x",((uint8_t *)pk.begin())[i]);
+                str[66] = 0;
+                result.push_back(Pair("combined_pk",str));
+                result.push_back(Pair("result","success"));
+                return(result);
+            } else return(cclib_error(result,"error serializeing combined_pk"));
+        } else return(cclib_error(result,"error combining pukbeys"));
+    } else return(cclib_error(result,"need pubkeys params"));
 }
 
 UniValue musig_session(uint64_t txfee,struct CCcontract_info *cp,cJSON *params)
 {
     UniValue result(UniValue::VOBJ);
     result.push_back(Pair("result","success"));
+    /** Initializes a signing session for a signer
+     *
+     *  Returns: 1: session is successfully initialized
+     *           0: session could not be initialized: secret key or secret nonce overflow
+     *  Args:         ctx: pointer to a context object, initialized for signing (cannot
+     *                     be NULL)
+     *  Out:      session: the session structure to initialize (cannot be NULL)
+     *            signers: an array of signers' data to be initialized. Array length must
+     *                     equal to `n_signers` (cannot be NULL)
+     * nonce_commitment32: filled with a 32-byte commitment to the generated nonce
+     *                     (cannot be NULL)
+     *  In:  session_id32: a *unique* 32-byte ID to assign to this session (cannot be
+     *                     NULL). If a non-unique session_id32 was given then a partial
+     *                     signature will LEAK THE SECRET KEY.
+     *              msg32: the 32-byte message to be signed. Shouldn't be NULL unless you
+     *                     require sharing public nonces before the message is known
+     *                     because it reduces nonce misuse resistance. If NULL, must be
+     *                     set with `musig_session_set_msg` before signing and verifying.
+     *        combined_pk: the combined public key of all signers (cannot be NULL)
+     *          pk_hash32: the 32-byte hash of the signers' individual keys (cannot be
+     *                     NULL)
+     *          n_signers: length of signers array. Number of signers participating in
+     *                     the MuSig. Must be greater than 0 and at most 2^32 - 1.
+     *           my_index: index of this signer in the signers array
+     *             seckey: the signer's 32-byte secret key (cannot be NULL)
+     */
+    //if (!secp256k1_musig_session_initialize(ctx, &musig_session[i], signer_data[i], nonce_commitment[i], session_id32, msg32, &combined_pk, pk_hash, N_SIGNERS, i, seckeys[i]))
+        //return 0;
+    // randombytes_buf(buf, num);
+
+    //nonce_commitment_ptr[i] = &nonce_commitment[i][0];
     return(result);
 }
 
@@ -126,6 +255,25 @@ UniValue musig_commit(uint64_t txfee,struct CCcontract_info *cp,cJSON *params)
 {
     UniValue result(UniValue::VOBJ);
     result.push_back(Pair("result","success"));
+    /** Gets the signer's public nonce given a list of all signers' data with commitments
+     *
+     *  Returns: 1: public nonce is written in nonce
+     *           0: signer data is missing commitments or session isn't initialized
+     *              for signing
+     *  Args:        ctx: pointer to a context object (cannot be NULL)
+     *           session: the signing session to get the nonce from (cannot be NULL)
+     *           signers: an array of signers' data initialized with
+     *                    `musig_session_initialize`. Array length must equal to
+     *                    `n_commitments` (cannot be NULL)
+     *  Out:       nonce: the nonce (cannot be NULL)
+     *  In:  commitments: array of 32-byte nonce commitments (cannot be NULL)
+     *     n_commitments: the length of commitments and signers array. Must be the total
+     *                    number of signers participating in the MuSig.
+     */
+    // Set nonce commitments in the signer data and get the own public nonce
+    //if (!secp256k1_musig_session_get_public_nonce(ctx, &musig_session[i], signer_data[i], &nonce[i], nonce_commitment_ptr, N_SIGNERS))
+       // return 0;
+    
     return(result);
 }
 
@@ -133,13 +281,69 @@ UniValue musig_nonce(uint64_t txfee,struct CCcontract_info *cp,cJSON *params)
 {
     UniValue result(UniValue::VOBJ);
     result.push_back(Pair("result","success"));
-    return(result);
+    /** Checks a signer's public nonce against a commitment to said nonce, and update
+     *  data structure if they match
+     *
+     *  Returns: 1: commitment was valid, data structure updated
+     *           0: commitment was invalid, nothing happened
+     *  Args:      ctx: pointer to a context object (cannot be NULL)
+     *          signer: pointer to the signer data to update (cannot be NULL). Must have
+     *                  been used with `musig_session_get_public_nonce` or initialized
+     *                  with `musig_session_initialize_verifier`.
+     *  In:     nonce: signer's alleged public nonce (cannot be NULL)
+     */
+    //if (!secp256k1_musig_set_nonce(ctx, &signer_data[i][j], &nonce[j])) {
+   
+    
+    /** Updates a session with the combined public nonce of all signers. The combined
+     * public nonce is the sum of every signer's public nonce.
+     *
+     *  Returns: 1: nonces are successfully combined
+     *           0: a signer's nonce is missing
+     *  Args:        ctx: pointer to a context object (cannot be NULL)
+     *           session: session to update with the combined public nonce (cannot be
+     *                    NULL)
+     *           signers: an array of signers' data, which must have had public nonces
+     *                    set with `musig_set_nonce`. Array length must equal to `n_signers`
+     *                    (cannot be NULL)
+     *         n_signers: the length of the signers array. Must be the total number of
+     *                    signers participating in the MuSig.
+     *  Out: nonce_is_negated: a pointer to an integer that indicates if the combined
+     *                    public nonce had to be negated.
+     *           adaptor: point to add to the combined public nonce. If NULL, nothing is
+     *                    added to the combined nonce.
+     */
+    // after all nonces: if (!secp256k1_musig_session_combine_nonces(ctx, &musig_session[i], signer_data[i], N_SIGNERS, NULL, NULL)) {
+        return(result);
 }
 
 UniValue musig_partialsign(uint64_t txfee,struct CCcontract_info *cp,cJSON *params)
 {
     UniValue result(UniValue::VOBJ);
     result.push_back(Pair("result","success"));
+    /** Produces a partial signature
+     *
+     *  Returns: 1: partial signature constructed
+     *           0: session in incorrect or inconsistent state
+     *  Args:         ctx: pointer to a context object (cannot be NULL)
+     *            session: active signing session for which the combined nonce has been
+     *                     computed (cannot be NULL)
+     *  Out:  partial_sig: partial signature (cannot be NULL)
+     */
+    //if (!secp256k1_musig_partial_sign(ctx, &musig_session[i], &partial_sig[i])) {
+    /** Parse and verify a MuSig partial signature.
+     *
+     *  Returns: 1 when the signature could be parsed, 0 otherwise.
+     *  Args:    ctx: a secp256k1 context object
+     *  Out:     sig: pointer to a signature object
+     *  In:     in32: pointer to the 32-byte signature to be parsed
+     *
+     *  After the call, sig will always be initialized. If parsing failed or the
+     *  encoded numbers are out of range, signature verification with it is
+     *  guaranteed to fail for every message and public key.
+     */
+    //SECP256K1_API int secp256k1_musig_partial_signature_parse(
+
     return(result);
 }
 
@@ -147,13 +351,54 @@ UniValue musig_sigcombine(uint64_t txfee,struct CCcontract_info *cp,cJSON *param
 {
     UniValue result(UniValue::VOBJ);
     result.push_back(Pair("result","success"));
-    return(result);
+    /** Checks that an individual partial signature verifies
+     *
+     *  This function is essential when using protocols with adaptor signatures.
+     *  However, it is not essential for regular MuSig's, in the sense that if any
+     *  partial signatures does not verify, the full signature will also not verify, so the
+     *  problem will be caught. But this function allows determining the specific party
+     *  who produced an invalid signature, so that signing can be restarted without them.
+     *
+     *  Returns: 1: partial signature verifies
+     *           0: invalid signature or bad data
+     *  Args:         ctx: pointer to a context object (cannot be NULL)
+     *            session: active session for which the combined nonce has been computed
+     *                     (cannot be NULL)
+     *             signer: data for the signer who produced this signature (cannot be NULL)
+     *  In:   partial_sig: signature to verify (cannot be NULL)
+     *             pubkey: public key of the signer who produced the signature (cannot be NULL)
+     */
+    //if (!secp256k1_musig_partial_sig_verify(ctx, &musig_session[i], &signer_data[i][j], &partial_sig[j], &pubkeys[j])) {
+        return 0;
+    /** Combines partial signatures
+     *
+     *  Returns: 1: all partial signatures have values in range. Does NOT mean the
+     *              resulting signature verifies.
+     *           0: some partial signature had s/r out of range
+     *  Args:         ctx: pointer to a context object (cannot be NULL)
+     *            session: initialized session for which the combined nonce has been
+     *                     computed (cannot be NULL)
+     *  Out:          sig: complete signature (cannot be NULL)
+     *  In:  partial_sigs: array of partial signatures to combine (cannot be NULL)
+     *             n_sigs: number of signatures in the partial_sigs array
+     */
+   // after all partials: return secp256k1_musig_partial_sig_combine(ctx, &musig_session[0], sig, partial_sig, N_SIGNERS return(result);
 }
 
 UniValue musig_verify(uint64_t txfee,struct CCcontract_info *cp,cJSON *params)
 {
     UniValue result(UniValue::VOBJ);
     result.push_back(Pair("result","success"));
+    /** Verify a Schnorr signature.
+     *
+     *  Returns: 1: correct signature
+     *           0: incorrect or unparseable signature
+     *  Args:    ctx: a secp256k1 context object, initialized for verification.
+     *  In:      sig: the signature being verified (cannot be NULL)
+     *         msg32: the 32-byte message hash being verified (cannot be NULL)
+     *        pubkey: pointer to a public key to verify with (cannot be NULL)
+     */
+    // if (!secp256k1_schnorrsig_verify(ctx, &sig, msg, &combined_pk)) {
     return(result);
 }
 

src/cc/rogue/Makefile_win

@@ -0,0 +1,222 @@
+###############################################################################
+#
+# Makefile for rogue
+#
+# Rogue: Exploring the Dungeons of Doom
+# Copyright (C) 1980-1983, 1985, 1999 Michael Toy, Ken Arnold and Glenn Wichman
+# All rights reserved.
+#       
+# See the file LICENSE.TXT for full copyright and licensing information.
+#
+###############################################################################
+        
+###############################################################################
+# Site configuration occurs beneath this comment
+# Typically ./configure (autoconf tools) configures this section
+# This section could be manually configured if autoconf/configure fails
+###############################################################################
+
+DISTNAME=rogue5.4.4
+PACKAGE_TARNAME = rogue-5.4.4
+PROGRAM=rogue
+
+O=o
+
+#CC=gcc
+CC    = x86_64-w64-mingw32-gcc
+
+#CFLAGS=-O2
+CFLAGS= -g -O2 -I./ncurses/include
+
+#LIBS=-lcurses
+LIBS = -L./ncurses/lib -lncursesw
+
+#RM=rm -f
+RM    = rm -f
+
+#GROFF=groff
+GROFF = groff
+
+#NROFF=nroff
+NROFF = nroff
+
+#TBL=tbl
+TBL   = tbl
+
+#COLCRT=colcrt
+COLCRT = colcrt
+
+#SED=sed
+SED   = sed
+
+#SCOREFILE=rogue54.scr
+SCOREFILE = rogue.scr
+
+#LOCKFILE=rogue54.lck
+LOCKFILE = rogue.lck
+
+#GROUPOWNER=games
+GROUPOWNER = 
+
+#CPPFLAGS=-DHAVE_CONFIG_H
+CPPFLAGS =-DHAVE_CONFIG_H 
+
+#DISTFILE = $(PROGRAM)
+DISTFILE = $(DISTNAME)-x86_64-w64-mingw32
+
+INSTALL=./install-sh
+
+#INSTGROUP=-g games
+INSTGROUP=
+#INSTOWNER=-u root
+INSTOWNER=
+
+CHGRP=chgrp
+
+MKDIR=mkdir
+
+TOUCH=touch
+
+RMDIR=rmdir
+
+CHMOD=chmod
+
+DESTDIR=
+
+prefix=/usr/local
+exec_prefix=${prefix}
+datarootdir=${prefix}/share
+datadir=${datarootdir}
+bindir=${exec_prefix}/bin
+mandir=${datarootdir}/man
+docdir=${datarootdir}/doc/${PACKAGE_TARNAME}
+man6dir = $(mandir)/man6
+
+###############################################################################
+# Site configuration occurs above this comment
+# It should not be necessary to change anything below this comment
+############################################################################### 
+
+HDRS     = rogue.h extern.h score.h
+OBJS1    = vers.$(O) extern.$(O) armor.$(O) chase.$(O) command.$(O) \
+           daemon.$(O) daemons.$(O) fight.$(O) init.$(O) io.$(O) list.$(O) \
+           mach_dep.$(O) rogue.$(O) mdport.$(O) misc.$(O) monsters.$(O) \
+           move.$(O) new_level.$(O) 
+OBJS2    = options.$(O) pack.$(O) passages.$(O) potions.$(O) rings.$(O) \
+           rip.$(O) rooms.$(O) save.$(O) scrolls.$(O) state.$(O) sticks.$(O) \
+           things.$(O) weapons.$(O) wizard.$(O) xcrypt.$(O)
+OBJS     = main.$(O) $(OBJS1) $(OBJS2)
+CFILES   = vers.c extern.c armor.c chase.c command.c daemon.c \
+           daemons.c fight.c init.c io.c list.c mach_dep.c \
+           main.c  mdport.c misc.c monsters.c move.c new_level.c \
+           options.c pack.c passages.c potions.c rings.c rip.c \
+           rooms.c save.c scrolls.c state.c sticks.c things.c \
+           weapons.c wizard.c xcrypt.c
+MISC_C   = findpw.c scedit.c scmisc.c
+DOCSRC   = rogue.me.in rogue.6.in rogue.doc.in rogue.html.in rogue.cat.in
+DOCS     = $(PROGRAM).doc $(PROGRAM).html $(PROGRAM).cat $(PROGRAM).me \
+           $(PROGRAM).6
+AFILES   = configure Makefile.in configure.ac config.h.in config.sub config.guess \
+           install-sh rogue.6.in rogue.me.in rogue.html.in rogue.doc.in rogue.cat.in
+MISC     = Makefile.std LICENSE.TXT rogue54.sln rogue54.vcproj rogue.spec \
+           rogue.png rogue.desktop
+
+.SUFFIXES: .obj
+
+.c.obj:
+	$(CC) $(CFLAGS) $(CPPFLAGS) /c $*.c
+    
+.c.o:
+	$(CC) $(CFLAGS) $(CPPFLAGS) -c $*.c
+
+#$(RM) rogue.so ; $(CC) -shared -o rogue.so cursesd.c $(OBJS1) $(OBJS2); $(CC) $(CFLAGS) $(LDFLAGS) $(OBJS) $(LIBS) -o $@
+
+$(PROGRAM): $(HDRS) $(OBJS)
+	$(CC) $(CFLAGS) $(LDFLAGS) $(OBJS) $(LIBS) -o $@.exe
+
+clean:
+	$(RM) $(OBJS1); $(RM) main.$(O) ; $(RM) rogue.so
+	$(RM) $(OBJS2)
+	$(RM) core a.exe a.out a.exe.stackdump $(PROGRAM) $(PROGRAM).exe
+	$(RM) $(PROGRAM).tar $(PROGRAM).tar.gz $(PROGRAM).zip 
+	$(RM) $(DISTNAME)/*
+	-rmdir $(DISTNAME)
+    
+maintainer-clean:
+	$(RM) config.h
+	$(RM) Makefile
+	$(RM) config.status
+	$(RM) -r autom4te.cache
+	$(RM) config.log
+	$(RM) $(PROGRAM).scr $(PROGRAM).lck
+
+stddocs:
+	sed -e 's/rogue/rogue/' -e 's/rogue.scr/rogue.scr/' rogue.6.in > rogue.6
+	sed -e 's/rogue/rogue/' -e 's/rogue.scr/rogue.scr/' rogue.me.in > rogue.me
+	sed -e 's/rogue/rogue/' -e 's/rogue.scr/rogue.scr/' rogue.html.in > rogue,html
+	sed -e 's/rogue/rogue/' -e 's/rogue.scr/rogue.scr/' rogue.doc.in > rogue.doc
+	sed -e 's/rogue/rogue/' -e 's/rogue.scr/rogue.scr/' rogue.cat.in > rogue.cat
+
+dist.src:
+	$(MAKE) $(MAKEFILE) clean
+	mkdir $(DISTNAME)
+	cp $(CFILES) $(HDRS) $(MISC) $(AFILES) $(DISTNAME)
+	tar cf $(DISTNAME)-src.tar $(DISTNAME)
+	gzip -f $(DISTNAME)-src.tar
+	rm -fr $(DISTNAME)
+
+findpw: findpw.c xcrypt.o mdport.o xcrypt.o
+	$(CC) -s -o findpw findpw.c xcrypt.o mdport.o -lcurses
+
+scedit: scedit.o scmisc.o vers.o mdport.o xcrypt.o
+	$(CC) -s -o scedit vers.o scedit.o scmisc.o mdport.o xcrypt.o -lcurses
+
+scmisc.o scedit.o:
+	$(CC) -O -c $(SF) $*.c
+
+$(PROGRAM).doc: rogue.me
+	if test "x$(GROFF)" != "x" -a "x$(SED)" != "x" ; then \
+	$(GROFF) -P-c -t -me -Tascii rogue.me | $(SED) -e 's/.\x08//g' > $(PROGRAM).doc ;\
+	elif test "x$(NROFF)" != "x" -a "x$(TBL)" != "x" -a "x$(COLCRT)" != "x" ; then \
+        tbl rogue.me | $(NROFF) -me | colcrt - > $(PROGRAM).doc ;\
+	fi
+
+$(PROGRAM).cat: rogue.6
+	if test "x$(GROFF)" != "x" -a "x$(SED)" != "x" ; then \
+	$(GROFF) -Tascii -man rogue.6 | $(SED) -e 's/.\x08//g' > $(PROGRAM).cat ;\
+	elif test "x$(NROFF)" != "x" -a "x$(TBL)" != "x" -a "x$(COLCRT)" != "x" ; then \
+	$(NROFF) -man rogue.6 | $(COLCRT) - > $(PROGRAM).cat ;\
+	fi
+
+dist: clean $(PROGRAM)
+	tar cf $(DISTFILE).tar $(PROGRAM) LICENSE.TXT $(DOCS)
+	gzip -f $(DISTFILE).tar
+
+install: $(PROGRAM)
+	-$(TOUCH) test
+	-if test ! -f $(DESTDIR)$(SCOREFILE) ; then $(INSTALL) -m 0664 test $(DESTDIR)$(SCOREFILE) ; fi
+	-$(INSTALL) -m 0755 $(PROGRAM) $(DESTDIR)$(bindir)/$(PROGRAM)
+	-if test "x$(GROUPOWNER)" != "x" ; then \
+	    $(CHGRP) $(GROUPOWNER) $(DESTDIR)$(SCOREFILE) ; \
+	    $(CHGRP) $(GROUPOWNER) $(DESTDIR)$(bindir)/$(PROGRAM) ; \
+	    $(CHMOD) 02755 $(DESTDIR)$(bindir)/$(PROGRAM) ; \
+	    $(CHMOD) 0464 $(DESTDIR)$(SCOREFILE) ; \
+         fi
+	-if test -d $(man6dir) ; then $(INSTALL) -m 0644 rogue.6 $(DESTDIR)$(man6dir)/$(PROGRAM).6 ; fi
+	-if test ! -d $(man6dir) ; then $(INSTALL) -m 0644 rogue.6 $(DESTDIR)$(mandir)/$(PROGRAM).6 ; fi
+	-$(INSTALL) -m 0644 rogue.doc $(DESTDIR)$(docdir)/$(PROGRAM).doc
+	-$(INSTALL) -m 0644 rogue.html $(DESTDIR)$(docdir)/$(PROGRAM).html
+	-$(INSTALL) -m 0644 rogue.cat $(DESTDIR)$(docdir)/$(PROGRAM).cat
+	-$(INSTALL) -m 0644 LICENSE.TXT $(DESTDIR)$(docdir)/LICENSE.TXT
+	-$(INSTALL) -m 0644 rogue.me $(DESTDIR)$(docdir)/$(PROGRAM).me
+	-if test ! -f $(DESTDIR)$(LOCKFILE)  ; then $(INSTALL) -m 0666 test $(DESTDIR)$(LOCKFILE)  ; $(RM) $(DESTDIR)$(LOCKFILE) ; fi
+	-$(RM) test
+
+uninstall:	
+	-$(RM) $(DESTDIR)$(bindir)/$(PROGRAM)
+	-$(RM) $(DESTDIR)$(man6dir)/$(PROGRAM).6
+	-$(RM) $(DESTDIR)$(docdir)$(PROGRAM)/$(PROGRAM).doc
+	-$(RM) $(DESTDIR)$(LOCKFILE)
+	-$(RMDIR) $(DESTDIR)$(docdir)$(PROGRAM)
+    
+reinstall: uninstall install

src/cc/rogue/cursesd.c

@@ -410,11 +410,13 @@ int32_t wgetnstr(WINDOW *win, char *str, int32_t n) // stub
     return(0);
 }
 
+#ifndef __MINGW32__
 int32_t getch(void)
 {
     fprintf(stderr,"unexpected and unsupported call to getch\n");
     return(0);
 }
+#endif
 
 int32_t md_readchar(void)
 {

src/cc/rogue/cursesd.h

@@ -48,7 +48,10 @@ extern WINDOW *stdscr,*curscr;
 extern int32_t ESCDELAY;
 typedef char chtype;
 
+#ifndef __MINGW32__
 int32_t getch(void); // stub
+#endif
+
 int32_t md_readchar(void); // stub
 
 WINDOW *initscr(void);