Merge all Komodo changes, including proof of stake, crypto conditions, passport, etc.

2018-05-02 03:24:21 -07:00
parent e329959f32 a04c095fea
commit 48d800c2c6
483 changed files with 62307 additions and 3553 deletions
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -1,4 +1,4 @@
-DIST_SUBDIRS = secp256k1 univalue
+DIST_SUBDIRS = secp256k1 univalue cryptoconditions

 AM_LDFLAGS = $(PTHREAD_CFLAGS) $(LIBTOOL_LDFLAGS) $(SAN_LDFLAGS) $(HARDENED_LDFLAGS)
 AM_CXXFLAGS = $(SAN_CXXFLAGS) $(HARDENED_CXXFLAGS) $(ERROR_CXXFLAGS)
@@ -23,6 +23,7 @@ BITCOIN_CONFIG_INCLUDES=-I$(builddir)/config
 BITCOIN_INCLUDES=-I$(builddir) -I$(builddir)/obj $(BOOST_CPPFLAGS) $(LEVELDB_CPPFLAGS) $(CRYPTO_CFLAGS) $(SSL_CFLAGS)

 BITCOIN_INCLUDES += -I$(srcdir)/secp256k1/include
+BITCOIN_INCLUDES += -I$(srcdir)/cryptoconditions/include
 BITCOIN_INCLUDES += -I$(srcdir)/snark
 BITCOIN_INCLUDES += -I$(srcdir)/snark/libsnark
 BITCOIN_INCLUDES += -I$(srcdir)/univalue/include
@@ -43,6 +44,7 @@ LIBBITCOIN_UTIL=libbitcoin_util.a
 LIBBITCOIN_CRYPTO=crypto/libbitcoin_crypto.a
 LIBVERUS_CRYPTO=crypto/libverus_crypto.a
 LIBSECP256K1=secp256k1/libsecp256k1.la
+LIBCRYPTOCONDITIONS=cryptoconditions/libcryptoconditions_core.la
 LIBSNARK=snark/libsnark.a
 LIBUNIVALUE=univalue/libunivalue.la
 LIBZCASH=libzcash.a -lcurl
@@ -65,6 +67,9 @@ libsnark-tests: $(wildcard snark/src/*)
 $(LIBUNIVALUE): $(wildcard univalue/lib/*)
 	$(AM_V_at)$(MAKE) $(AM_MAKEFLAGS) -C univalue/

+$(LIBCRYPTOCONDITIONS): $(wildcard cryptoconditions/src/*) $(wildcard cryptoconditions/include/*)
+	$(AM_V_at)$(MAKE) $(AM_MAKEFLAGS) -C $(@D) $(@F)
+
 # Make is not made aware of per-object dependencies to avoid limiting building parallelization
 # But to build the less dependent modules first, we manually select their order here:
 EXTRA_LIBRARIES = \
@@ -97,13 +102,17 @@ bin_PROGRAMS =
 noinst_PROGRAMS =
 TESTS =

-if BUILD_BITCOIND
+#if BUILD_BITCOIND
  bin_PROGRAMS += komodod
-endif
+#endif

 if BUILD_BITCOIN_UTILS
  bin_PROGRAMS += komodo-cli komodo-tx
 endif
+if ENABLE_WALLET
+  bin_PROGRAMS += wallet-utility
+endif
+

 LIBZCASH_H = \
  zcash/IncrementalMerkleTree.hpp \
@@ -119,6 +128,8 @@ LIBZCASH_H = \
 .PHONY: FORCE collate-libsnark check-symbols check-security
 # bitcoin core #
 BITCOIN_CORE_H = \
+  addressindex.h \
+  spentindex.h \
  addrman.h \
  alert.h \
  amount.h \
@@ -132,6 +143,7 @@ BITCOIN_CORE_H = \
  asyncrpcqueue.h \
  base58.h \
  bloom.h \
+  cc/eval.h \
  chain.h \
  chainparams.h \
  chainparamsbase.h \
@@ -188,7 +200,7 @@ BITCOIN_CORE_H = \
  script/interpreter.h \
  script/script.h \
  script/script_error.h \
-  script/sigcache.h \
+  script/serverchecker.h \
  script/sign.h \
  script/standard.h \
  serialize.h \
@@ -232,7 +244,7 @@ BITCOIN_CORE_H = \
 obj/build.h: FORCE
 	@$(MKDIR_P) $(builddir)/obj
 	@$(top_srcdir)/share/genbuild.sh $(abs_top_builddir)/src/obj/build.h \
-	  $(abs_top_srcdir)
+	$(abs_top_srcdir)
 libbitcoin_util_a-clientversion.$(OBJEXT): obj/build.h

 # server: zcashd
@@ -246,6 +258,10 @@ libbitcoin_server_a_SOURCES = \
  asyncrpcoperation.cpp \
  asyncrpcqueue.cpp \
  bloom.cpp \
+  cc/eval.cpp \
+  cc/importpayout.cpp \
+  cc/disputepayout.cpp \
+  cc/betprotocol.cpp \
  chain.cpp \
  checkpoints.cpp \
  deprecation.cpp \
@@ -270,7 +286,7 @@ libbitcoin_server_a_SOURCES = \
  rpcnet.cpp \
  rpcrawtransaction.cpp \
  rpcserver.cpp \
-  script/sigcache.cpp \
+  script/serverchecker.cpp \
  timedata.cpp \
  torcontrol.cpp \
  txdb.cpp \
@@ -285,9 +301,9 @@ LIBBITCOIN_ZMQ=libbitcoin_zmq.a
 libbitcoin_zmq_a_CPPFLAGS = $(BITCOIN_INCLUDES) $(ZMQ_CFLAGS)
 libbitcoin_zmq_a_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
 libbitcoin_zmq_a_SOURCES = \
-  zmq/zmqabstractnotifier.cpp \
-  zmq/zmqnotificationinterface.cpp \
-  zmq/zmqpublishnotifier.cpp
+	zmq/zmqabstractnotifier.cpp \
+	zmq/zmqnotificationinterface.cpp \
+	zmq/zmqpublishnotifier.cpp
 endif

 if ENABLE_PROTON
@@ -350,14 +366,14 @@ crypto_libbitcoin_crypto_a_SOURCES = \

 if ENABLE_MINING
 EQUIHASH_TROMP_SOURCES = \
-  pow/tromp/equi_miner.h \
-  pow/tromp/equi.h \
-  pow/tromp/osx_barrier.h
+	pow/tromp/equi_miner.h \
+	pow/tromp/equi.h \
+	pow/tromp/osx_barrier.h

 crypto_libbitcoin_crypto_a_CPPFLAGS += \
-  -DEQUIHASH_TROMP_ATOMIC
+	-DEQUIHASH_TROMP_ATOMIC
 crypto_libbitcoin_crypto_a_SOURCES += \
-  ${EQUIHASH_TROMP_SOURCES}
+	${EQUIHASH_TROMP_SOURCES}
 endif

 # Verus hash specific library
@@ -389,6 +405,7 @@ libbitcoin_common_a_SOURCES = \
  protocol.cpp \
  pubkey.cpp \
  scheduler.cpp \
+  script/cc.cpp \
  script/interpreter.cpp \
  script/script.cpp \
  script/script_ext.cpp \
@@ -404,23 +421,23 @@ libbitcoin_common_a_SOURCES = \
 libbitcoin_util_a_CPPFLAGS = $(AM_CPPFLAGS) $(BITCOIN_INCLUDES)
 libbitcoin_util_a_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
 libbitcoin_util_a_SOURCES = \
-  support/pagelocker.cpp \
-  chainparamsbase.cpp \
-  clientversion.cpp \
-  compat/glibc_sanity.cpp \
-  compat/glibcxx_sanity.cpp \
-  compat/strnlen.cpp \
-  random.cpp \
-  rpcprotocol.cpp \
-  support/cleanse.cpp \
-  sync.cpp \
-  uint256.cpp \
-  util.cpp \
-  utilmoneystr.cpp \
-  utilstrencodings.cpp \
-  utiltime.cpp \
-  $(BITCOIN_CORE_H) \
-  $(LIBZCASH_H)
+	support/pagelocker.cpp \
+	chainparamsbase.cpp \
+	clientversion.cpp \
+	compat/glibc_sanity.cpp \
+	compat/glibcxx_sanity.cpp \
+	compat/strnlen.cpp \
+	random.cpp \
+	rpcprotocol.cpp \
+	support/cleanse.cpp \
+	sync.cpp \
+	uint256.cpp \
+	util.cpp \
+	utilmoneystr.cpp \
+	utilstrencodings.cpp \
+	utiltime.cpp \
+	$(BITCOIN_CORE_H) \
+	$(LIBZCASH_H)

 if GLIBC_BACK_COMPAT
 libbitcoin_util_a_SOURCES += compat/glibc_compat.cpp
@@ -430,9 +447,9 @@ endif
 libbitcoin_cli_a_CPPFLAGS = $(AM_CPPFLAGS) $(BITCOIN_INCLUDES)
 libbitcoin_cli_a_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
 libbitcoin_cli_a_SOURCES = \
-  rpcclient.cpp \
-  $(BITCOIN_CORE_H) \
-  $(LIBZCASH_H)
+	rpcclient.cpp \
+	$(BITCOIN_CORE_H) \
+	$(LIBZCASH_H)

 nodist_libbitcoin_util_a_SOURCES = $(srcdir)/obj/build.h
 #
@@ -458,7 +475,8 @@ komodod_LDADD = \
  $(LIBSNARK) \
  $(LIBLEVELDB) \
  $(LIBMEMENV) \
-  $(LIBSECP256K1)
+  $(LIBSECP256K1) \
+  $(LIBCRYPTOCONDITIONS)

 if ENABLE_ZMQ
 komodod_LDADD += $(LIBBITCOIN_ZMQ) $(ZMQ_LIBS)
@@ -489,23 +507,46 @@ komodo_cli_CPPFLAGS = $(AM_CPPFLAGS) $(BITCOIN_INCLUDES) $(EVENT_CFLAGS)
 komodo_cli_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
 komodo_cli_LDFLAGS = $(RELDFLAGS) $(AM_LDFLAGS) $(LIBTOOL_APP_LDFLAGS)

+# wallet-utility binary #
+if ENABLE_WALLET
+wallet_utility_SOURCES = wallet-utility.cpp
+wallet_utility_CPPFLAGS = $(AM_CPPFLAGS) $(BITCOIN_INCLUDES)
+wallet_utility_CXXFLAGS = $(AM_CXXFLAGS) $(PIE_FLAGS)
+wallet_utility_LDFLAGS = $(RELDFLAGS) $(AM_LDFLAGS) $(LIBTOOL_APP_LDFLAGS)
+endif
+
 if TARGET_WINDOWS
 komodo_cli_SOURCES += bitcoin-cli-res.rc
 endif

 komodo_cli_LDADD = \
-  $(LIBBITCOIN_CLI) \
-  $(LIBUNIVALUE) \
-  $(LIBBITCOIN_UTIL) \
-  $(BOOST_LIBS) \
-  $(SSL_LIBS) \
-  $(CRYPTO_LIBS) \
-  $(EVENT_LIBS) \
-  $(LIBZCASH) \
-  $(LIBSNARK) \
-  $(LIBBITCOIN_CRYPTO) \
-  $(LIBZCASH_LIBS)
-#
+	$(LIBBITCOIN_CLI) \
+	$(LIBUNIVALUE) \
+	$(LIBBITCOIN_UTIL) \
+	$(BOOST_LIBS) \
+	$(SSL_LIBS) \
+	$(CRYPTO_LIBS) \
+	$(EVENT_LIBS) \
+	$(LIBZCASH) \
+	$(LIBBITCOIN_CRYPTO) \
+	$(LIBZCASH_LIBS)
+
+if ENABLE_WALLET
+wallet_utility_LDADD = \
+	libbitcoin_wallet.a \
+	$(LIBBITCOIN_COMMON) \
+	$(LIBBITCOIN_CRYPTO) \
+  $(LIBVERUS_CRYPTO) \
+	$(LIBSECP256K1) \
+	$(LIBBITCOIN_UTIL) \
+	$(BOOST_LIBS) \
+	$(BDB_LIBS) \
+	$(CRYPTO_LIBS) \
+	$(LIBZCASH) \
+	$(LIBSNARK) \
+	$(LIBZCASH_LIBS)\
+  $(LIBCRYPTOCONDITIONS)
+endif

 # zcash-tx binary #
 komodo_tx_SOURCES = komodo-tx.cpp
@@ -527,27 +568,28 @@ komodo_tx_LDADD = \
  $(LIBSNARK) \
  $(LIBBITCOIN_CRYPTO) \
  $(LIBVERUS_CRYPTO) \
-  $(LIBZCASH_LIBS)
+  $(LIBZCASH_LIBS) \
+  $(LIBCRYPTOCONDITIONS)

 komodo_tx_LDADD += $(BOOST_LIBS) $(CRYPTO_LIBS)
 #

 # zcash protocol primitives #
 libzcash_a_SOURCES = \
-  zcash/IncrementalMerkleTree.cpp \
-  zcash/NoteEncryption.cpp \
-  zcash/Address.cpp \
-  zcash/JoinSplit.cpp \
-  zcash/Proof.cpp \
-  zcash/Note.cpp \
-  zcash/prf.cpp \
-  zcash/util.cpp \
-  zcash/circuit/commitment.tcc \
-  zcash/circuit/gadget.tcc \
-  zcash/circuit/merkle.tcc \
-  zcash/circuit/note.tcc \
-  zcash/circuit/prfs.tcc \
-  zcash/circuit/utils.tcc
+	zcash/IncrementalMerkleTree.cpp \
+	zcash/NoteEncryption.cpp \
+	zcash/Address.cpp \
+	zcash/JoinSplit.cpp \
+	zcash/Proof.cpp \
+	zcash/Note.cpp \
+	zcash/prf.cpp \
+	zcash/util.cpp \
+	zcash/circuit/commitment.tcc \
+	zcash/circuit/gadget.tcc \
+	zcash/circuit/merkle.tcc \
+	zcash/circuit/note.tcc \
+	zcash/circuit/prfs.tcc \
+	zcash/circuit/utils.tcc

 libzcash_a_CPPFLAGS = -DMULTICORE -fopenmp -fPIC -DBINARY_OUTPUT -DCURVE_ALT_BN128 -DBOOST_SPIRIT_THREADSAFE -DHAVE_BUILD_INFO -D__STDC_FORMAT_MACROS $(HARDENED_CPPFLAGS) $(HARDENED_CXXFLAGS) $(HARDENED_LDFLAGS) -pipe $(SAN_LDFLAGS) -O1 -g -Wstack-protector $(SAN_CXXFLAGS) -fstack-protector-all -fPIE -fvisibility=hidden -DSTATIC $(BITCOIN_INCLUDES)

@@ -575,7 +617,7 @@ libzcashconsensus_la_SOURCES = \
  utilstrencodings.cpp

 if GLIBC_BACK_COMPAT
-  libzcashconsensus_la_SOURCES += compat/glibc_compat.cpp
+libzcashconsensus_la_SOURCES += compat/glibc_compat.cpp
 endif

 libzcashconsensus_la_LDFLAGS = $(AM_LDFLAGS) -no-undefined $(RELDFLAGS)
@@ -623,9 +665,10 @@ endif
 	@test -f $(PROTOC)
 	$(AM_V_GEN) $(PROTOC) --cpp_out=$(@D) --proto_path=$(abspath $(<D) $<)

-#if ENABLE_TESTS
+if ENABLE_TESTS
+include Makefile.ktest.include
 #include Makefile.test.include
 #include Makefile.gtest.include
-#endif
+endif

 include Makefile.zcash.include
--- a/src/Makefile.ktest.include
+++ b/src/Makefile.ktest.include
@@ -0,0 +1,16 @@
+
+TESTS += komodo-test
+bin_PROGRAMS += komodo-test
+
+# tool for generating our public parameters
+komodo_test_SOURCES = \
+	test-komodo/main.cpp \
+	test-komodo/test_cryptoconditions.cpp \
+	test-komodo/test_eval_bet.cpp \
+	test-komodo/test_eval_notarisation.cpp
+
+komodo_test_CPPFLAGS = $(komodod_CPPFLAGS)
+
+komodo_test_LDADD = -lgtest $(komodod_LDADD)
+
+komodo_test_LDFLAGS = $(RELDFLAGS) $(AM_LDFLAGS) $(LIBTOOL_APP_LDFLAGS) -static
--- a/src/Makefile.test.include
+++ b/src/Makefile.test.include
@@ -15,87 +15,90 @@ EXTRA_DIST += \
 	test/data/tx394b54bb.hex \
 	test/data/txcreate1.hex \
 	test/data/txcreate2.hex \
-	test/data/txcreatesign.hex
+	test/data/txcreatesign.hex \
+	test/wallet-utility.py \
+	test/data/wallet.dat

 JSON_TEST_FILES = \
-  test/data/script_valid.json \
-  test/data/base58_keys_valid.json \
-  test/data/base58_encode_decode.json \
-  test/data/base58_keys_invalid.json \
-  test/data/script_invalid.json \
-  test/data/tx_invalid.json \
-  test/data/tx_valid.json \
-  test/data/sighash.json \
-  test/data/merkle_roots.json \
-  test/data/merkle_roots_empty.json \
-  test/data/merkle_serialization.json \
-  test/data/merkle_witness_serialization.json \
-  test/data/merkle_path.json \
-  test/data/merkle_commitments.json \
-  test/data/g1_compressed.json \
-  test/data/g2_compressed.json
+	test/data/script_valid.json \
+	test/data/base58_keys_valid.json \
+	test/data/base58_encode_decode.json \
+	test/data/base58_keys_invalid.json \
+	test/data/script_invalid.json \
+	test/data/tx_invalid.json \
+	test/data/tx_valid.json \
+	test/data/sighash.json \
+	test/data/merkle_roots.json \
+	test/data/merkle_roots_empty.json \
+	test/data/merkle_serialization.json \
+	test/data/merkle_witness_serialization.json \
+	test/data/merkle_path.json \
+	test/data/merkle_commitments.json \
+	test/data/g1_compressed.json \
+	test/data/g2_compressed.json

 RAW_TEST_FILES = test/data/alertTests.raw

 GENERATED_TEST_FILES = $(JSON_TEST_FILES:.json=.json.h) $(RAW_TEST_FILES:.raw=.raw.h)

 BITCOIN_TESTS =\
-  test/arith_uint256_tests.cpp \
-  test/bignum.h \
-  test/addrman_tests.cpp \
-  test/alert_tests.cpp \
-  test/allocator_tests.cpp \
-  test/base32_tests.cpp \
-  test/base58_tests.cpp \
-  test/base64_tests.cpp \
-  test/bip32_tests.cpp \
-  test/bloom_tests.cpp \
-  test/checkblock_tests.cpp \
-  test/Checkpoints_tests.cpp \
-  test/coins_tests.cpp \
-  test/compress_tests.cpp \
-  test/crypto_tests.cpp \
-  test/DoS_tests.cpp \
-  test/equihash_tests.cpp \
-  test/getarg_tests.cpp \
-  test/hash_tests.cpp \
-  test/key_tests.cpp \
-  test/main_tests.cpp \
-  test/mempool_tests.cpp \
-  test/miner_tests.cpp \
-  test/mruset_tests.cpp \
-  test/multisig_tests.cpp \
-  test/netbase_tests.cpp \
-  test/pmt_tests.cpp \
-  test/policyestimator_tests.cpp \
-  test/pow_tests.cpp \
-  test/raii_event_tests.cpp \
-  test/reverselock_tests.cpp \
-  test/rpc_tests.cpp \
-  test/sanity_tests.cpp \
-  test/scheduler_tests.cpp \
-  test/script_P2SH_tests.cpp \
-  test/script_tests.cpp \
-  test/scriptnum_tests.cpp \
-  test/serialize_tests.cpp \
-  test/sighash_tests.cpp \
-  test/sigopcount_tests.cpp \
-  test/skiplist_tests.cpp \
-  test/test_bitcoin.cpp \
-  test/test_bitcoin.h \
-  test/timedata_tests.cpp \
-  test/torcontrol_tests.cpp \
-  test/transaction_tests.cpp \
-  test/uint256_tests.cpp \
-  test/univalue_tests.cpp \
-  test/util_tests.cpp \
-  test/sha256compress_tests.cpp
+	test/arith_uint256_tests.cpp \
+	test/bignum.h \
+	test/addrman_tests.cpp \
+	test/alert_tests.cpp \
+	test/allocator_tests.cpp \
+	test/base32_tests.cpp \
+	test/base58_tests.cpp \
+	test/base64_tests.cpp \
+	test/bip32_tests.cpp \
+	test/bloom_tests.cpp \
+	test/checkblock_tests.cpp \
+	test/Checkpoints_tests.cpp \
+	test/coins_tests.cpp \
+	test/compress_tests.cpp \
+	test/crypto_tests.cpp \
+	test/DoS_tests.cpp \
+	test/equihash_tests.cpp \
+	test/getarg_tests.cpp \
+	test/hash_tests.cpp \
+	test/key_tests.cpp \
+	test/main_tests.cpp \
+	test/mempool_tests.cpp \
+	test/miner_tests.cpp \
+	test/mruset_tests.cpp \
+	test/multisig_tests.cpp \
+	test/netbase_tests.cpp \
+	test/pmt_tests.cpp \
+	test/policyestimator_tests.cpp \
+	test/pow_tests.cpp \
+	test/raii_event_tests.cpp \
+	test/reverselock_tests.cpp \
+	test/rpc_tests.cpp \
+	test/sanity_tests.cpp \
+	test/scheduler_tests.cpp \
+	test/script_P2SH_tests.cpp \
+	test/script_P2PKH_tests.cpp \
+	test/script_tests.cpp \
+	test/scriptnum_tests.cpp \
+	test/serialize_tests.cpp \
+	test/sighash_tests.cpp \
+	test/sigopcount_tests.cpp \
+	test/skiplist_tests.cpp \
+	test/test_bitcoin.cpp \
+	test/test_bitcoin.h \
+	test/timedata_tests.cpp \
+	test/torcontrol_tests.cpp \
+	test/transaction_tests.cpp \
+	test/uint256_tests.cpp \
+	test/univalue_tests.cpp \
+	test/util_tests.cpp \
+	test/sha256compress_tests.cpp

 if ENABLE_WALLET
 BITCOIN_TESTS += \
-  test/accounting_tests.cpp \
-  wallet/test/wallet_tests.cpp \
-  test/rpc_wallet_tests.cpp
+	test/accounting_tests.cpp \
+	wallet/test/wallet_tests.cpp \
+	test/rpc_wallet_tests.cpp
 endif

 test_test_bitcoin_SOURCES = $(BITCOIN_TESTS) $(JSON_TEST_FILES) $(RAW_TEST_FILES)
@@ -137,6 +140,10 @@ bitcoin_test_clean : FORCE
 check-local:
 	@echo "Running test/bitcoin-util-test.py..."
 	$(AM_V_at)srcdir=$(srcdir) PYTHONPATH=$(builddir)/test $(srcdir)/test/bitcoin-util-test.py
+if ENABLE_WALLET
+	@echo "Running test/wallet-utility.py..."
+	$(AM_V_at)srcdir=$(srcdir) PYTHONPATH=$(builddir)/test $(srcdir)/test/wallet-utility.py
+endif
 	$(AM_V_at)$(MAKE) $(AM_MAKEFLAGS) -C secp256k1 check
 	$(AM_V_at)$(MAKE) $(AM_MAKEFLAGS) -C univalue check

--- a/src/Makefile.zcash.include
+++ b/src/Makefile.zcash.include
@@ -26,4 +26,7 @@ zcash_CreateJoinSplit_LDADD = \
  $(LIBBITCOIN_CRYPTO) \
  $(LIBVERUS_CRYPTO) \
  $(BOOST_LIBS) \
-  $(LIBZCASH_LIBS)
+  $(LIBZCASH_LIBS) \
+  $(LIBCRYPTOCONDITIONS) \
+  $(LIBSECP256K1)
+
--- a/src/ac/axo
+++ b/src/ac/axo
@@ -0,0 +1,2 @@
+#!/bin/bash
+./komodo-cli -ac_name=AXO $1 $2 $3 $4 $5 $6
--- a/src/ac/beer
+++ b/src/ac/beer
@@ -0,0 +1,2 @@
+#!/bin/bash
+./komodo-cli -ac_name=BEER $1 $2 $3 $4 $5 $6
--- a/src/ac/bet
+++ b/src/ac/bet
@@ -0,0 +1,2 @@
+#!/bin/bash
+./komodo-cli -ac_name=BET $1 $2 $3 $4 $5 $6
--- a/src/ac/bntn
+++ b/src/ac/bntn
@@ -0,0 +1,2 @@
+#!/bin/bash
+./komodo-cli -ac_name=BNTN $1 $2 $3 $4 $5 $6
--- a/src/ac/bots
+++ b/src/ac/bots
@@ -0,0 +1,2 @@
+#!/bin/bash
+./komodo-cli -ac_name=BOTS $1 $2 $3 $4 $5 $6
--- a/src/ac/btch
+++ b/src/ac/btch
@@ -0,0 +1,2 @@
+#!/bin/bash
+./komodo-cli -ac_name=BTCH $1 $2 $3 $4 $5 $6
--- a/src/ac/ceal
+++ b/src/ac/ceal
@@ -0,0 +1,2 @@
+#!/bin/bash
+./komodo-cli -ac_name=CEAL $1 $2 $3 $4 $5 $6
--- a/src/ac/chain
+++ b/src/ac/chain
@@ -0,0 +1,2 @@
+#!/bin/bash
+./komodo-cli -ac_name=CHAIN $1 $2 $3 $4 $5 $6
--- a/src/ac/coqui
+++ b/src/ac/coqui
@@ -0,0 +1,2 @@
+#!/bin/bash
+./komodo-cli -ac_name=COQUI $1 $2 $3 $4 $5 $6
--- a/src/ac/crypto
+++ b/src/ac/crypto
@@ -0,0 +1,2 @@
+#!/bin/bash
+./komodo-cli -ac_name=CRYPTO $1 $2 $3 $4 $5 $6
--- a/src/ac/dex
+++ b/src/ac/dex
@@ -0,0 +1,2 @@
+#!/bin/bash
+./komodo-cli -ac_name=DEX $1 $2 $3 $4 $5 $6
--- a/src/ac/etomic
+++ b/src/ac/etomic
@@ -0,0 +1,2 @@
+#!/bin/bash
+./komodo-cli -ac_name=ETOMIC $1 $2 $3 $4 $5 $6
--- a/src/ac/hodl
+++ b/src/ac/hodl
@@ -0,0 +1,2 @@
+#!/bin/bash
+./komodo-cli -ac_name=HODL $1 $2 $3 $4 $5 $6
--- a/src/ac/jumblr
+++ b/src/ac/jumblr
@@ -0,0 +1,2 @@
+#!/bin/bash
+./komodo-cli -ac_name=JUMBLR $1 $2 $3 $4 $5 $6
--- a/src/ac/kv
+++ b/src/ac/kv
@@ -0,0 +1,2 @@
+#!/bin/bash
+./komodo-cli -ac_name=KV $1 $2 $3 $4 $5 $6
--- a/src/ac/mesh
+++ b/src/ac/mesh
@@ -0,0 +1,2 @@
+#!/bin/bash
+./komodo-cli -ac_name=MESH $1 $2 $3 $4 $5 $6
--- a/src/ac/mgw
+++ b/src/ac/mgw
@@ -0,0 +1,2 @@
+#!/bin/bash
+./komodo-cli -ac_name=MGW $1 $2 $3 $4 $5 $6
--- a/src/ac/mnz
+++ b/src/ac/mnz
@@ -0,0 +1,2 @@
+#!/bin/bash
+./komodo-cli -ac_name=MNZ $1 $2 $3 $4 $5 $6
--- a/src/ac/mshark
+++ b/src/ac/mshark
@@ -0,0 +1,2 @@
+#!/bin/bash
+./komodo-cli -ac_name=MSHARK $1 $2 $3 $4 $5 $6
--- a/src/ac/ninja
+++ b/src/ac/ninja
@@ -0,0 +1,2 @@
+#!/bin/bash
+./komodo-cli -ac_name=NINJA $1 $2 $3 $4 $5 $6
--- a/src/ac/oot
+++ b/src/ac/oot
@@ -0,0 +1,2 @@
+#!/bin/bash
+./komodo-cli -ac_name=OOT $1 $2 $3 $4 $5 $6
--- a/src/ac/pangea
+++ b/src/ac/pangea
@@ -0,0 +1,2 @@
+#!/bin/bash
+./komodo-cli -ac_name=PANGEA $1 $2 $3 $4 $5 $6
--- a/src/ac/pizza
+++ b/src/ac/pizza
@@ -0,0 +1,2 @@
+#!/bin/bash
+./komodo-cli -ac_name=PIZZA $1 $2 $3 $4 $5 $6
--- a/src/ac/prlpay
+++ b/src/ac/prlpay
@@ -0,0 +1,2 @@
+#!/bin/bash
+./komodo-cli -ac_name=PRLPAY $1 $2 $3 $4 $5 $6
--- a/src/ac/revs
+++ b/src/ac/revs
@@ -0,0 +1,2 @@
+#!/bin/bash
+./komodo-cli -ac_name=REVS $1 $2 $3 $4 $5 $6
--- a/src/ac/supernet
+++ b/src/ac/supernet
@@ -0,0 +1,2 @@
+#!/bin/bash
+./komodo-cli -ac_name=SUPERNET $1 $2 $3 $4 $5 $6
--- a/src/ac/vote2018
+++ b/src/ac/vote2018
@@ -0,0 +1,2 @@
+#!/bin/bash
+./komodo-cli -ac_name=VOTE2018 $1 $2 $3 $4 $5 $6
--- a/src/ac/wlc
+++ b/src/ac/wlc
@@ -0,0 +1,2 @@
+#!/bin/bash
+./komodo-cli -ac_name=WLC $1 $2 $3 $4 $5 $6
--- a/src/addressindex.h
+++ b/src/addressindex.h
@@ -0,0 +1,82 @@
+// Copyright (c) 2009-2010 Satoshi Nakamoto
+// Copyright (c) 2009-2015 The Bitcoin Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_ADDRESSINDEX_H
+#define BITCOIN_ADDRESSINDEX_H
+
+#include "uint256.h"
+#include "amount.h"
+
+struct CMempoolAddressDelta
+{
+    int64_t time;
+    CAmount amount;
+    uint256 prevhash;
+    unsigned int prevout;
+
+    CMempoolAddressDelta(int64_t t, CAmount a, uint256 hash, unsigned int out) {
+        time = t;
+        amount = a;
+        prevhash = hash;
+        prevout = out;
+    }
+
+    CMempoolAddressDelta(int64_t t, CAmount a) {
+        time = t;
+        amount = a;
+        prevhash.SetNull();
+        prevout = 0;
+    }
+};
+
+struct CMempoolAddressDeltaKey
+{
+    int type;
+    uint160 addressBytes;
+    uint256 txhash;
+    unsigned int index;
+    int spending;
+
+    CMempoolAddressDeltaKey(int addressType, uint160 addressHash, uint256 hash, unsigned int i, int s) {
+        type = addressType;
+        addressBytes = addressHash;
+        txhash = hash;
+        index = i;
+        spending = s;
+    }
+
+    CMempoolAddressDeltaKey(int addressType, uint160 addressHash) {
+        type = addressType;
+        addressBytes = addressHash;
+        txhash.SetNull();
+        index = 0;
+        spending = 0;
+    }
+};
+
+struct CMempoolAddressDeltaKeyCompare
+{
+    bool operator()(const CMempoolAddressDeltaKey& a, const CMempoolAddressDeltaKey& b) const {
+        if (a.type == b.type) {
+            if (a.addressBytes == b.addressBytes) {
+                if (a.txhash == b.txhash) {
+                    if (a.index == b.index) {
+                        return a.spending < b.spending;
+                    } else {
+                        return a.index < b.index;
+                    }
+                } else {
+                    return a.txhash < b.txhash;
+                }
+            } else {
+                return a.addressBytes < b.addressBytes;
+            }
+        } else {
+            return a.type < b.type;
+        }
+    }
+};
+
+#endif // BITCOIN_ADDRESSINDEX_H
--- a/src/arith_uint256.cpp
+++ b/src/arith_uint256.cpp
@@ -111,7 +111,7 @@ int base_uint<BITS>::CompareTo(const base_uint<BITS>& b) const
 {
    if ( (uint64_t)pn < 0x1000 || (uint64_t)b.pn <= 0x1000 )
    {
-        fprintf(stderr,"CompareTo null %p or %p\n",pn,b.pn);
+        //fprintf(stderr,"CompareTo null %p or %p\n",pn,b.pn);
        return(0);
    }
    for (int i = WIDTH - 1; i >= 0; i--) {
--- a/src/assetchains
+++ b/src/assetchains
@@ -53,3 +53,5 @@ komodo_asset BEER 100000000
 komodo_asset NINJA 100000000
 komodo_asset OOT 216000000
 komodo_asset BNTN 500000000
+komodo_asset CHAIN 999999
+komodo_asset PRLPAY 500000000
--- a/src/assetchains.old
+++ b/src/assetchains.old
@@ -30,6 +30,8 @@ echo $pubkey
 ./komodod -pubkey=$pubkey -ac_name=NINJA -ac_supply=100000000 -addnode=78.47.196.146 &
 ./komodod -pubkey=$pubkey -ac_name=OOT -ac_supply=216000000 -addnode=174.138.107.226 &
 ./komodod -pubkey=$pubkey -ac_name=BNTN -ac_supply=500000000 -addnode=94.130.169.205 &
+./komodod -pubkey=$pubkey -ac_name=CHAIN -ac_supply=999999 -addnode=78.47.146.222 &
+./komodod -pubkey=$pubkey -ac_name=PRLPAY -ac_supply=500000000 -addnode=13.250.226.125 &
 #sleep $delay

 #./komodod -pubkey=$pubkey -ac_name=USD -addnode=78.47.196.146 $1  &
--- a/src/assetchains_stop
+++ b/src/assetchains_stop
@@ -0,0 +1,40 @@
+#!/bin/bash
+args=("$@")
+komodo_cli='./komodo-cli'
+delay=20
+
+function komodo_stop ()
+{
+    $komodo_cli --ac_name=$1 stop
+}
+
+#set -x
+
+komodo_stop REVS
+komodo_stop SUPERNET
+komodo_stop DEX
+komodo_stop PANGEA
+komodo_stop JUMBLR
+komodo_stop BET
+komodo_stop CRYPTO
+komodo_stop HODL
+komodo_stop MSHARK
+komodo_stop BOTS
+komodo_stop MGW
+komodo_stop COQUI
+komodo_stop WLC
+komodo_stop KV
+komodo_stop CEAL
+komodo_stop MESH
+komodo_stop MNZ
+komodo_stop AXO
+komodo_stop ETOMIC
+komodo_stop BTCH
+komodo_stop VOTE2018
+komodo_stop PIZZA
+komodo_stop BEER
+komodo_stop NINJA
+komodo_stop OOT
+komodo_stop BNTN
+komodo_stop CHAIN
+komodo_stop PRLPAY
--- a/src/base58.cpp
+++ b/src/base58.cpp
@@ -275,6 +275,23 @@ CTxDestination CBitcoinAddress::Get() const
        return CNoDestination();
 }

+bool CBitcoinAddress::GetIndexKey(uint160& hashBytes, int& type) const
+{
+    if (!IsValid()) {
+        return false;
+    } else if (vchVersion == Params().Base58Prefix(CChainParams::PUBKEY_ADDRESS)) {
+        memcpy(&hashBytes, &vchData[0], 20);
+        type = 1;
+        return true;
+    } else if (vchVersion == Params().Base58Prefix(CChainParams::SCRIPT_ADDRESS)) {
+        memcpy(&hashBytes, &vchData[0], 20);
+        type = 2;
+        return true;
+    }
+
+    return false;
+}
+
 bool CBitcoinAddress::GetKeyID(CKeyID& keyID) const
 {
    if (!IsValid() || vchVersion != Params().Base58Prefix(CChainParams::PUBKEY_ADDRESS))
--- a/src/base58.h
+++ b/src/base58.h
@@ -163,6 +163,7 @@ public:

    CTxDestination Get() const;
    bool GetKeyID(CKeyID &keyID) const;
+    bool GetIndexKey(uint160& hashBytes, int& type) const;
    bool IsScript() const;
 };

--- a/src/bitcoin-cli.cpp
+++ b/src/bitcoin-cli.cpp
@@ -202,7 +202,7 @@ UniValue CallRPC(const string& strMethod, const UniValue& params)
 {
    std::string host = GetArg("-rpcconnect", "127.0.0.1");
    int port = GetArg("-rpcport", BaseParams().RPCPort());
-    BITCOIND_PORT = port;
+    BITCOIND_RPCPORT = port;
    // Obtain event base
    raii_event_base base = obtain_event_base();

--- a/src/bitcoind.cpp
+++ b/src/bitcoind.cpp
@@ -45,6 +45,8 @@ static bool fDaemon;
 #define KOMODO_ASSETCHAIN_MAXLEN 65
 extern char ASSETCHAINS_SYMBOL[KOMODO_ASSETCHAIN_MAXLEN];
 void komodo_passport_iteration();
+uint64_t komodo_interestsum();
+int32_t komodo_longestchain();

 void WaitForShutdown(boost::thread_group* threadGroup)
 {
@@ -56,8 +58,14 @@ void WaitForShutdown(boost::thread_group* threadGroup)
        if ( ASSETCHAINS_SYMBOL[0] == 0 )
        {
            komodo_passport_iteration();
-            MilliSleep(1000);
-        } else MilliSleep(1000);
+            MilliSleep(10000);
+        }
+        else
+        {
+            komodo_interestsum();
+            komodo_longestchain();
+            MilliSleep(20000);
+        }
        fShutdown = ShutdownRequested();
    }
    if (threadGroup)
@@ -125,7 +133,7 @@ bool AppInit(int argc, char* argv[])
            sleep(1);
            #endif
        }
-        printf("initialized %s\n",ASSETCHAINS_SYMBOL);
+        printf("initialized %s at %u\n",ASSETCHAINS_SYMBOL,(uint32_t)time(NULL));
        if (!boost::filesystem::is_directory(GetDataDir(false)))
        {
            fprintf(stderr, "Error: Specified data directory \"%s\" does not exist.\n", mapArgs["-datadir"].c_str());
--- a/src/cJSON.h
+++ b/src/cJSON.h
@@ -20,14 +20,6 @@
  THE SOFTWARE.
 */

-#include <stdio.h>
-#include <stdlib.h>
-#include <stdint.h>
-#include <math.h>
-#include <ctype.h>
-#include <float.h>
-#include <memory.h>
-
 #ifndef cJSON__h
 #define cJSON__h

--- a/src/cc/betprotocol.cpp
+++ b/src/cc/betprotocol.cpp
@@ -0,0 +1,139 @@
+#include <cryptoconditions.h>
+
+#include "streams.h"
+#include "script/cc.h"
+#include "cc/eval.h"
+#include "cc/betprotocol.h"
+#include "primitives/transaction.h"
+
+
+std::vector<CC*> BetProtocol::PlayerConditions()
+{
+    std::vector<CC*> subs;
+    for (int i=0; i<players.size(); i++)
+        subs.push_back(CCNewSecp256k1(players[i]));
+    return subs;
+}
+
+
+CC* BetProtocol::MakeDisputeCond()
+{
+    CC *disputePoker = CCNewEval(E_MARSHAL(
+        ss << disputeCode << VARINT(waitBlocks) << vmParams;
+    ));
+
+    CC *anySig = CCNewThreshold(1, PlayerConditions());
+
+    return CCNewThreshold(2, {disputePoker, anySig});
+}
+
+
+/*
+ * spendFee is the amount assigned to each output, for the purposes of posting
+ * dispute / evidence.
+ */
+CMutableTransaction BetProtocol::MakeSessionTx(CAmount spendFee)
+{
+    CMutableTransaction mtx;
+
+    CC *disputeCond = MakeDisputeCond();
+    mtx.vout.push_back(CTxOut(spendFee, CCPubKey(disputeCond)));
+    cc_free(disputeCond);
+
+    for (int i=0; i<players.size(); i++) {
+        CC *cond = CCNewSecp256k1(players[i]);
+        mtx.vout.push_back(CTxOut(spendFee, CCPubKey(cond)));
+        cc_free(cond);
+    }
+    return mtx;
+}
+
+
+CMutableTransaction BetProtocol::MakeDisputeTx(uint256 signedSessionTxHash, uint256 vmResultHash)
+{
+    CMutableTransaction mtx;
+
+    CC *disputeCond = MakeDisputeCond();
+    mtx.vin.push_back(CTxIn(signedSessionTxHash, 0, CScript()));
+
+    std::vector<unsigned char> result(vmResultHash.begin(), vmResultHash.begin()+32);
+    mtx.vout.push_back(CTxOut(0, CScript() << OP_RETURN << result));
+    return mtx;
+}
+
+
+CMutableTransaction BetProtocol::MakePostEvidenceTx(uint256 signedSessionTxHash,
+        int playerIdx, std::vector<unsigned char> state)
+{
+    CMutableTransaction mtx;
+
+    mtx.vin.push_back(CTxIn(signedSessionTxHash, playerIdx+1, CScript()));
+    mtx.vout.push_back(CTxOut(0, CScript() << OP_RETURN << state));
+
+    return mtx;
+}
+
+
+CC* BetProtocol::MakePayoutCond(uint256 signedSessionTxHash)
+{
+    // TODO: 2/3 majority
+    CC* agree = CCNewThreshold(players.size(), PlayerConditions());
+
+    CC *import;
+    {
+        CC *importEval = CCNewEval(E_MARSHAL(
+            ss << EVAL_IMPORTPAYOUT << signedSessionTxHash;
+        ));
+
+        CC *oneof = CCNewThreshold(1, PlayerConditions());
+
+        import = CCNewThreshold(2, {oneof, importEval});
+    }
+
+    return CCNewThreshold(1, {agree, import});
+}
+
+
+CMutableTransaction BetProtocol::MakeStakeTx(CAmount totalPayout, uint256 signedSessionTxHash)
+{
+    CMutableTransaction mtx;
+
+    CC *payoutCond = MakePayoutCond(signedSessionTxHash);
+    mtx.vout.push_back(CTxOut(totalPayout, CCPubKey(payoutCond)));
+    cc_free(payoutCond);
+
+    return mtx;
+}
+
+
+CMutableTransaction BetProtocol::MakeAgreePayoutTx(std::vector<CTxOut> payouts,
+        uint256 signedStakeTxHash)
+{
+    CMutableTransaction mtx;
+    mtx.vin.push_back(CTxIn(signedStakeTxHash, 0, CScript()));
+    mtx.vout = payouts;
+    return mtx;
+}
+
+
+CMutableTransaction BetProtocol::MakeImportPayoutTx(std::vector<CTxOut> payouts,
+        CTransaction signedDisputeTx, uint256 signedStakeTxHash, MoMProof momProof)
+{
+    CMutableTransaction mtx;
+    mtx.vin.push_back(CTxIn(signedStakeTxHash, 0, CScript()));
+    mtx.vout = payouts;
+    CScript proofData;
+    proofData << OP_RETURN << E_MARSHAL(ss << momProof << signedDisputeTx);
+    mtx.vout.insert(mtx.vout.begin(), CTxOut(0, proofData));
+    return mtx;
+}
+
+
+bool GetOpReturnHash(CScript script, uint256 &hash)
+{
+    std::vector<unsigned char> vHash;
+    GetOpReturnData(script, vHash);
+    if (vHash.size() != 32) return false;
+    hash = uint256(vHash);
+    return true;
+}
--- a/src/cc/betprotocol.h
+++ b/src/cc/betprotocol.h
@@ -0,0 +1,68 @@
+#ifndef BETPROTOCOL_H
+#define BETPROTOCOL_H
+
+#include "cc/eval.h"
+#include "pubkey.h"
+#include "primitives/block.h"
+#include "primitives/transaction.h"
+#include "cryptoconditions/include/cryptoconditions.h"
+
+
+class MoMProof
+{
+public:
+    int nIndex;
+    std::vector<uint256> branch;
+    uint256 notarisationHash;
+
+    MoMProof() {}
+    MoMProof(int i, std::vector<uint256> b, uint256 n) : notarisationHash(n), nIndex(i), branch(b) {}
+    uint256 Exec(uint256 hash) const { return CBlock::CheckMerkleBranch(hash, branch, nIndex); }
+
+    ADD_SERIALIZE_METHODS;
+    
+    template <typename Stream, typename Operation>
+    inline void SerializationOp(Stream& s, Operation ser_action, int nType, int nVersion) {
+        READWRITE(VARINT(nIndex));
+        READWRITE(branch);
+        READWRITE(notarisationHash);
+    }
+};
+
+
+class BetProtocol
+{
+protected:
+    std::vector<CC*> playerConditions();
+public:
+    EvalCode disputeCode;
+    std::vector<CPubKey> players;
+    std::vector<unsigned char> vmParams;
+    uint32_t waitBlocks;
+
+    // Utility
+    BetProtocol(EvalCode dc, std::vector<CPubKey> ps, uint32_t wb, std::vector<uint8_t> vmp)
+        : disputeCode(dc), waitBlocks(wb), vmParams(vmp), players(ps) {}
+    std::vector<CC*> PlayerConditions();
+
+    // on PANGEA
+    CC* MakeDisputeCond();
+    CMutableTransaction MakeSessionTx(CAmount spendFee);
+    CMutableTransaction MakeDisputeTx(uint256 signedSessionTxHash, uint256 vmResultHash);
+    CMutableTransaction MakePostEvidenceTx(uint256 signedSessionTxHash,
+            int playerIndex, std::vector<unsigned char> state);
+
+    // on KMD
+    CC* MakePayoutCond(uint256 signedSessionTxHash);
+    CMutableTransaction MakeStakeTx(CAmount totalPayout, uint256 signedSessionTx);
+    CMutableTransaction MakeAgreePayoutTx(std::vector<CTxOut> payouts, uint256 signedStakeTxHash);
+    CMutableTransaction MakeImportPayoutTx(std::vector<CTxOut> payouts,
+            CTransaction signedDisputeTx, uint256 signedStakeTxHash, MoMProof momProof);
+};
+
+
+
+bool GetOpReturnHash(CScript script, uint256 &hash);
+
+
+#endif /* BETPROTOCOL_H */
--- a/src/cc/disputepayout.cpp
+++ b/src/cc/disputepayout.cpp
@@ -0,0 +1,84 @@
+#include <cryptoconditions.h>
+
+#include "hash.h"
+#include "chain.h"
+#include "version.h"
+#include "script/cc.h"
+#include "cc/eval.h"
+#include "cc/betprotocol.h"
+#include "primitives/transaction.h"
+
+
+/*
+ * Crypto-Condition EVAL method that resolves a dispute of a session
+ *
+ * IN: vm - AppVM virtual machine to verify states
+ * IN: params - condition params
+ * IN: disputeTx - transaction attempting to resolve dispute
+ * IN: nIn  - index of input of dispute tx
+ *
+ * disputeTx: attempt to resolve a dispute
+ *
+ *   in  0:      Spends Session TX first output, reveals DisputeHeader
+ *   out 0:      OP_RETURN hash of payouts
+ */
+bool Eval::DisputePayout(AppVM &vm, std::vector<uint8_t> params, const CTransaction &disputeTx, unsigned int nIn)
+{
+    if (disputeTx.vout.size() == 0) return Invalid("no-vouts");
+
+    // get payouts hash
+    uint256 payoutHash;
+    if (!GetOpReturnHash(disputeTx.vout[0].scriptPubKey, payoutHash))
+        return Invalid("invalid-payout-hash");
+
+    // load params
+    uint16_t waitBlocks;
+    std::vector<uint8_t> vmParams;
+    if (!E_UNMARSHAL(params, ss >> VARINT(waitBlocks); ss >> vmParams))
+        return Invalid("malformed-params");
+
+    // ensure that enough time has passed
+    {
+        CTransaction sessionTx;
+        CBlockIndex sessionBlock;
+        
+        // if unconformed its too soon
+        if (!GetTxConfirmed(disputeTx.vin[0].prevout.hash, sessionTx, sessionBlock))
+            return Error("couldnt-get-parent");
+
+        if (GetCurrentHeight() < sessionBlock.nHeight + waitBlocks)
+            return Invalid("dispute-too-soon");  // Not yet
+    }
+
+    // get spends
+    std::vector<CTransaction> spends;
+    if (!GetSpendsConfirmed(disputeTx.vin[0].prevout.hash, spends))
+        return Error("couldnt-get-spends");
+
+    // verify result from VM
+    int maxLength = -1;
+    uint256 bestPayout;
+    for (int i=1; i<spends.size(); i++)
+    {
+        std::vector<unsigned char> vmState;
+        if (spends[i].vout.size() == 0) continue;
+        if (!GetOpReturnData(spends[i].vout[0].scriptPubKey, vmState)) continue;
+        auto out = vm.evaluate(vmParams, vmState);
+        uint256 resultHash = SerializeHash(out.second);
+        if (out.first > maxLength) {
+            maxLength = out.first;
+            bestPayout = resultHash;
+        }
+        // The below means that if for any reason there is a draw, the first dispute wins
+        else if (out.first == maxLength) {
+            if (bestPayout != payoutHash) {
+                fprintf(stderr, "WARNING: VM has multiple solutions of same length\n");
+                bestPayout = resultHash;
+            }
+        }
+    }
+
+    if (maxLength == -1) return Invalid("no-evidence");
+
+    return bestPayout == payoutHash ? Valid() : Invalid("wrong-payout");
+}
--- a/src/cc/eval.cpp
+++ b/src/cc/eval.cpp
@@ -0,0 +1,205 @@
+#include <assert.h>
+#include <cryptoconditions.h>
+
+#include "primitives/transaction.h"
+#include "script/cc.h"
+#include "cc/eval.h"
+#include "main.h"
+#include "chain.h"
+#include "core_io.h"
+
+
+Eval* EVAL_TEST = 0;
+
+
+bool RunCCEval(const CC *cond, const CTransaction &tx, unsigned int nIn)
+{
+    Eval eval_;
+    Eval *eval = EVAL_TEST;
+    if (!eval) eval = &eval_;
+
+    bool out = eval->Dispatch(cond, tx, nIn);
+    assert(eval->state.IsValid() == out);
+
+    if (eval->state.IsValid()) return true;
+
+    std::string lvl = eval->state.IsInvalid() ? "Invalid" : "Error!";
+    fprintf(stderr, "CC Eval %s %s: %s spending tx %s\n",
+            EvalToStr(cond->code[0]).data(),
+            lvl.data(),
+            eval->state.GetRejectReason().data(),
+            tx.vin[nIn].prevout.hash.GetHex().data());
+    if (eval->state.IsError()) fprintf(stderr, "Culprit: %s\n", EncodeHexTx(tx).data());
+    return false;
+}
+
+
+/*
+ * Test the validity of an Eval node
+ */
+bool Eval::Dispatch(const CC *cond, const CTransaction &txTo, unsigned int nIn)
+{
+    if (cond->codeLength == 0)
+        return Invalid("empty-eval");
+
+    uint8_t ecode = cond->code[0];
+    std::vector<uint8_t> vparams(cond->code+1, cond->code+cond->codeLength);
+
+    if (ecode == EVAL_IMPORTPAYOUT) {
+        return ImportPayout(vparams, txTo, nIn);
+    }
+
+    return Invalid("invalid-code");
+}
+
+
+bool Eval::GetSpendsConfirmed(uint256 hash, std::vector<CTransaction> &spends) const
+{
+    // NOT IMPLEMENTED
+    return false;
+}
+
+
+bool Eval::GetTxUnconfirmed(const uint256 &hash, CTransaction &txOut, uint256 &hashBlock) const
+{
+    bool fAllowSlow = false; // Don't allow slow
+    return GetTransaction(hash, txOut, hashBlock, fAllowSlow);
+}
+
+
+bool Eval::GetTxConfirmed(const uint256 &hash, CTransaction &txOut, CBlockIndex &block) const
+{
+    uint256 hashBlock;
+    if (!GetTxUnconfirmed(hash, txOut, hashBlock))
+        return false;
+    if (hashBlock.IsNull() || !GetBlock(hashBlock, block))
+        return false;
+    return true;
+}
+
+
+unsigned int Eval::GetCurrentHeight() const
+{
+    return chainActive.Height();
+}
+
+
+bool Eval::GetBlock(uint256 hash, CBlockIndex& blockIdx) const
+{
+    auto r = mapBlockIndex.find(hash);
+    if (r != mapBlockIndex.end()) {
+        blockIdx = *r->second;
+        return true;
+    }
+    fprintf(stderr, "CC Eval Error: Can't get block from index\n");
+    return false;
+}
+
+
+extern int32_t komodo_notaries(uint8_t pubkeys[64][33],int32_t height,uint32_t timestamp);
+
+
+int32_t Eval::GetNotaries(uint8_t pubkeys[64][33], int32_t height, uint32_t timestamp) const
+{
+    return komodo_notaries(pubkeys, height, timestamp);
+}
+
+
+bool Eval::CheckNotaryInputs(const CTransaction &tx, uint32_t height, uint32_t timestamp) const
+{
+    if (tx.vin.size() < 11) return false;
+
+    uint8_t seenNotaries[64] = {0};
+    uint8_t notaries[64][33];
+    int nNotaries = GetNotaries(notaries, height, timestamp);
+
+    BOOST_FOREACH(const CTxIn &txIn, tx.vin)
+    {
+        // Get notary pubkey
+        CTransaction tx;
+        uint256 hashBlock;
+        if (!GetTxUnconfirmed(txIn.prevout.hash, tx, hashBlock)) return false;
+        if (tx.vout.size() < txIn.prevout.n) return false;
+        CScript spk = tx.vout[txIn.prevout.n].scriptPubKey;
+        if (spk.size() != 35) return false;
+        const unsigned char *pk = spk.data();
+        if (pk++[0] != 33) return false;
+        if (pk[33] != OP_CHECKSIG) return false;
+
+        // Check it's a notary
+        for (int i=0; i<nNotaries; i++) {
+            if (!seenNotaries[i]) {
+                if (memcmp(pk, notaries[i], 33) == 0) {
+                    seenNotaries[i] = 1;
+                    goto found;
+                }
+            }
+        }
+        return false;
+        found:;
+    }
+
+    return true;
+}
+
+
+/*
+ * Get MoM from a notarisation tx hash
+ */
+bool Eval::GetNotarisationData(const uint256 notaryHash, NotarisationData &data) const
+{
+    CTransaction notarisationTx;
+    CBlockIndex block;
+    if (!GetTxConfirmed(notaryHash, notarisationTx, block)) return false;
+    if (!CheckNotaryInputs(notarisationTx, block.nHeight, block.nTime)) return false;
+    if (notarisationTx.vout.size() < 2) return false;
+    if (!data.Parse(notarisationTx.vout[1].scriptPubKey)) return false;
+    return true;
+}
+
+
+/*
+ * Notarisation data, ie, OP_RETURN payload in notarisation transactions
+ */
+extern char ASSETCHAINS_SYMBOL[16];
+
+bool NotarisationData::Parse(const CScript scriptPK)
+{
+    *this = NotarisationData();
+
+    std::vector<unsigned char> vdata;
+    if (!GetOpReturnData(scriptPK, vdata)) return false;
+
+    CDataStream ss(vdata, SER_NETWORK, PROTOCOL_VERSION);
+
+    try {
+        ss >> blockHash;
+        ss >> height;
+        if (ASSETCHAINS_SYMBOL[0])
+            ss >> txHash;
+
+        char *nullPos = (char*) memchr(&ss[0], 0, ss.size());
+        if (!nullPos) return false;
+        ss.read(symbol, nullPos-&ss[0]+1);
+
+        if (ss.size() < 36) return false;
+        ss >> MoM;
+        ss >> MoMDepth;
+    } catch (...) {
+        return false;
+    }
+    return true;
+}
+
+
+/*
+ * Misc
+ */
+
+std::string EvalToStr(EvalCode c)
+{
+    FOREACH_EVAL(EVAL_GENERATE_STRING);
+    char s[10];
+    sprintf(s, "0x%x", c);
+    return std::string(s);
+}
--- a/src/cc/eval.h
+++ b/src/cc/eval.h
@@ -0,0 +1,143 @@
+#ifndef CC_EVAL_H
+#define CC_EVAL_H
+
+#include <cryptoconditions.h>
+
+#include "chain.h"
+#include "streams.h"
+#include "version.h"
+#include "consensus/validation.h"
+#include "primitives/transaction.h"
+
+
+/*
+ * Eval codes
+ *
+ * Add to below macro to generate new code.
+ *
+ * If at some point a new interpretation model is introduced,
+ * there should be a code identifying it. For example,
+ * a possible code is EVAL_BITCOIN_SCRIPT, where the entire binary
+ * after the code is interpreted as a bitcoin script.
+ */
+#define FOREACH_EVAL(EVAL) \
+        EVAL(EVAL_IMPORTPAYOUT, 0xe1)
+
+typedef uint8_t EvalCode;
+
+
+class AppVM;
+class NotarisationData;
+
+
+class Eval
+{
+public:
+    CValidationState state;
+
+    bool Invalid(std::string s) { return state.Invalid(false, 0, s); }
+    bool Error(std::string s) { return state.Error(s); }
+    bool Valid() { return true; }
+
+    /*
+     * Test validity of a CC_Eval node
+     */
+    virtual bool Dispatch(const CC *cond, const CTransaction &tx, unsigned int nIn);
+
+    /*
+     * Dispute a payout using a VM
+     */
+    bool DisputePayout(AppVM &vm, std::vector<uint8_t> params, const CTransaction &disputeTx, unsigned int nIn);
+
+    /*
+     * Test an ImportPayout CC Eval condition
+     */
+    bool ImportPayout(std::vector<uint8_t> params, const CTransaction &importTx, unsigned int nIn);
+
+    /*
+     * IO functions
+     */
+    virtual bool GetTxUnconfirmed(const uint256 &hash, CTransaction &txOut, uint256 &hashBlock) const;
+    virtual bool GetTxConfirmed(const uint256 &hash, CTransaction &txOut, CBlockIndex &block) const;
+    virtual unsigned int GetCurrentHeight() const;
+    virtual bool GetSpendsConfirmed(uint256 hash, std::vector<CTransaction> &spends) const;
+    virtual bool GetBlock(uint256 hash, CBlockIndex& blockIdx) const;
+    virtual int32_t GetNotaries(uint8_t pubkeys[64][33], int32_t height, uint32_t timestamp) const;
+    virtual bool GetNotarisationData(uint256 notarisationHash, NotarisationData &data) const;
+    virtual bool CheckNotaryInputs(const CTransaction &tx, uint32_t height, uint32_t timestamp) const;
+};
+
+
+bool RunCCEval(const CC *cond, const CTransaction &tx, unsigned int nIn);
+
+
+/*
+ * Virtual machine to use in the case of on-chain app evaluation
+ */
+class AppVM
+{ 
+public:
+    /*
+     * in:  header   - paramters agreed upon by all players
+     * in:  body     - gamestate
+     * out: length   - length of game (longest wins)
+     * out: payments - vector of CTxOut, always deterministically sorted.
+     */
+    virtual std::pair<int,std::vector<CTxOut>>
+        evaluate(std::vector<unsigned char> header, std::vector<unsigned char> body) = 0;
+};
+
+
+/*
+ * Data from notarisation OP_RETURN
+ */
+class NotarisationData {
+public:
+    uint256 blockHash;
+    uint32_t height;
+    uint256 txHash;  // Only get this guy in asset chains not in KMD
+    char symbol[64];
+    uint256 MoM;
+    uint32_t MoMDepth;
+
+    bool Parse(CScript scriptPubKey);
+};
+
+
+/*
+ * Eval code utilities.
+ */
+#define EVAL_GENERATE_DEF(L,I) const uint8_t L = I;
+#define EVAL_GENERATE_STRING(L,I) if (c == I) return #L;
+
+FOREACH_EVAL(EVAL_GENERATE_DEF);
+
+std::string EvalToStr(EvalCode c);
+
+
+/*
+ * Serialisation boilerplate
+ */
+#define E_MARSHAL(body) SerializeF([&] (CDataStream &ss) {body;})
+template <class T>
+std::vector<uint8_t> SerializeF(const T f)
+{
+    CDataStream ss(SER_NETWORK, PROTOCOL_VERSION);
+    f(ss);
+    return std::vector<unsigned char>(ss.begin(), ss.end());
+}
+
+#define E_UNMARSHAL(params, body) DeserializeF(params, [&] (CDataStream &ss) {body;})
+template <class T>
+bool DeserializeF(const std::vector<unsigned char> vIn, T f)
+{
+    CDataStream ss(vIn, SER_NETWORK, PROTOCOL_VERSION);
+    try {
+         f(ss);
+        if (ss.eof()) return true;
+    } catch(...) {}
+    return false;
+}
+
+
+#endif /* CC_EVAL_H */
--- a/src/cc/importpayout.cpp
+++ b/src/cc/importpayout.cpp
@@ -0,0 +1,76 @@
+#include <cryptoconditions.h>
+
+#include "main.h"
+#include "chain.h"
+#include "streams.h"
+#include "cc/eval.h"
+#include "cc/betprotocol.h"
+#include "primitives/transaction.h"
+
+
+/*
+ * Crypto-Condition EVAL method that verifies a payout against a transaction
+ * notarised on another chain.
+ *
+ * IN: params - condition params
+ * IN: importTx - Payout transaction on value chain (KMD)
+ * IN: nIn  - index of input of stake
+ *
+ * importTx: Spends stakeTx with payouts from asset chain
+ *
+ *   in  0:      Spends Stake TX and contains ImportPayout CC
+ *   out 0:      OP_RETURN MomProof, disputeTx
+ *   out 1-:     arbitrary payouts
+ *
+ * disputeTx: Spends sessionTx.0 (opener on asset chain)
+ *
+ *   in 0:       spends sessionTx.0
+ *   in 1-:      anything
+ *   out 0:      OP_RETURN hash of payouts
+ *   out 1-:     anything
+ */
+bool Eval::ImportPayout(const std::vector<uint8_t> params, const CTransaction &importTx, unsigned int nIn)
+{
+    if (importTx.vout.size() == 0) return Invalid("no-vouts");
+
+    // load data from vout[0]
+    MoMProof proof;
+    CTransaction disputeTx;
+    {
+        std::vector<unsigned char> vopret;
+        GetOpReturnData(importTx.vout[0].scriptPubKey, vopret);
+        if (!E_UNMARSHAL(vopret, ss >> proof; ss >> disputeTx))
+            return Invalid("invalid-payload");
+    }
+
+    // Check disputeTx.0 shows correct payouts
+    {
+        uint256 givenPayoutsHash;
+        GetOpReturnHash(disputeTx.vout[0].scriptPubKey, givenPayoutsHash);
+        std::vector<CTxOut> payouts(importTx.vout.begin() + 1, importTx.vout.end());
+        if (givenPayoutsHash != SerializeHash(payouts))
+            return Invalid("wrong-payouts");
+    }
+
+    // Check disputeTx spends sessionTx.0
+    // condition ImportPayout params is session ID from other chain
+    {
+        uint256 sessionHash;
+        if (!E_UNMARSHAL(params, ss >> sessionHash))
+            return Invalid("malformed-params");
+        if (disputeTx.vin[0].prevout != COutPoint(sessionHash, 0))
+            return Invalid("wrong-session");
+    }
+
+    // Check disputeTx solves momproof from vout[0]
+    {
+        NotarisationData data;
+        if (!GetNotarisationData(proof.notarisationHash, data))
+            return Invalid("coudnt-load-mom");
+
+        if (data.MoM != proof.Exec(disputeTx.GetHash()))
+            return Invalid("mom-check-fail");
+    }
+
+    return Valid();
+}
--- a/src/chain.h
+++ b/src/chain.h
@@ -177,7 +177,6 @@ public:

    //! (memory only) Sequential id assigned to distinguish order in which blocks are received.
    uint32_t nSequenceId;
-    int8_t notaryid; uint8_t pubkey33[33];
    
    void SetNull()
    {
--- a/src/chainparams.cpp
+++ b/src/chainparams.cpp
@@ -79,7 +79,7 @@ void *chainparams_commandline(void *ptr);
 #include "komodo_defs.h"

 extern char ASSETCHAINS_SYMBOL[KOMODO_ASSETCHAIN_MAXLEN];
-extern uint16_t ASSETCHAINS_PORT;
+extern uint16_t ASSETCHAINS_P2PPORT,ASSETCHAINS_RPCPORT;
 extern uint32_t ASSETCHAIN_INIT;
 extern uint32_t ASSETCHAINS_MAGIC;
 extern uint64_t ASSETCHAINS_SUPPLY;
@@ -213,7 +213,7 @@ void CChainParams::SetCheckpointData(CChainParams::CCheckpointData checkpointDat
 void *chainparams_commandline(void *ptr)
 {
    CChainParams::CCheckpointData checkpointData;
-    while ( ASSETCHAINS_PORT == 0 )
+    while ( ASSETCHAINS_P2PPORT == 0 )
    {
        #ifdef _WIN32
        boost::this_thread::sleep(boost::posix_time::milliseconds(1000));
@@ -221,15 +221,17 @@ void *chainparams_commandline(void *ptr)
        sleep(1);
        #endif
    }
-    //fprintf(stderr,">>>>>>>> port.%u\n",ASSETCHAINS_PORT);
+    //fprintf(stderr,">>>>>>>> port.%u\n",ASSETCHAINS_P2PPORT);
    if ( ASSETCHAINS_SYMBOL[0] != 0 )
    {
-        mainParams.SetDefaultPort(ASSETCHAINS_PORT);
+        mainParams.SetDefaultPort(ASSETCHAINS_P2PPORT);
+        if ( ASSETCHAINS_RPCPORT == 0 )
+            ASSETCHAINS_RPCPORT = ASSETCHAINS_P2PPORT + 1;
        mainParams.pchMessageStart[0] = ASSETCHAINS_MAGIC & 0xff;
        mainParams.pchMessageStart[1] = (ASSETCHAINS_MAGIC >> 8) & 0xff;
        mainParams.pchMessageStart[2] = (ASSETCHAINS_MAGIC >> 16) & 0xff;
        mainParams.pchMessageStart[3] = (ASSETCHAINS_MAGIC >> 24) & 0xff;
-        fprintf(stderr,">>>>>>>>>> %s: port.%u/%u magic.%08x %u %u coins\n",ASSETCHAINS_SYMBOL,ASSETCHAINS_PORT,ASSETCHAINS_PORT+1,ASSETCHAINS_MAGIC,ASSETCHAINS_MAGIC,(uint32_t)ASSETCHAINS_SUPPLY);
+        fprintf(stderr,">>>>>>>>>> %s: p2p.%u rpc.%u magic.%08x %u %u coins\n",ASSETCHAINS_SYMBOL,ASSETCHAINS_P2PPORT,ASSETCHAINS_RPCPORT,ASSETCHAINS_MAGIC,ASSETCHAINS_MAGIC,(uint32_t)ASSETCHAINS_SUPPLY);

        if (ASSETCHAINS_ALGO != ASSETCHAINS_EQUIHASH)
        {
--- a/src/clientversion.cpp
+++ b/src/clientversion.cpp
@@ -48,10 +48,11 @@ const std::string CLIENT_NAME("MagicBean");
 #include "build.h"
 #endif

-//! git will put "#define GIT_ARCHIVE 1" on the next line inside archives. $Format:%n#define GIT_ARCHIVE 1$
+//! git will put "#define GIT_ARCHIVE 1" on the next line inside archives. 
+#define GIT_ARCHIVE 1
 #ifdef GIT_ARCHIVE
-#define GIT_COMMIT_ID "$Format:%h$"
-#define GIT_COMMIT_DATE "$Format:%cD$"
+#define GIT_COMMIT_ID "a86845f3dc"
+#define GIT_COMMIT_DATE "Wed, 21 Feb 2018 16:15:11 +0200"
 #endif

 #define RENDER_BETA_STRING(num) "-beta" DO_STRINGIZE(num)
--- a/src/consensus/consensus.h
+++ b/src/consensus/consensus.h
@@ -17,7 +17,7 @@ static const int32_t OVERWINTER_MAX_TX_VERSION = 3;
 /** The maximum allowed size for a serialized block, in bytes (network rule) */
 static const unsigned int MAX_BLOCK_SIZE = 2000000;
 /** The maximum allowed number of signature check operations in a block (network rule) */
-static const unsigned int MAX_BLOCK_SIGOPS = 20000;
+extern unsigned int MAX_BLOCK_SIGOPS;
 /** The maximum size of a transaction (network rule) */
 static const unsigned int MAX_TX_SIZE = 100000;
 /** Coinbase transaction outputs can only be spent after this number of new blocks (network rule) */
--- a/src/consensus/validation.h
+++ b/src/consensus/validation.h
@@ -17,6 +17,7 @@ static const unsigned char REJECT_NONSTANDARD = 0x40;
 static const unsigned char REJECT_DUST = 0x41;
 static const unsigned char REJECT_INSUFFICIENTFEE = 0x42;
 static const unsigned char REJECT_CHECKPOINT = 0x43;
+static const unsigned char REJECT_HAVEBETTER = 0x44;

 /** Capture information about block/transaction validation */
 class CValidationState {
--- a/src/cryptoconditions/.gitignore
+++ b/src/cryptoconditions/.gitignore
@@ -0,0 +1,24 @@
+*.pyc
+.cache
+/Makefile
+/Makefile.in
+/aclocal.m4
+/autom4te.cache/
+/src/cryptoconditions-config.h
+/configure
+/depcomp
+/install-sh
+/libtool
+/ltmain.sh
+/m4/
+/missing
+/stamp-h?
+.deps/
+.dirstamp
+.libs/
+*.l[ao]
+*.[ao]
+*~
+converter-sample.c
+config.*
+.pytest_cache
--- a/src/cryptoconditions/.travis.yml
+++ b/src/cryptoconditions/.travis.yml
@@ -0,0 +1,10 @@
+language: C
+sudo: true
+compiler:
+  - clang
+  - gcc
+before_script: ./autogen.sh
+addons:
+  apt:
+    packages:
+    - gdb
--- a/src/cryptoconditions/LICENSE
+++ b/src/cryptoconditions/LICENSE
@@ -0,0 +1,13 @@
+Copyright 2017 Scott Sadler
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
--- a/src/cryptoconditions/Makefile.am
+++ b/src/cryptoconditions/Makefile.am
@@ -0,0 +1,91 @@
+lib_LTLIBRARIES=libcryptoconditions.la
+noinst_LTLIBRARIES=$(CRYPTOCONDITIONS_CORE)
+SUBDIRS = src/include/secp256k1
+
+include_HEADERS = include/cryptoconditions.h
+
+# Have a separate build target for cryptoconditions that does not contain secp256k1
+
+libcryptoconditions_la_SOURCES = include/cryptoconditions.h
+libcryptoconditions_la_LIBADD = $(CRYPTOCONDITIONS_CORE) $(LIBSECP256K1)
+
+AM_CFLAGS = -I$(top_srcdir)/src/asn -I$(top_srcdir)/include -I$(top_srcdir)/src/include \
+			-Wall -Wno-pointer-sign -Wno-discarded-qualifiers
+
+LIBSECP256K1=src/include/secp256k1/libsecp256k1.la
+
+$(LIBSECP256K1): $(wildcard src/secp256k1/*)
+	$(AM_V_at)$(MAKE) $(AM_MAKEFLAGS) -C $(@D) $(@F)
+
+CRYPTOCONDITIONS_CORE=libcryptoconditions_core.la
+
+libcryptoconditions_core_la_SOURCES = \
+	src/cryptoconditions.c \
+	src/utils.c \
+	src/include/cJSON.c \
+	src/include/sha256.c \
+	src/include/ed25519/src/keypair.c \
+	src/include/ed25519/src/seed.c \
+	src/include/ed25519/src/verify.c \
+	src/include/ed25519/src/sign.c \
+	src/include/ed25519/src/fe.c \
+	src/include/ed25519/src/sc.c \
+	src/include/ed25519/src/sha512.c \
+	src/include/ed25519/src/ge.c \
+	src/include/ed25519/src/add_scalar.c \
+	src/include/ed25519/src/key_exchange.c \
+	src/asn/Condition.c	\
+	src/asn/SimpleSha256Condition.c	\
+	src/asn/CompoundSha256Condition.c	\
+	src/asn/ConditionTypes.c	\
+	src/asn/Fulfillment.c	\
+	src/asn/PreimageFulfillment.c	\
+	src/asn/PrefixFulfillment.c	\
+	src/asn/ThresholdFulfillment.c	\
+	src/asn/RsaSha256Fulfillment.c	\
+	src/asn/Ed25519Sha512Fulfillment.c	\
+	src/asn/PrefixFingerprintContents.c	\
+	src/asn/ThresholdFingerprintContents.c	\
+	src/asn/RsaFingerprintContents.c	\
+	src/asn/Ed25519FingerprintContents.c \
+	src/asn/EvalFulfillment.c \
+	src/asn/Secp256k1FingerprintContents.c \
+	src/asn/Secp256k1Fulfillment.c \
+	src/asn/INTEGER.c \
+	src/asn/NativeEnumerated.c \
+	src/asn/NativeInteger.c \
+	src/asn/asn_SET_OF.c \
+	src/asn/constr_CHOICE.c \
+	src/asn/constr_SEQUENCE.c \
+	src/asn/constr_SET_OF.c \
+	src/asn/OCTET_STRING.c \
+	src/asn/BIT_STRING.c \
+	src/asn/asn_codecs_prim.c \
+	src/asn/ber_tlv_length.c \
+	src/asn/ber_tlv_tag.c \
+	src/asn/ber_decoder.c \
+	src/asn/der_encoder.c \
+	src/asn/constr_TYPE.c \
+	src/asn/constraints.c \
+	src/asn/xer_support.c \
+	src/asn/xer_decoder.c \
+	src/asn/xer_encoder.c \
+	src/asn/per_support.c \
+	src/asn/per_decoder.c \
+	src/asn/per_encoder.c \
+	src/asn/per_opentype.c
+
+test:
+	bash -c '[ -d .env ] || virtualenv .env -p python3'
+	.env/bin/pip install pytest
+	gdb -batch -ex run -ex bt --args .env/bin/python -m pytest -s -x -v 2>&1 | grep -v ^"No stack."$
+
+test-debug-interactive:
+	gdb -ex run --args python3 -m pytest -s -x -v
+
+asn:
+	cd src/asn; \
+		mv asn_system.h asn_system.bak; \
+		rm *.c *.h; \
+		asn1c CryptoConditions.asn; \
+		mv asn_system.bak asn_system.h
--- a/src/cryptoconditions/README.md
+++ b/src/cryptoconditions/README.md
@@ -0,0 +1,165 @@
+# libcryptoconditions [![Build Status](https://travis-ci.org/libscott/libcryptoconditions.svg?branch=komodo)](https://travis-ci.org/libscott/libcryptoconditions)
+
+Interledger Crypto-Conditions in C, targeting spec [draft-thomas-crypto-conditions-03](https://tools.ietf.org/html/draft-thomas-crypto-conditions-03).
+
+Features shared object and easy to use JSON api, as well as a command line interface written in Python.
+
+## Quickstart
+
+```shell
+git clone --recursive https://github.com/libscott/libcryptoconditions
+cd libcryptoconditions
+./autogen.sh
+./configure
+make
+./cryptoconditions.py --help
+```
+
+## Status
+
+JSON interface may not be particularly safe. The rest is pretty good now.
+
+## Embedding
+
+For the binary interface, see [cryptoconditions.h](./include/cryptoconditions.h).
+
+To embed in other languages, the easiest way may be to call the JSON RPC method via FFI. This is how it looks in Python:
+
+```python
+import json
+from ctypes import *
+
+so = cdll.LoadLibrary('.libs/libcryptoconditions.so')
+so.jsonRPC.restype = c_char_p
+
+def call_cryptoconditions_rpc(method, params):
+    out = so.jsonRPC(json.dumps({
+        'method': method,
+        'params': params,
+    }))
+    return json.loads(out)
+```
+
+## JSON methods
+
+### encodeCondition
+
+Encode a JSON condition to a base64 binary string
+
+```shell
+cryptoconditions encodeCondition '{
+    "type": "ed25519-sha-256",
+    "publicKey": "11qYAYKxCrfVS_7TyWQHOg7hcvPapiMlrwIaaPcHURo"
+}'
+{
+    "bin": "pCeAIHmSOauo_E_36r-8TETmnovf7ZkzJOEu1keSq-KJzx1fgQMCAAA", 
+    "uri": "ni:///sha-256;eZI5q6j8T_fqv7xMROaei9_tmTMk4S7WR5Kr4onPHV8?fpt=ed25519-sha-256&cost=131072"
+}
+```
+
+### decodeCondition
+
+Decode a binary condition
+
+```shell
+cryptoconditions decodeCondition '{
+    "bin": "pCeAIHmSOauo_E_36r-8TETmnovf7ZkzJOEu1keSq-KJzx1fgQMCAAA"
+}'
+{
+    "bin": "pCeAIHmSOauo_E_36r-8TETmnovf7ZkzJOEu1keSq-KJzx1fgQMCAAA", 
+    "uri": "ni:///sha-256;eZI5q6j8T_fqv7xMROaei9_tmTMk4S7WR5Kr4onPHV8?fpt=ed25519-sha-256&cost=131072"
+}
+```
+
+### encodeFulfillment
+
+Encode a JSON condition to a binary fulfillment. The condition must be fulfilled, that is,
+it needs to have signatures present.
+
+```shell
+cryptoconditions encodeFulfillment '{
+{
+    "type": "ed25519-sha-256",
+    "publicKey": "E0x0Ws4GhWhO_zBoUyaLbuqCz6hDdq11Ft1Dgbe9y9k",
+    "signature": "jcuovSRpHwqiC781KzSM1Jd0Qtyfge0cMGttUdLOVdjJlSBFLTtgpinASOaJpd-VGjhSGWkp1hPWuMAAZq6pAg"
+}'
+{
+    "fulfillment": "pGSAIBNMdFrOBoVoTv8waFMmi27qgs-oQ3atdRbdQ4G3vcvZgUCNy6i9JGkfCqILvzUrNIzUl3RC3J-B7Rwwa21R0s5V2MmVIEUtO2CmKcBI5oml35UaOFIZaSnWE9a4wABmrqkC"
+}
+
+```
+
+### decodeFulfillment
+
+Decode a binary fulfillment
+
+```shell
+cryptoconditions decodeFulfillment '{
+    "fulfillment": "pGSAINdamAGCsQq31Uv-08lkBzoO4XLz2qYjJa8CGmj3B1EagUDlVkMAw2CscpCG4syAboKKhId_Hrjl2XTYc-BlIkkBVV-4ghWQozusxh45cBz5tGvSW_XwWVu-JGVRQUOOehAL"
+}'
+{
+    "bin": "pCeAIHmSOauo_E_36r-8TETmnovf7ZkzJOEu1keSq-KJzx1fgQMCAAA", 
+    "uri": "ni:///sha-256;eZI5q6j8T_fqv7xMROaei9_tmTMk4S7WR5Kr4onPHV8?fpt=ed25519-sha-256&cost=131072"
+}
+```
+
+### verifyFulfillment
+
+Verify a fulfillment against a message and a condition URL
+
+```shell
+cryptoconditions verifyFulfillment '{
+    "message": "",
+    "fulfillment": "pGSAINdamAGCsQq31Uv-08lkBzoO4XLz2qYjJa8CGmj3B1EagUDlVkMAw2CscpCG4syAboKKhId_Hrjl2XTYc-BlIkkBVV-4ghWQozusxh45cBz5tGvSW_XwWVu-JGVRQUOOehAL",
+    "condition": "pCeAIHmSOauo_E_36r-8TETmnovf7ZkzJOEu1keSq-KJzx1fgQMCAAA"
+}
+{
+    "valid": true
+}
+```
+
+### signTreeEd25519
+
+Sign all ed25519 nodes in a condition tree
+
+```shell
+cryptoconditions signTreeEd25519 '{
+    "condition": {
+        "type": "ed25519-sha-256",
+        "publicKey": "E0x0Ws4GhWhO_zBoUyaLbuqCz6hDdq11Ft1Dgbe9y9k",
+    },
+    "privateKey": "11qYAYKxCrfVS_7TyWQHOg7hcvPapiMlrwIaaPcHURo",
+    "message": "",
+}'
+{
+    "num_signed": 1,
+    "condition": {
+        "type": "ed25519-sha-256",
+        "publicKey": "E0x0Ws4GhWhO_zBoUyaLbuqCz6hDdq11Ft1Dgbe9y9k",
+        "signature": "jcuovSRpHwqiC781KzSM1Jd0Qtyfge0cMGttUdLOVdjJlSBFLTtgpinASOaJpd-VGjhSGWkp1hPWuMAAZq6pAg"
+    }
+}
+```
+
+### signTreeSecp256k1
+
+Sign all secp256k1 nodes in a condition tree
+
+```shell
+cryptoconditions signTreeSecp256k1 '{
+    "condition": {
+        "type": "secp256k1-sha-256",
+        "publicKey": "AmkauD4tVL5-I7NN9hE_A8SlA0WdCIeJe_1Nac_km1hr",
+    },
+    "privateKey": "Bxwd5hOLZcTvzrR5Cupm3IV7TWHHl8nNLeO4UhYfRs4",
+    "message": "",
+}'
+{
+    "num_signed": 1,
+    "condition": {
+        "type": "secp256k1-sha-256",
+        "publicKey": "AmkauD4tVL5-I7NN9hE_A8SlA0WdCIeJe_1Nac_km1hr",
+        "signature": "LSQLzZo4cmt04KoCdoFcbIJX5MZ9CM6324SqkdqV1PppfUwquiWa7HD97hf4jdkdqU3ep8ZS9AU7zEJoUAl_Gg"
+    }
+}
+```
--- a/src/cryptoconditions/autogen.sh
+++ b/src/cryptoconditions/autogen.sh
@@ -0,0 +1,3 @@
+#!/bin/sh
+set -e
+autoreconf -if --warnings=all
--- a/src/cryptoconditions/compile
+++ b/src/cryptoconditions/compile
@@ -0,0 +1,347 @@
+#! /bin/sh
+# Wrapper for compilers which do not understand '-c -o'.
+
+scriptversion=2012-10-14.11; # UTC
+
+# Copyright (C) 1999-2014 Free Software Foundation, Inc.
+# Written by Tom Tromey <tromey@cygnus.com>.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2, or (at your option)
+# any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that program.
+
+# This file is maintained in Automake, please report
+# bugs to <bug-automake@gnu.org> or send patches to
+# <automake-patches@gnu.org>.
+
+nl='
+'
+
+# We need space, tab and new line, in precisely that order.  Quoting is
+# there to prevent tools from complaining about whitespace usage.
+IFS=" ""	$nl"
+
+file_conv=
+
+# func_file_conv build_file lazy
+# Convert a $build file to $host form and store it in $file
+# Currently only supports Windows hosts. If the determined conversion
+# type is listed in (the comma separated) LAZY, no conversion will
+# take place.
+func_file_conv ()
+{
+  file=$1
+  case $file in
+    / | /[!/]*) # absolute file, and not a UNC file
+      if test -z "$file_conv"; then
+	# lazily determine how to convert abs files
+	case `uname -s` in
+	  MINGW*)
+	    file_conv=mingw
+	    ;;
+	  CYGWIN*)
+	    file_conv=cygwin
+	    ;;
+	  *)
+	    file_conv=wine
+	    ;;
+	esac
+      fi
+      case $file_conv/,$2, in
+	*,$file_conv,*)
+	  ;;
+	mingw/*)
+	  file=`cmd //C echo "$file " | sed -e 's/"\(.*\) " *$/\1/'`
+	  ;;
+	cygwin/*)
+	  file=`cygpath -m "$file" || echo "$file"`
+	  ;;
+	wine/*)
+	  file=`winepath -w "$file" || echo "$file"`
+	  ;;
+      esac
+      ;;
+  esac
+}
+
+# func_cl_dashL linkdir
+# Make cl look for libraries in LINKDIR
+func_cl_dashL ()
+{
+  func_file_conv "$1"
+  if test -z "$lib_path"; then
+    lib_path=$file
+  else
+    lib_path="$lib_path;$file"
+  fi
+  linker_opts="$linker_opts -LIBPATH:$file"
+}
+
+# func_cl_dashl library
+# Do a library search-path lookup for cl
+func_cl_dashl ()
+{
+  lib=$1
+  found=no
+  save_IFS=$IFS
+  IFS=';'
+  for dir in $lib_path $LIB
+  do
+    IFS=$save_IFS
+    if $shared && test -f "$dir/$lib.dll.lib"; then
+      found=yes
+      lib=$dir/$lib.dll.lib
+      break
+    fi
+    if test -f "$dir/$lib.lib"; then
+      found=yes
+      lib=$dir/$lib.lib
+      break
+    fi
+    if test -f "$dir/lib$lib.a"; then
+      found=yes
+      lib=$dir/lib$lib.a
+      break
+    fi
+  done
+  IFS=$save_IFS
+
+  if test "$found" != yes; then
+    lib=$lib.lib
+  fi
+}
+
+# func_cl_wrapper cl arg...
+# Adjust compile command to suit cl
+func_cl_wrapper ()
+{
+  # Assume a capable shell
+  lib_path=
+  shared=:
+  linker_opts=
+  for arg
+  do
+    if test -n "$eat"; then
+      eat=
+    else
+      case $1 in
+	-o)
+	  # configure might choose to run compile as 'compile cc -o foo foo.c'.
+	  eat=1
+	  case $2 in
+	    *.o | *.[oO][bB][jJ])
+	      func_file_conv "$2"
+	      set x "$@" -Fo"$file"
+	      shift
+	      ;;
+	    *)
+	      func_file_conv "$2"
+	      set x "$@" -Fe"$file"
+	      shift
+	      ;;
+	  esac
+	  ;;
+	-I)
+	  eat=1
+	  func_file_conv "$2" mingw
+	  set x "$@" -I"$file"
+	  shift
+	  ;;
+	-I*)
+	  func_file_conv "${1#-I}" mingw
+	  set x "$@" -I"$file"
+	  shift
+	  ;;
+	-l)
+	  eat=1
+	  func_cl_dashl "$2"
+	  set x "$@" "$lib"
+	  shift
+	  ;;
+	-l*)
+	  func_cl_dashl "${1#-l}"
+	  set x "$@" "$lib"
+	  shift
+	  ;;
+	-L)
+	  eat=1
+	  func_cl_dashL "$2"
+	  ;;
+	-L*)
+	  func_cl_dashL "${1#-L}"
+	  ;;
+	-static)
+	  shared=false
+	  ;;
+	-Wl,*)
+	  arg=${1#-Wl,}
+	  save_ifs="$IFS"; IFS=','
+	  for flag in $arg; do
+	    IFS="$save_ifs"
+	    linker_opts="$linker_opts $flag"
+	  done
+	  IFS="$save_ifs"
+	  ;;
+	-Xlinker)
+	  eat=1
+	  linker_opts="$linker_opts $2"
+	  ;;
+	-*)
+	  set x "$@" "$1"
+	  shift
+	  ;;
+	*.cc | *.CC | *.cxx | *.CXX | *.[cC]++)
+	  func_file_conv "$1"
+	  set x "$@" -Tp"$file"
+	  shift
+	  ;;
+	*.c | *.cpp | *.CPP | *.lib | *.LIB | *.Lib | *.OBJ | *.obj | *.[oO])
+	  func_file_conv "$1" mingw
+	  set x "$@" "$file"
+	  shift
+	  ;;
+	*)
+	  set x "$@" "$1"
+	  shift
+	  ;;
+      esac
+    fi
+    shift
+  done
+  if test -n "$linker_opts"; then
+    linker_opts="-link$linker_opts"
+  fi
+  exec "$@" $linker_opts
+  exit 1
+}
+
+eat=
+
+case $1 in
+  '')
+     echo "$0: No command.  Try '$0 --help' for more information." 1>&2
+     exit 1;
+     ;;
+  -h | --h*)
+    cat <<\EOF
+Usage: compile [--help] [--version] PROGRAM [ARGS]
+
+Wrapper for compilers which do not understand '-c -o'.
+Remove '-o dest.o' from ARGS, run PROGRAM with the remaining
+arguments, and rename the output as expected.
+
+If you are trying to build a whole package this is not the
+right script to run: please start by reading the file 'INSTALL'.
+
+Report bugs to <bug-automake@gnu.org>.
+EOF
+    exit $?
+    ;;
+  -v | --v*)
+    echo "compile $scriptversion"
+    exit $?
+    ;;
+  cl | *[/\\]cl | cl.exe | *[/\\]cl.exe )
+    func_cl_wrapper "$@"      # Doesn't return...
+    ;;
+esac
+
+ofile=
+cfile=
+
+for arg
+do
+  if test -n "$eat"; then
+    eat=
+  else
+    case $1 in
+      -o)
+	# configure might choose to run compile as 'compile cc -o foo foo.c'.
+	# So we strip '-o arg' only if arg is an object.
+	eat=1
+	case $2 in
+	  *.o | *.obj)
+	    ofile=$2
+	    ;;
+	  *)
+	    set x "$@" -o "$2"
+	    shift
+	    ;;
+	esac
+	;;
+      *.c)
+	cfile=$1
+	set x "$@" "$1"
+	shift
+	;;
+      *)
+	set x "$@" "$1"
+	shift
+	;;
+    esac
+  fi
+  shift
+done
+
+if test -z "$ofile" || test -z "$cfile"; then
+  # If no '-o' option was seen then we might have been invoked from a
+  # pattern rule where we don't need one.  That is ok -- this is a
+  # normal compilation that the losing compiler can handle.  If no
+  # '.c' file was seen then we are probably linking.  That is also
+  # ok.
+  exec "$@"
+fi
+
+# Name of file we expect compiler to create.
+cofile=`echo "$cfile" | sed 's|^.*[\\/]||; s|^[a-zA-Z]:||; s/\.c$/.o/'`
+
+# Create the lock directory.
+# Note: use '[/\\:.-]' here to ensure that we don't use the same name
+# that we are using for the .o file.  Also, base the name on the expected
+# object file name, since that is what matters with a parallel build.
+lockdir=`echo "$cofile" | sed -e 's|[/\\:.-]|_|g'`.d
+while true; do
+  if mkdir "$lockdir" >/dev/null 2>&1; then
+    break
+  fi
+  sleep 1
+done
+# FIXME: race condition here if user kills between mkdir and trap.
+trap "rmdir '$lockdir'; exit 1" 1 2 15
+
+# Run the compile.
+"$@"
+ret=$?
+
+if test -f "$cofile"; then
+  test "$cofile" = "$ofile" || mv "$cofile" "$ofile"
+elif test -f "${cofile}bj"; then
+  test "${cofile}bj" = "$ofile" || mv "${cofile}bj" "$ofile"
+fi
+
+rmdir "$lockdir"
+exit $ret
+
+# Local Variables:
+# mode: shell-script
+# sh-indentation: 2
+# eval: (add-hook 'write-file-hooks 'time-stamp)
+# time-stamp-start: "scriptversion="
+# time-stamp-format: "%:y-%02m-%02d.%02H"
+# time-stamp-time-zone: "UTC"
+# time-stamp-end: "; # UTC"
+# End:
--- a/src/cryptoconditions/configure.ac
+++ b/src/cryptoconditions/configure.ac
@@ -0,0 +1,42 @@
+#                                               -*- Autoconf -*-
+# Process this file with autoconf to produce a configure script.
+
+AC_PREREQ([2.69])
+AC_INIT([FULL-PACKAGE-NAME], [VERSION], [BUG-REPORT-ADDRESS])
+AC_CONFIG_HEADERS([src/cryptoconditions-config.h])
+AC_CONFIG_MACRO_DIRS([m4])
+AC_CONFIG_SUBDIRS([src/include/secp256k1])
+
+AM_INIT_AUTOMAKE([foreign subdir-objects])
+LT_INIT
+
+# Checks for programs.
+AC_PROG_CC
+AC_PROG_CC_STDC
+
+# Checks for libraries.
+
+# Checks for header files.
+AC_FUNC_ALLOCA
+AC_CHECK_HEADERS([arpa/inet.h float.h inttypes.h limits.h locale.h malloc.h netinet/in.h stddef.h stdint.h stdlib.h string.h])
+
+# Checks for typedefs, structures, and compiler characteristics.
+AC_CHECK_HEADER_STDBOOL
+AC_TYPE_INT16_T
+AC_TYPE_INT32_T
+AC_TYPE_INT8_T
+AC_TYPE_SIZE_T
+AC_TYPE_SSIZE_T
+AC_TYPE_UINT16_T
+AC_TYPE_UINT32_T
+AC_TYPE_UINT64_T
+AC_TYPE_UINT8_T
+AC_CHECK_TYPES([ptrdiff_t])
+
+# Checks for library functions.
+AC_FUNC_MALLOC
+AC_FUNC_STRTOD
+AC_CHECK_FUNCS([localeconv memchr memset])
+
+AC_CONFIG_FILES([Makefile])
+AC_OUTPUT
--- a/src/cryptoconditions/cryptoconditions.py
+++ b/src/cryptoconditions/cryptoconditions.py
@@ -0,0 +1,62 @@
+#!/usr/bin/env python
+
+import sys
+import json
+import ctypes
+import base64
+import os.path
+import argparse
+from ctypes import *
+
+
+so = cdll.LoadLibrary('.libs/libcryptoconditions.so')
+so.jsonRPC.restype = c_char_p
+
+
+def jsonRPC(method, params, load=True):
+    out = so.cc_jsonRPC(json.dumps({
+        'method': method,
+        'params': params,
+    }))
+    return json.loads(out) if load else out
+
+
+def b16_to_b64(b16):
+    return base64.urlsafe_b64encode(base64.b16decode(b16)).rstrip('=')
+
+
+USAGE = "cryptoconditions [-h] {method} {request_json}"
+
+def get_help():
+    methods = jsonRPC("listMethods", {})['methods']
+
+    txt = USAGE + "\n\nmethods:\n"
+    
+    for method in methods:
+        txt += '    %s: %s\n' % (method['name'], method['description'])
+
+    txt += """\noptional arguments:
+  -h, --help            show this help message and exit
+"""
+    return txt
+
+
+def get_parser():
+    class Parser(argparse.ArgumentParser):
+        def format_help(self):
+            return get_help()
+
+    parser = Parser(description='Crypto Conditions JSON interface', usage=USAGE)
+
+    json_loads = lambda r: json.loads(r)
+    json_loads.__name__ = 'json'
+    
+    parser.add_argument("method")
+    parser.add_argument("request", type=json_loads)
+    
+    return parser
+
+
+if __name__ == '__main__':
+    args = get_parser().parse_args()
+    print(jsonRPC(args.method, args.request, load=False))
--- a/src/cryptoconditions/include/cryptoconditions.h
+++ b/src/cryptoconditions/include/cryptoconditions.h
@@ -0,0 +1,106 @@
+#include <cJSON.h>
+#include <stdint.h>
+
+
+#ifndef CRYPTOCONDITIONS_H
+#define CRYPTOCONDITIONS_H
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+struct CC;
+struct CCType;
+
+
+enum CCTypeId {
+    CC_Anon = -1,
+    CC_Preimage = 0,
+    CC_Prefix = 1,
+    CC_Threshold = 2,
+    CC_Ed25519 = 4,
+    CC_Secp256k1 = 5,
+    CC_Eval = 15
+};
+
+
+/*
+ * Evaliliary verification callback
+ */
+typedef int (*VerifyEval)(struct CC *cond, void *context);
+
+
+
+/*
+ * Crypto Condition
+ */
+typedef struct CC {
+    struct CCType *type;
+    union {
+        // public key types
+        struct { uint8_t *publicKey, *signature; };
+        // preimage
+        struct { uint8_t *preimage; size_t preimageLength; };
+        // threshold
+        struct { long threshold; uint8_t size; struct CC **subconditions; };
+        // prefix
+        struct { uint8_t *prefix; size_t prefixLength; struct CC *subcondition;
+                 size_t maxMessageLength; };
+        // eval
+        struct { uint8_t *code; size_t codeLength; };
+        // anon
+        struct { uint8_t fingerprint[32]; uint32_t subtypes; unsigned long cost; 
+                 struct CCType *conditionType; };
+    };
+} CC;
+
+
+
+/*
+ * Crypto Condition Visitor
+ */
+typedef struct CCVisitor {
+    int (*visit)(CC *cond, struct CCVisitor visitor);
+    const uint8_t *msg;
+    size_t msgLength;
+    void *context;
+} CCVisitor;
+
+
+/*
+ * Public methods
+ */
+int             cc_isFulfilled(const CC *cond);
+int             cc_verify(const struct CC *cond, const uint8_t *msg, size_t msgLength,
+                        int doHashMessage, const uint8_t *condBin, size_t condBinLength,
+                        VerifyEval verifyEval, void *evalContext);
+int             cc_visit(CC *cond, struct CCVisitor visitor);
+int             cc_signTreeEd25519(CC *cond, const uint8_t *privateKey, const uint8_t *msg,
+                        const size_t msgLength);
+int             cc_signTreeSecp256k1Msg32(CC *cond, const uint8_t *privateKey, const uint8_t *msg32);
+int             cc_secp256k1VerifyTreeMsg32(const CC *cond, const uint8_t *msg32);
+size_t          cc_conditionBinary(const CC *cond, uint8_t *buf);
+size_t          cc_fulfillmentBinary(const CC *cond, uint8_t *buf, size_t bufLength);
+struct CC*      cc_conditionFromJSON(cJSON *params, char *err);
+struct CC*      cc_conditionFromJSONString(const char *json, char *err);
+struct CC*      cc_readConditionBinary(const uint8_t *cond_bin, size_t cond_bin_len);
+struct CC*      cc_readFulfillmentBinary(const uint8_t *ffill_bin, size_t ffill_bin_len);
+struct CC*      cc_new(int typeId);
+struct cJSON*   cc_conditionToJSON(const CC *cond);
+char*           cc_conditionToJSONString(const CC *cond);
+char*           cc_conditionUri(const CC *cond);
+char*           cc_jsonRPC(char *request);
+char*           cc_typeName(const CC *cond);
+enum CCTypeId   cc_typeId(const CC *cond);
+unsigned long   cc_getCost(const CC *cond);
+uint32_t        cc_typeMask(const CC *cond);
+int             cc_isAnon(const CC *cond);
+void            cc_free(struct CC *cond);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  /* CRYPTOCONDITIONS_H */
--- a/src/cryptoconditions/src/anon.c
+++ b/src/cryptoconditions/src/anon.c
@@ -0,0 +1,73 @@
+
+#include "asn/Condition.h"
+#include "asn/Fulfillment.h"
+#include "asn/PrefixFingerprintContents.h"
+#include "asn/OCTET_STRING.h"
+#include "include/cJSON.h"
+#include "cryptoconditions.h"
+
+
+struct CCType CC_AnonType;
+
+
+CC *mkAnon(const Condition_t *asnCond) {
+
+    CCType *realType = getTypeByAsnEnum(asnCond->present);
+    if (!realType) {
+        fprintf(stderr, "Unknown ASN type: %i", asnCond->present);
+        return 0;
+    }
+    CC *cond = cc_new(CC_Anon);
+    cond->conditionType = realType;
+    const CompoundSha256Condition_t *deets = &asnCond->choice.thresholdSha256;
+    memcpy(cond->fingerprint, deets->fingerprint.buf, 32);
+    cond->cost = deets->cost;
+    if (realType->getSubtypes) {
+        cond->subtypes = fromAsnSubtypes(deets->subtypes);
+    }
+    return cond;
+}
+
+
+
+static void anonToJSON(const CC *cond, cJSON *params) {
+    unsigned char *b64 = base64_encode(cond->fingerprint, 32);
+    cJSON_AddItemToObject(params, "fingerprint", cJSON_CreateString(b64));
+    free(b64);
+    cJSON_AddItemToObject(params, "cost", cJSON_CreateNumber(cond->cost));
+    cJSON_AddItemToObject(params, "subtypes", cJSON_CreateNumber(cond->subtypes));
+}
+
+
+static unsigned char *anonFingerprint(const CC *cond) {
+    unsigned char *out = calloc(1, 32);
+    memcpy(out, cond->fingerprint, 32);
+    return out;
+}
+
+
+static unsigned long anonCost(const CC *cond) {
+    return cond->cost;
+}
+
+
+static uint32_t anonSubtypes(const CC *cond) {
+    return cond->subtypes;
+}
+
+
+static Fulfillment_t *anonFulfillment(const CC *cond) {
+    return NULL;
+}
+
+
+static void anonFree(CC *cond) {
+}
+
+
+static int anonIsFulfilled(const CC *cond) {
+    return 0;
+}
+
+
+struct CCType CC_AnonType = { -1, "(anon)", Condition_PR_NOTHING, NULL, &anonFingerprint, &anonCost, &anonSubtypes, NULL, &anonToJSON, NULL, &anonFulfillment, &anonIsFulfilled, &anonFree };
--- a/src/cryptoconditions/src/asn/BIT_STRING.c
+++ b/src/cryptoconditions/src/asn/BIT_STRING.c
@@ -0,0 +1,189 @@
+/*-
+ * Copyright (c) 2003, 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#include <asn_internal.h>
+#include <BIT_STRING.h>
+#include <asn_internal.h>
+
+/*
+ * BIT STRING basic type description.
+ */
+static const ber_tlv_tag_t asn_DEF_BIT_STRING_tags[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (3 << 2))
+};
+static asn_OCTET_STRING_specifics_t asn_DEF_BIT_STRING_specs = {
+	sizeof(BIT_STRING_t),
+	offsetof(BIT_STRING_t, _asn_ctx),
+	ASN_OSUBV_BIT
+};
+asn_TYPE_descriptor_t asn_DEF_BIT_STRING = {
+	"BIT STRING",
+	"BIT_STRING",
+	OCTET_STRING_free,         /* Implemented in terms of OCTET STRING */
+	BIT_STRING_print,
+	BIT_STRING_constraint,
+	OCTET_STRING_decode_ber,   /* Implemented in terms of OCTET STRING */
+	OCTET_STRING_encode_der,   /* Implemented in terms of OCTET STRING */
+	OCTET_STRING_decode_xer_binary,
+	BIT_STRING_encode_xer,
+	OCTET_STRING_decode_uper,	/* Unaligned PER decoder */
+	OCTET_STRING_encode_uper,	/* Unaligned PER encoder */
+	0, /* Use generic outmost tag fetcher */
+	asn_DEF_BIT_STRING_tags,
+	sizeof(asn_DEF_BIT_STRING_tags)
+	  / sizeof(asn_DEF_BIT_STRING_tags[0]),
+	asn_DEF_BIT_STRING_tags,	/* Same as above */
+	sizeof(asn_DEF_BIT_STRING_tags)
+	  / sizeof(asn_DEF_BIT_STRING_tags[0]),
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	&asn_DEF_BIT_STRING_specs
+};
+
+/*
+ * BIT STRING generic constraint.
+ */
+int
+BIT_STRING_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+		asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
+
+	if(st && st->buf) {
+		if((st->size == 0 && st->bits_unused)
+		|| st->bits_unused < 0 || st->bits_unused > 7) {
+			ASN__CTFAIL(app_key, td, sptr,
+				"%s: invalid padding byte (%s:%d)",
+				td->name, __FILE__, __LINE__);
+			return -1;
+		}
+	} else {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+
+	return 0;
+}
+
+static char *_bit_pattern[16] = {
+	"0000", "0001", "0010", "0011", "0100", "0101", "0110", "0111",
+	"1000", "1001", "1010", "1011", "1100", "1101", "1110", "1111"
+};
+
+asn_enc_rval_t
+BIT_STRING_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
+	int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	asn_enc_rval_t er;
+	char scratch[128];
+	char *p = scratch;
+	char *scend = scratch + (sizeof(scratch) - 10);
+	const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
+	int xcan = (flags & XER_F_CANONICAL);
+	uint8_t *buf;
+	uint8_t *end;
+
+	if(!st || !st->buf)
+		ASN__ENCODE_FAILED;
+
+	er.encoded = 0;
+
+	buf = st->buf;
+	end = buf + st->size - 1;	/* Last byte is special */
+
+	/*
+	 * Binary dump
+	 */
+	for(; buf < end; buf++) {
+		int v = *buf;
+		int nline = xcan?0:(((buf - st->buf) % 8) == 0);
+		if(p >= scend || nline) {
+			er.encoded += p - scratch;
+			ASN__CALLBACK(scratch, p - scratch);
+			p = scratch;
+			if(nline) ASN__TEXT_INDENT(1, ilevel);
+		}
+		memcpy(p + 0, _bit_pattern[v >> 4], 4);
+		memcpy(p + 4, _bit_pattern[v & 0x0f], 4);
+		p += 8;
+	}
+
+	if(!xcan && ((buf - st->buf) % 8) == 0)
+		ASN__TEXT_INDENT(1, ilevel);
+	er.encoded += p - scratch;
+	ASN__CALLBACK(scratch, p - scratch);
+	p = scratch;
+
+	if(buf == end) {
+		int v = *buf;
+		int ubits = st->bits_unused;
+		int i;
+		for(i = 7; i >= ubits; i--)
+			*p++ = (v & (1 << i)) ? 0x31 : 0x30;
+		er.encoded += p - scratch;
+		ASN__CALLBACK(scratch, p - scratch);
+	}
+
+	if(!xcan) ASN__TEXT_INDENT(1, ilevel - 1);
+
+	ASN__ENCODED_OK(er);
+cb_failed:
+	ASN__ENCODE_FAILED;
+}
+
+
+/*
+ * BIT STRING specific contents printer.
+ */
+int
+BIT_STRING_print(asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	const char * const h2c = "0123456789ABCDEF";
+	char scratch[64];
+	const BIT_STRING_t *st = (const BIT_STRING_t *)sptr;
+	uint8_t *buf;
+	uint8_t *end;
+	char *p = scratch;
+
+	(void)td;	/* Unused argument */
+
+	if(!st || !st->buf)
+		return (cb("<absent>", 8, app_key) < 0) ? -1 : 0;
+
+	ilevel++;
+	buf = st->buf;
+	end = buf + st->size;
+
+	/*
+	 * Hexadecimal dump.
+	 */
+	for(; buf < end; buf++) {
+		if((buf - st->buf) % 16 == 0 && (st->size > 16)
+				&& buf != st->buf) {
+			_i_INDENT(1);
+			/* Dump the string */
+			if(cb(scratch, p - scratch, app_key) < 0) return -1;
+			p = scratch;
+		}
+		*p++ = h2c[*buf >> 4];
+		*p++ = h2c[*buf & 0x0F];
+		*p++ = 0x20;
+	}
+
+	if(p > scratch) {
+		p--;	/* Eat the tailing space */
+
+		if((st->size > 16)) {
+			_i_INDENT(1);
+		}
+
+		/* Dump the incomplete 16-bytes row */
+		if(cb(scratch, p - scratch, app_key) < 0)
+			return -1;
+	}
+
+	return 0;
+}
+
--- a/src/cryptoconditions/src/asn/BIT_STRING.h
+++ b/src/cryptoconditions/src/asn/BIT_STRING.h
@@ -0,0 +1,33 @@
+/*-
+ * Copyright (c) 2003 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#ifndef	_BIT_STRING_H_
+#define	_BIT_STRING_H_
+
+#include <OCTET_STRING.h>	/* Some help from OCTET STRING */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct BIT_STRING_s {
+	uint8_t *buf;	/* BIT STRING body */
+	int size;	/* Size of the above buffer */
+
+	int bits_unused;/* Unused trailing bits in the last octet (0..7) */
+
+	asn_struct_ctx_t _asn_ctx;	/* Parsing across buffer boundaries */
+} BIT_STRING_t;
+
+extern asn_TYPE_descriptor_t asn_DEF_BIT_STRING;
+
+asn_struct_print_f BIT_STRING_print;	/* Human-readable output */
+asn_constr_check_f BIT_STRING_constraint;
+xer_type_encoder_f BIT_STRING_encode_xer;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _BIT_STRING_H_ */
--- a/src/cryptoconditions/src/asn/CompoundSha256Condition.c
+++ b/src/cryptoconditions/src/asn/CompoundSha256Condition.c
@@ -0,0 +1,235 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "Crypto-Conditions"
+ * 	found in "CryptoConditions.asn"
+ */
+
+#include "CompoundSha256Condition.h"
+
+static int
+cost_3_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	
+	if(!sptr) {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	
+	/* Constraint check succeeded */
+	return 0;
+}
+
+/*
+ * This type is implemented using NativeInteger,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+cost_3_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_NativeInteger.free_struct;
+	td->print_struct   = asn_DEF_NativeInteger.print_struct;
+	td->check_constraints = asn_DEF_NativeInteger.check_constraints;
+	td->ber_decoder    = asn_DEF_NativeInteger.ber_decoder;
+	td->der_encoder    = asn_DEF_NativeInteger.der_encoder;
+	td->xer_decoder    = asn_DEF_NativeInteger.xer_decoder;
+	td->xer_encoder    = asn_DEF_NativeInteger.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeInteger.uper_decoder;
+	td->uper_encoder   = asn_DEF_NativeInteger.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeInteger.per_constraints;
+	td->elements       = asn_DEF_NativeInteger.elements;
+	td->elements_count = asn_DEF_NativeInteger.elements_count;
+     /* td->specifics      = asn_DEF_NativeInteger.specifics;	// Defined explicitly */
+}
+
+static void
+cost_3_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	cost_3_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+static int
+cost_3_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	cost_3_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+static asn_dec_rval_t
+cost_3_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	cost_3_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+static asn_enc_rval_t
+cost_3_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	cost_3_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+static asn_dec_rval_t
+cost_3_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	cost_3_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+static asn_enc_rval_t
+cost_3_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	cost_3_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+static int
+memb_fingerprint_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	size = st->size;
+	
+	if((size == 32)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static int
+memb_cost_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	
+	if(!sptr) {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	
+	/* Constraint check succeeded */
+	return 0;
+}
+
+static const asn_INTEGER_specifics_t asn_SPC_cost_specs_3 = {
+	0,	0,	0,	0,	0,
+	0,	/* Native long size */
+	1	/* Unsigned representation */
+};
+static const ber_tlv_tag_t asn_DEF_cost_tags_3[] = {
+	(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+static /* Use -fall-defs-global to expose */
+asn_TYPE_descriptor_t asn_DEF_cost_3 = {
+	"cost",
+	"cost",
+	cost_3_free,
+	cost_3_print,
+	cost_3_constraint,
+	cost_3_decode_ber,
+	cost_3_encode_der,
+	cost_3_decode_xer,
+	cost_3_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_cost_tags_3,
+	sizeof(asn_DEF_cost_tags_3)
+		/sizeof(asn_DEF_cost_tags_3[0]) - 1, /* 1 */
+	asn_DEF_cost_tags_3,	/* Same as above */
+	sizeof(asn_DEF_cost_tags_3)
+		/sizeof(asn_DEF_cost_tags_3[0]), /* 2 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	&asn_SPC_cost_specs_3	/* Additional specs */
+};
+
+static asn_TYPE_member_t asn_MBR_CompoundSha256Condition_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct CompoundSha256Condition, fingerprint),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_OCTET_STRING,
+		memb_fingerprint_constraint_1,
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"fingerprint"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct CompoundSha256Condition, cost),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_cost_3,
+		memb_cost_constraint_1,
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"cost"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct CompoundSha256Condition, subtypes),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_ConditionTypes,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"subtypes"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_CompoundSha256Condition_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_CompoundSha256Condition_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* fingerprint */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* cost */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* subtypes */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_CompoundSha256Condition_specs_1 = {
+	sizeof(struct CompoundSha256Condition),
+	offsetof(struct CompoundSha256Condition, _asn_ctx),
+	asn_MAP_CompoundSha256Condition_tag2el_1,
+	3,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	-1,	/* Start extensions */
+	-1	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_CompoundSha256Condition = {
+	"CompoundSha256Condition",
+	"CompoundSha256Condition",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_CompoundSha256Condition_tags_1,
+	sizeof(asn_DEF_CompoundSha256Condition_tags_1)
+		/sizeof(asn_DEF_CompoundSha256Condition_tags_1[0]), /* 1 */
+	asn_DEF_CompoundSha256Condition_tags_1,	/* Same as above */
+	sizeof(asn_DEF_CompoundSha256Condition_tags_1)
+		/sizeof(asn_DEF_CompoundSha256Condition_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_CompoundSha256Condition_1,
+	3,	/* Elements count */
+	&asn_SPC_CompoundSha256Condition_specs_1	/* Additional specs */
+};
+
--- a/src/cryptoconditions/src/asn/CompoundSha256Condition.h
+++ b/src/cryptoconditions/src/asn/CompoundSha256Condition.h
@@ -0,0 +1,42 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "Crypto-Conditions"
+ * 	found in "CryptoConditions.asn"
+ */
+
+#ifndef	_CompoundSha256Condition_H_
+#define	_CompoundSha256Condition_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <OCTET_STRING.h>
+#include <NativeInteger.h>
+#include "ConditionTypes.h"
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* CompoundSha256Condition */
+typedef struct CompoundSha256Condition {
+	OCTET_STRING_t	 fingerprint;
+	unsigned long	 cost;
+	ConditionTypes_t	 subtypes;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} CompoundSha256Condition_t;
+
+/* Implementation */
+/* extern asn_TYPE_descriptor_t asn_DEF_cost_3;	// (Use -fall-defs-global to expose) */
+extern asn_TYPE_descriptor_t asn_DEF_CompoundSha256Condition;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _CompoundSha256Condition_H_ */
+#include <asn_internal.h>
--- a/src/cryptoconditions/src/asn/Condition.c
+++ b/src/cryptoconditions/src/asn/Condition.c
@@ -0,0 +1,114 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "Crypto-Conditions"
+ * 	found in "CryptoConditions.asn"
+ */
+
+#include "Condition.h"
+
+static asn_TYPE_member_t asn_MBR_Condition_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct Condition, choice.preimageSha256),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_SimpleSha256Condition,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"preimageSha256"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct Condition, choice.prefixSha256),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_CompoundSha256Condition,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"prefixSha256"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct Condition, choice.thresholdSha256),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_CompoundSha256Condition,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"thresholdSha256"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct Condition, choice.rsaSha256),
+		(ASN_TAG_CLASS_CONTEXT | (3 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_SimpleSha256Condition,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"rsaSha256"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct Condition, choice.ed25519Sha256),
+		(ASN_TAG_CLASS_CONTEXT | (4 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_SimpleSha256Condition,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"ed25519Sha256"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct Condition, choice.secp256k1Sha256),
+		(ASN_TAG_CLASS_CONTEXT | (5 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_SimpleSha256Condition,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"secp256k1Sha256"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct Condition, choice.evalSha256),
+		(ASN_TAG_CLASS_CONTEXT | (15 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_SimpleSha256Condition,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"evalSha256"
+		},
+};
+static const asn_TYPE_tag2member_t asn_MAP_Condition_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* preimageSha256 */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* prefixSha256 */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* thresholdSha256 */
+    { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 }, /* rsaSha256 */
+    { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 4, 0, 0 }, /* ed25519Sha256 */
+    { (ASN_TAG_CLASS_CONTEXT | (5 << 2)), 5, 0, 0 }, /* secp256k1Sha256 */
+    { (ASN_TAG_CLASS_CONTEXT | (15 << 2)), 6, 0, 0 } /* evalSha256 */
+};
+static asn_CHOICE_specifics_t asn_SPC_Condition_specs_1 = {
+	sizeof(struct Condition),
+	offsetof(struct Condition, _asn_ctx),
+	offsetof(struct Condition, present),
+	sizeof(((struct Condition *)0)->present),
+	asn_MAP_Condition_tag2el_1,
+	7,	/* Count of tags in the map */
+	0,
+	-1	/* Extensions start */
+};
+asn_TYPE_descriptor_t asn_DEF_Condition = {
+	"Condition",
+	"Condition",
+	CHOICE_free,
+	CHOICE_print,
+	CHOICE_constraint,
+	CHOICE_decode_ber,
+	CHOICE_encode_der,
+	CHOICE_decode_xer,
+	CHOICE_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	CHOICE_outmost_tag,
+	0,	/* No effective tags (pointer) */
+	0,	/* No effective tags (count) */
+	0,	/* No tags (pointer) */
+	0,	/* No tags (count) */
+	0,	/* No PER visible constraints */
+	asn_MBR_Condition_1,
+	7,	/* Elements count */
+	&asn_SPC_Condition_specs_1	/* Additional specs */
+};
+
--- a/src/cryptoconditions/src/asn/Condition.h
+++ b/src/cryptoconditions/src/asn/Condition.h
@@ -0,0 +1,59 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "Crypto-Conditions"
+ * 	found in "CryptoConditions.asn"
+ */
+
+#ifndef	_Condition_H_
+#define	_Condition_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "SimpleSha256Condition.h"
+#include "CompoundSha256Condition.h"
+#include <constr_CHOICE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum Condition_PR {
+	Condition_PR_NOTHING,	/* No components present */
+	Condition_PR_preimageSha256,
+	Condition_PR_prefixSha256,
+	Condition_PR_thresholdSha256,
+	Condition_PR_rsaSha256,
+	Condition_PR_ed25519Sha256,
+	Condition_PR_secp256k1Sha256,
+	Condition_PR_evalSha256
+} Condition_PR;
+
+/* Condition */
+typedef struct Condition {
+	Condition_PR present;
+	union Condition_u {
+		SimpleSha256Condition_t	 preimageSha256;
+		CompoundSha256Condition_t	 prefixSha256;
+		CompoundSha256Condition_t	 thresholdSha256;
+		SimpleSha256Condition_t	 rsaSha256;
+		SimpleSha256Condition_t	 ed25519Sha256;
+		SimpleSha256Condition_t	 secp256k1Sha256;
+		SimpleSha256Condition_t	 evalSha256;
+	} choice;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} Condition_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_Condition;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _Condition_H_ */
+#include <asn_internal.h>
--- a/src/cryptoconditions/src/asn/ConditionTypes.c
+++ b/src/cryptoconditions/src/asn/ConditionTypes.c
@@ -0,0 +1,108 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "Crypto-Conditions"
+ * 	found in "CryptoConditions.asn"
+ */
+
+#include "ConditionTypes.h"
+
+int
+ConditionTypes_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	/* Replace with underlying type checker */
+	td->check_constraints = asn_DEF_BIT_STRING.check_constraints;
+	return td->check_constraints(td, sptr, ctfailcb, app_key);
+}
+
+/*
+ * This type is implemented using BIT_STRING,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+ConditionTypes_1_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_BIT_STRING.free_struct;
+	td->print_struct   = asn_DEF_BIT_STRING.print_struct;
+	td->check_constraints = asn_DEF_BIT_STRING.check_constraints;
+	td->ber_decoder    = asn_DEF_BIT_STRING.ber_decoder;
+	td->der_encoder    = asn_DEF_BIT_STRING.der_encoder;
+	td->xer_decoder    = asn_DEF_BIT_STRING.xer_decoder;
+	td->xer_encoder    = asn_DEF_BIT_STRING.xer_encoder;
+	td->uper_decoder   = asn_DEF_BIT_STRING.uper_decoder;
+	td->uper_encoder   = asn_DEF_BIT_STRING.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_BIT_STRING.per_constraints;
+	td->elements       = asn_DEF_BIT_STRING.elements;
+	td->elements_count = asn_DEF_BIT_STRING.elements_count;
+	td->specifics      = asn_DEF_BIT_STRING.specifics;
+}
+
+void
+ConditionTypes_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	ConditionTypes_1_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+int
+ConditionTypes_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	ConditionTypes_1_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+asn_dec_rval_t
+ConditionTypes_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	ConditionTypes_1_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+asn_enc_rval_t
+ConditionTypes_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	ConditionTypes_1_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+asn_dec_rval_t
+ConditionTypes_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	ConditionTypes_1_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+asn_enc_rval_t
+ConditionTypes_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	ConditionTypes_1_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+static const ber_tlv_tag_t asn_DEF_ConditionTypes_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (3 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_ConditionTypes = {
+	"ConditionTypes",
+	"ConditionTypes",
+	ConditionTypes_free,
+	ConditionTypes_print,
+	ConditionTypes_constraint,
+	ConditionTypes_decode_ber,
+	ConditionTypes_encode_der,
+	ConditionTypes_decode_xer,
+	ConditionTypes_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_ConditionTypes_tags_1,
+	sizeof(asn_DEF_ConditionTypes_tags_1)
+		/sizeof(asn_DEF_ConditionTypes_tags_1[0]), /* 1 */
+	asn_DEF_ConditionTypes_tags_1,	/* Same as above */
+	sizeof(asn_DEF_ConditionTypes_tags_1)
+		/sizeof(asn_DEF_ConditionTypes_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* Defined elsewhere */
+	0	/* No specifics */
+};
+
--- a/src/cryptoconditions/src/asn/ConditionTypes.h
+++ b/src/cryptoconditions/src/asn/ConditionTypes.h
@@ -0,0 +1,49 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "Crypto-Conditions"
+ * 	found in "CryptoConditions.asn"
+ */
+
+#ifndef	_ConditionTypes_H_
+#define	_ConditionTypes_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <BIT_STRING.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum ConditionTypes {
+	ConditionTypes_preImageSha256	= 0,
+	ConditionTypes_prefixSha256	= 1,
+	ConditionTypes_thresholdSha256	= 2,
+	ConditionTypes_rsaSha256	= 3,
+	ConditionTypes_ed25519Sha256	= 4,
+	ConditionTypes_secp256k1Sha256	= 5,
+	ConditionTypes_evalSha256	= 15
+} e_ConditionTypes;
+
+/* ConditionTypes */
+typedef BIT_STRING_t	 ConditionTypes_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_ConditionTypes;
+asn_struct_free_f ConditionTypes_free;
+asn_struct_print_f ConditionTypes_print;
+asn_constr_check_f ConditionTypes_constraint;
+ber_type_decoder_f ConditionTypes_decode_ber;
+der_type_encoder_f ConditionTypes_encode_der;
+xer_type_decoder_f ConditionTypes_decode_xer;
+xer_type_encoder_f ConditionTypes_encode_xer;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _ConditionTypes_H_ */
+#include <asn_internal.h>
--- a/src/cryptoconditions/src/asn/CryptoConditions.asn
+++ b/src/cryptoconditions/src/asn/CryptoConditions.asn
@@ -0,0 +1,113 @@
+--<ASN1.PDU Crypto-Conditions.Condition, Crypto-Conditions.Fulfillment>--
+
+Crypto-Conditions DEFINITIONS AUTOMATIC TAGS ::= BEGIN
+
+    -- Conditions
+
+    Condition ::= CHOICE {
+      preimageSha256   [0] SimpleSha256Condition,
+      prefixSha256     [1] CompoundSha256Condition,
+      thresholdSha256  [2] CompoundSha256Condition,
+      rsaSha256        [3] SimpleSha256Condition,
+      ed25519Sha256    [4] SimpleSha256Condition,
+      secp256k1Sha256  [5] SimpleSha256Condition,
+      evalSha256       [15] SimpleSha256Condition
+    }
+
+    SimpleSha256Condition ::= SEQUENCE {
+      fingerprint          OCTET STRING (SIZE(32)),
+      cost                 INTEGER (0..4294967295)
+    }
+
+    CompoundSha256Condition ::= SEQUENCE {
+      fingerprint          OCTET STRING (SIZE(32)),
+      cost                 INTEGER (0..4294967295),
+      subtypes             ConditionTypes
+    }
+
+    ConditionTypes ::= BIT STRING {
+      preImageSha256   (0),
+      prefixSha256     (1),
+      thresholdSha256  (2),
+      rsaSha256        (3),
+      ed25519Sha256    (4),
+      secp256k1Sha256  (5),
+      evalSha256       (15)
+    }
+    
+    -- Fulfillments
+
+    Fulfillment ::= CHOICE {
+      preimageSha256   [0] PreimageFulfillment ,
+      prefixSha256     [1] PrefixFulfillment,
+      thresholdSha256  [2] ThresholdFulfillment,
+      rsaSha256        [3] RsaSha256Fulfillment,
+      ed25519Sha256    [4] Ed25519Sha512Fulfillment,
+      secp256k1Sha256  [5] Secp256k1Fulfillment,
+      evalSha256       [15] EvalFulfillment
+    }
+
+    PreimageFulfillment ::= SEQUENCE {
+      preimage             OCTET STRING
+    }
+
+    PrefixFulfillment ::= SEQUENCE {
+      prefix               OCTET STRING,
+      maxMessageLength     INTEGER (0..4294967295),
+      subfulfillment       Fulfillment
+    }
+
+    ThresholdFulfillment ::= SEQUENCE {
+      subfulfillments      SET OF Fulfillment,
+      subconditions        SET OF Condition
+    }
+
+    RsaSha256Fulfillment ::= SEQUENCE {
+      modulus              OCTET STRING,
+      signature            OCTET STRING
+    }
+
+    Ed25519Sha512Fulfillment ::= SEQUENCE {
+      publicKey            OCTET STRING (SIZE(32)),
+      signature            OCTET STRING (SIZE(64))
+    }
+
+    Secp256k1Fulfillment ::= SEQUENCE {
+      publicKey            OCTET STRING (SIZE(33)),
+      signature            OCTET STRING (SIZE(64))
+    }
+
+    EvalFulfillment ::= SEQUENCE {
+      code                 OCTET STRING
+    }
+
+    -- Fingerprint Content
+
+    -- The PREIMAGE-SHA-256 condition fingerprint content is not DER encoded
+    -- The fingerprint content is the preimage
+    -- Same for Eval
+
+    PrefixFingerprintContents ::= SEQUENCE {
+      prefix               OCTET STRING,
+      maxMessageLength     INTEGER (0..4294967295),
+      subcondition         Condition
+    }
+
+    ThresholdFingerprintContents ::= SEQUENCE {
+      threshold            INTEGER (1..65535),
+      subconditions2       SET OF Condition
+    }
+    
+    RsaFingerprintContents ::= SEQUENCE {
+      modulus              OCTET STRING
+    }
+    
+    Ed25519FingerprintContents ::= SEQUENCE {
+      publicKey            OCTET STRING (SIZE(32))
+    }
+
+    Secp256k1FingerprintContents ::= SEQUENCE {
+      publicKey            OCTET STRING (SIZE(33))
+    }
+
+END
--- a/src/cryptoconditions/src/asn/Ed25519FingerprintContents.c
+++ b/src/cryptoconditions/src/asn/Ed25519FingerprintContents.c
@@ -0,0 +1,84 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "Crypto-Conditions"
+ * 	found in "CryptoConditions.asn"
+ */
+
+#include "Ed25519FingerprintContents.h"
+
+static int
+memb_publicKey_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	size = st->size;
+	
+	if((size == 32)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static asn_TYPE_member_t asn_MBR_Ed25519FingerprintContents_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct Ed25519FingerprintContents, publicKey),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_OCTET_STRING,
+		memb_publicKey_constraint_1,
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"publicKey"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_Ed25519FingerprintContents_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_Ed25519FingerprintContents_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* publicKey */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_Ed25519FingerprintContents_specs_1 = {
+	sizeof(struct Ed25519FingerprintContents),
+	offsetof(struct Ed25519FingerprintContents, _asn_ctx),
+	asn_MAP_Ed25519FingerprintContents_tag2el_1,
+	1,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	-1,	/* Start extensions */
+	-1	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_Ed25519FingerprintContents = {
+	"Ed25519FingerprintContents",
+	"Ed25519FingerprintContents",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_Ed25519FingerprintContents_tags_1,
+	sizeof(asn_DEF_Ed25519FingerprintContents_tags_1)
+		/sizeof(asn_DEF_Ed25519FingerprintContents_tags_1[0]), /* 1 */
+	asn_DEF_Ed25519FingerprintContents_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Ed25519FingerprintContents_tags_1)
+		/sizeof(asn_DEF_Ed25519FingerprintContents_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_Ed25519FingerprintContents_1,
+	1,	/* Elements count */
+	&asn_SPC_Ed25519FingerprintContents_specs_1	/* Additional specs */
+};
+
--- a/src/cryptoconditions/src/asn/Ed25519FingerprintContents.h
+++ b/src/cryptoconditions/src/asn/Ed25519FingerprintContents.h
@@ -0,0 +1,37 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "Crypto-Conditions"
+ * 	found in "CryptoConditions.asn"
+ */
+
+#ifndef	_Ed25519FingerprintContents_H_
+#define	_Ed25519FingerprintContents_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <OCTET_STRING.h>
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Ed25519FingerprintContents */
+typedef struct Ed25519FingerprintContents {
+	OCTET_STRING_t	 publicKey;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} Ed25519FingerprintContents_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_Ed25519FingerprintContents;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _Ed25519FingerprintContents_H_ */
+#include <asn_internal.h>
--- a/src/cryptoconditions/src/asn/Ed25519Sha512Fulfillment.c
+++ b/src/cryptoconditions/src/asn/Ed25519Sha512Fulfillment.c
@@ -0,0 +1,120 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "Crypto-Conditions"
+ * 	found in "CryptoConditions.asn"
+ */
+
+#include "Ed25519Sha512Fulfillment.h"
+
+static int
+memb_publicKey_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	size = st->size;
+	
+	if((size == 32)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static int
+memb_signature_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	const OCTET_STRING_t *st = (const OCTET_STRING_t *)sptr;
+	size_t size;
+	
+	if(!sptr) {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	size = st->size;
+	
+	if((size == 64)) {
+		/* Constraint check succeeded */
+		return 0;
+	} else {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: constraint failed (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+}
+
+static asn_TYPE_member_t asn_MBR_Ed25519Sha512Fulfillment_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct Ed25519Sha512Fulfillment, publicKey),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_OCTET_STRING,
+		memb_publicKey_constraint_1,
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"publicKey"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct Ed25519Sha512Fulfillment, signature),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_OCTET_STRING,
+		memb_signature_constraint_1,
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"signature"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_Ed25519Sha512Fulfillment_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_Ed25519Sha512Fulfillment_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* publicKey */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* signature */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_Ed25519Sha512Fulfillment_specs_1 = {
+	sizeof(struct Ed25519Sha512Fulfillment),
+	offsetof(struct Ed25519Sha512Fulfillment, _asn_ctx),
+	asn_MAP_Ed25519Sha512Fulfillment_tag2el_1,
+	2,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	-1,	/* Start extensions */
+	-1	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_Ed25519Sha512Fulfillment = {
+	"Ed25519Sha512Fulfillment",
+	"Ed25519Sha512Fulfillment",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_Ed25519Sha512Fulfillment_tags_1,
+	sizeof(asn_DEF_Ed25519Sha512Fulfillment_tags_1)
+		/sizeof(asn_DEF_Ed25519Sha512Fulfillment_tags_1[0]), /* 1 */
+	asn_DEF_Ed25519Sha512Fulfillment_tags_1,	/* Same as above */
+	sizeof(asn_DEF_Ed25519Sha512Fulfillment_tags_1)
+		/sizeof(asn_DEF_Ed25519Sha512Fulfillment_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_Ed25519Sha512Fulfillment_1,
+	2,	/* Elements count */
+	&asn_SPC_Ed25519Sha512Fulfillment_specs_1	/* Additional specs */
+};
+
--- a/src/cryptoconditions/src/asn/Ed25519Sha512Fulfillment.h
+++ b/src/cryptoconditions/src/asn/Ed25519Sha512Fulfillment.h
@@ -0,0 +1,38 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "Crypto-Conditions"
+ * 	found in "CryptoConditions.asn"
+ */
+
+#ifndef	_Ed25519Sha512Fulfillment_H_
+#define	_Ed25519Sha512Fulfillment_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <OCTET_STRING.h>
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Ed25519Sha512Fulfillment */
+typedef struct Ed25519Sha512Fulfillment {
+	OCTET_STRING_t	 publicKey;
+	OCTET_STRING_t	 signature;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} Ed25519Sha512Fulfillment_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_Ed25519Sha512Fulfillment;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _Ed25519Sha512Fulfillment_H_ */
+#include <asn_internal.h>
--- a/src/cryptoconditions/src/asn/EvalFulfillment.c
+++ b/src/cryptoconditions/src/asn/EvalFulfillment.c
@@ -0,0 +1,58 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "Crypto-Conditions"
+ * 	found in "CryptoConditions.asn"
+ */
+
+#include "EvalFulfillment.h"
+
+static asn_TYPE_member_t asn_MBR_EvalFulfillment_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct EvalFulfillment, code),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_OCTET_STRING,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"code"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_EvalFulfillment_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_EvalFulfillment_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* code */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_EvalFulfillment_specs_1 = {
+	sizeof(struct EvalFulfillment),
+	offsetof(struct EvalFulfillment, _asn_ctx),
+	asn_MAP_EvalFulfillment_tag2el_1,
+	1,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	-1,	/* Start extensions */
+	-1	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_EvalFulfillment = {
+	"EvalFulfillment",
+	"EvalFulfillment",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_EvalFulfillment_tags_1,
+	sizeof(asn_DEF_EvalFulfillment_tags_1)
+		/sizeof(asn_DEF_EvalFulfillment_tags_1[0]), /* 1 */
+	asn_DEF_EvalFulfillment_tags_1,	/* Same as above */
+	sizeof(asn_DEF_EvalFulfillment_tags_1)
+		/sizeof(asn_DEF_EvalFulfillment_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_EvalFulfillment_1,
+	1,	/* Elements count */
+	&asn_SPC_EvalFulfillment_specs_1	/* Additional specs */
+};
+
--- a/src/cryptoconditions/src/asn/EvalFulfillment.h
+++ b/src/cryptoconditions/src/asn/EvalFulfillment.h
@@ -0,0 +1,37 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "Crypto-Conditions"
+ * 	found in "CryptoConditions.asn"
+ */
+
+#ifndef	_EvalFulfillment_H_
+#define	_EvalFulfillment_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <OCTET_STRING.h>
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* EvalFulfillment */
+typedef struct EvalFulfillment {
+	OCTET_STRING_t	 code;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} EvalFulfillment_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_EvalFulfillment;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _EvalFulfillment_H_ */
+#include <asn_internal.h>
--- a/src/cryptoconditions/src/asn/Fulfillment.c
+++ b/src/cryptoconditions/src/asn/Fulfillment.c
@@ -0,0 +1,114 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "Crypto-Conditions"
+ * 	found in "CryptoConditions.asn"
+ */
+
+#include "Fulfillment.h"
+
+static asn_TYPE_member_t asn_MBR_Fulfillment_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct Fulfillment, choice.preimageSha256),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_PreimageFulfillment,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"preimageSha256"
+		},
+	{ ATF_POINTER, 0, offsetof(struct Fulfillment, choice.prefixSha256),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_PrefixFulfillment,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"prefixSha256"
+		},
+	{ ATF_POINTER, 0, offsetof(struct Fulfillment, choice.thresholdSha256),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_ThresholdFulfillment,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"thresholdSha256"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct Fulfillment, choice.rsaSha256),
+		(ASN_TAG_CLASS_CONTEXT | (3 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_RsaSha256Fulfillment,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"rsaSha256"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct Fulfillment, choice.ed25519Sha256),
+		(ASN_TAG_CLASS_CONTEXT | (4 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_Ed25519Sha512Fulfillment,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"ed25519Sha256"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct Fulfillment, choice.secp256k1Sha256),
+		(ASN_TAG_CLASS_CONTEXT | (5 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_Secp256k1Fulfillment,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"secp256k1Sha256"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct Fulfillment, choice.evalSha256),
+		(ASN_TAG_CLASS_CONTEXT | (15 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_EvalFulfillment,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"evalSha256"
+		},
+};
+static const asn_TYPE_tag2member_t asn_MAP_Fulfillment_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* preimageSha256 */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* prefixSha256 */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 }, /* thresholdSha256 */
+    { (ASN_TAG_CLASS_CONTEXT | (3 << 2)), 3, 0, 0 }, /* rsaSha256 */
+    { (ASN_TAG_CLASS_CONTEXT | (4 << 2)), 4, 0, 0 }, /* ed25519Sha256 */
+    { (ASN_TAG_CLASS_CONTEXT | (5 << 2)), 5, 0, 0 }, /* secp256k1Sha256 */
+    { (ASN_TAG_CLASS_CONTEXT | (15 << 2)), 6, 0, 0 } /* evalSha256 */
+};
+static asn_CHOICE_specifics_t asn_SPC_Fulfillment_specs_1 = {
+	sizeof(struct Fulfillment),
+	offsetof(struct Fulfillment, _asn_ctx),
+	offsetof(struct Fulfillment, present),
+	sizeof(((struct Fulfillment *)0)->present),
+	asn_MAP_Fulfillment_tag2el_1,
+	7,	/* Count of tags in the map */
+	0,
+	-1	/* Extensions start */
+};
+asn_TYPE_descriptor_t asn_DEF_Fulfillment = {
+	"Fulfillment",
+	"Fulfillment",
+	CHOICE_free,
+	CHOICE_print,
+	CHOICE_constraint,
+	CHOICE_decode_ber,
+	CHOICE_encode_der,
+	CHOICE_decode_xer,
+	CHOICE_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	CHOICE_outmost_tag,
+	0,	/* No effective tags (pointer) */
+	0,	/* No effective tags (count) */
+	0,	/* No tags (pointer) */
+	0,	/* No tags (count) */
+	0,	/* No PER visible constraints */
+	asn_MBR_Fulfillment_1,
+	7,	/* Elements count */
+	&asn_SPC_Fulfillment_specs_1	/* Additional specs */
+};
+
--- a/src/cryptoconditions/src/asn/Fulfillment.h
+++ b/src/cryptoconditions/src/asn/Fulfillment.h
@@ -0,0 +1,70 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "Crypto-Conditions"
+ * 	found in "CryptoConditions.asn"
+ */
+
+#ifndef	_Fulfillment_H_
+#define	_Fulfillment_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include "PreimageFulfillment.h"
+#include "RsaSha256Fulfillment.h"
+#include "Ed25519Sha512Fulfillment.h"
+#include "Secp256k1Fulfillment.h"
+#include "EvalFulfillment.h"
+#include <constr_CHOICE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Dependencies */
+typedef enum Fulfillment_PR {
+	Fulfillment_PR_NOTHING,	/* No components present */
+	Fulfillment_PR_preimageSha256,
+	Fulfillment_PR_prefixSha256,
+	Fulfillment_PR_thresholdSha256,
+	Fulfillment_PR_rsaSha256,
+	Fulfillment_PR_ed25519Sha256,
+	Fulfillment_PR_secp256k1Sha256,
+	Fulfillment_PR_evalSha256
+} Fulfillment_PR;
+
+/* Forward declarations */
+struct PrefixFulfillment;
+struct ThresholdFulfillment;
+
+/* Fulfillment */
+typedef struct Fulfillment {
+	Fulfillment_PR present;
+	union Fulfillment_u {
+		PreimageFulfillment_t	 preimageSha256;
+		struct PrefixFulfillment	*prefixSha256;
+		struct ThresholdFulfillment	*thresholdSha256;
+		RsaSha256Fulfillment_t	 rsaSha256;
+		Ed25519Sha512Fulfillment_t	 ed25519Sha256;
+		Secp256k1Fulfillment_t	 secp256k1Sha256;
+		EvalFulfillment_t	 evalSha256;
+	} choice;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} Fulfillment_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_Fulfillment;
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Referred external types */
+#include "PrefixFulfillment.h"
+#include "ThresholdFulfillment.h"
+
+#endif	/* _Fulfillment_H_ */
+#include <asn_internal.h>
--- a/src/cryptoconditions/src/asn/INTEGER.c
+++ b/src/cryptoconditions/src/asn/INTEGER.c
--- a/src/cryptoconditions/src/asn/INTEGER.h
+++ b/src/cryptoconditions/src/asn/INTEGER.h
@@ -0,0 +1,82 @@
+/*-
+ * Copyright (c) 2003, 2005 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#ifndef	_INTEGER_H_
+#define	_INTEGER_H_
+
+#include <asn_application.h>
+#include <asn_codecs_prim.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef ASN__PRIMITIVE_TYPE_t INTEGER_t;
+
+extern asn_TYPE_descriptor_t asn_DEF_INTEGER;
+
+/* Map with <tag> to integer value association */
+typedef struct asn_INTEGER_enum_map_s {
+	long		 nat_value;	/* associated native integer value */
+	size_t		 enum_len;	/* strlen("tag") */
+	const char	*enum_name;	/* "tag" */
+} asn_INTEGER_enum_map_t;
+
+/* This type describes an enumeration for INTEGER and ENUMERATED types */
+typedef const struct asn_INTEGER_specifics_s {
+	const asn_INTEGER_enum_map_t *value2enum;	/* N -> "tag"; sorted by N */
+	const unsigned int *enum2value;		/* "tag" => N; sorted by tag */
+	int map_count;				/* Elements in either map */
+	int extension;				/* This map is extensible */
+	int strict_enumeration;			/* Enumeration set is fixed */
+	int field_width;			/* Size of native integer */
+	int field_unsigned;			/* Signed=0, unsigned=1 */
+} asn_INTEGER_specifics_t;
+
+asn_struct_print_f INTEGER_print;
+ber_type_decoder_f INTEGER_decode_ber;
+der_type_encoder_f INTEGER_encode_der;
+xer_type_decoder_f INTEGER_decode_xer;
+xer_type_encoder_f INTEGER_encode_xer;
+per_type_decoder_f INTEGER_decode_uper;
+per_type_encoder_f INTEGER_encode_uper;
+
+/***********************************
+ * Some handy conversion routines. *
+ ***********************************/
+
+/*
+ * Returns 0 if it was possible to convert, -1 otherwise.
+ * -1/EINVAL: Mandatory argument missing
+ * -1/ERANGE: Value encoded is out of range for long representation
+ * -1/ENOMEM: Memory allocation failed (in asn_long2INTEGER()).
+ */
+int asn_INTEGER2long(const INTEGER_t *i, long *l);
+int asn_INTEGER2ulong(const INTEGER_t *i, unsigned long *l);
+int asn_long2INTEGER(INTEGER_t *i, long l);
+int asn_ulong2INTEGER(INTEGER_t *i, unsigned long l);
+
+/* A a reified version of strtol(3) with nicer error reporting. */
+enum asn_strtol_result_e {
+    ASN_STRTOL_ERROR_RANGE = -3,  /* Input outside of numeric range for long type */
+    ASN_STRTOL_ERROR_INVAL = -2,  /* Invalid data encountered (e.g., "+-") */
+    ASN_STRTOL_EXPECT_MORE = -1,  /* More data expected (e.g. "+") */
+    ASN_STRTOL_OK          =  0,  /* Conversion succeded, number ends at (*end) */
+    ASN_STRTOL_EXTRA_DATA  =  1   /* Conversion succeded, but the string has extra stuff */
+};
+enum asn_strtol_result_e asn_strtol_lim(const char *str, const char **end, long *l);
+
+/* The asn_strtol is going to be DEPRECATED soon */
+enum asn_strtol_result_e asn_strtol(const char *str, const char *end, long *l);
+
+/*
+ * Convert the integer value into the corresponding enumeration map entry.
+ */
+const asn_INTEGER_enum_map_t *INTEGER_map_value2enum(asn_INTEGER_specifics_t *specs, long value);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _INTEGER_H_ */
--- a/src/cryptoconditions/src/asn/Makefile.am.sample
+++ b/src/cryptoconditions/src/asn/Makefile.am.sample
@@ -0,0 +1,120 @@
+ASN_MODULE_SOURCES=	\
+	Condition.c	\
+	SimpleSha256Condition.c	\
+	CompoundSha256Condition.c	\
+	ConditionTypes.c	\
+	Fulfillment.c	\
+	PreimageFulfillment.c	\
+	PrefixFulfillment.c	\
+	ThresholdFulfillment.c	\
+	RsaSha256Fulfillment.c	\
+	Ed25519Sha512Fulfillment.c	\
+	Secp256k1Fulfillment.c	\
+	EvalFulfillment.c	\
+	PrefixFingerprintContents.c	\
+	ThresholdFingerprintContents.c	\
+	RsaFingerprintContents.c	\
+	Ed25519FingerprintContents.c	\
+	Secp256k1FingerprintContents.c
+
+ASN_MODULE_HEADERS=	\
+	Condition.h	\
+	SimpleSha256Condition.h	\
+	CompoundSha256Condition.h	\
+	ConditionTypes.h	\
+	Fulfillment.h	\
+	PreimageFulfillment.h	\
+	PrefixFulfillment.h	\
+	ThresholdFulfillment.h	\
+	RsaSha256Fulfillment.h	\
+	Ed25519Sha512Fulfillment.h	\
+	Secp256k1Fulfillment.h	\
+	EvalFulfillment.h	\
+	PrefixFingerprintContents.h	\
+	ThresholdFingerprintContents.h	\
+	RsaFingerprintContents.h	\
+	Ed25519FingerprintContents.h	\
+	Secp256k1FingerprintContents.h
+
+ASN_MODULE_HEADERS+=INTEGER.h
+ASN_MODULE_HEADERS+=NativeEnumerated.h
+ASN_MODULE_SOURCES+=INTEGER.c
+ASN_MODULE_SOURCES+=NativeEnumerated.c
+ASN_MODULE_HEADERS+=NativeInteger.h
+ASN_MODULE_SOURCES+=NativeInteger.c
+ASN_MODULE_HEADERS+=asn_SET_OF.h
+ASN_MODULE_SOURCES+=asn_SET_OF.c
+ASN_MODULE_HEADERS+=constr_CHOICE.h
+ASN_MODULE_SOURCES+=constr_CHOICE.c
+ASN_MODULE_HEADERS+=constr_SEQUENCE.h
+ASN_MODULE_SOURCES+=constr_SEQUENCE.c
+ASN_MODULE_HEADERS+=constr_SET_OF.h
+ASN_MODULE_SOURCES+=constr_SET_OF.c
+ASN_MODULE_HEADERS+=asn_application.h
+ASN_MODULE_HEADERS+=asn_system.h
+ASN_MODULE_HEADERS+=asn_codecs.h
+ASN_MODULE_HEADERS+=asn_internal.h
+ASN_MODULE_HEADERS+=OCTET_STRING.h
+ASN_MODULE_SOURCES+=OCTET_STRING.c
+ASN_MODULE_HEADERS+=BIT_STRING.h
+ASN_MODULE_SOURCES+=BIT_STRING.c
+ASN_MODULE_SOURCES+=asn_codecs_prim.c
+ASN_MODULE_HEADERS+=asn_codecs_prim.h
+ASN_MODULE_HEADERS+=ber_tlv_length.h
+ASN_MODULE_SOURCES+=ber_tlv_length.c
+ASN_MODULE_HEADERS+=ber_tlv_tag.h
+ASN_MODULE_SOURCES+=ber_tlv_tag.c
+ASN_MODULE_HEADERS+=ber_decoder.h
+ASN_MODULE_SOURCES+=ber_decoder.c
+ASN_MODULE_HEADERS+=der_encoder.h
+ASN_MODULE_SOURCES+=der_encoder.c
+ASN_MODULE_HEADERS+=constr_TYPE.h
+ASN_MODULE_SOURCES+=constr_TYPE.c
+ASN_MODULE_HEADERS+=constraints.h
+ASN_MODULE_SOURCES+=constraints.c
+ASN_MODULE_HEADERS+=xer_support.h
+ASN_MODULE_SOURCES+=xer_support.c
+ASN_MODULE_HEADERS+=xer_decoder.h
+ASN_MODULE_SOURCES+=xer_decoder.c
+ASN_MODULE_HEADERS+=xer_encoder.h
+ASN_MODULE_SOURCES+=xer_encoder.c
+ASN_MODULE_HEADERS+=per_support.h
+ASN_MODULE_SOURCES+=per_support.c
+ASN_MODULE_HEADERS+=per_decoder.h
+ASN_MODULE_SOURCES+=per_decoder.c
+ASN_MODULE_HEADERS+=per_encoder.h
+ASN_MODULE_SOURCES+=per_encoder.c
+ASN_MODULE_HEADERS+=per_opentype.h
+ASN_MODULE_SOURCES+=per_opentype.c
+ASN_CONVERTER_SOURCES+=converter-sample.c
+
+
+lib_LTLIBRARIES=libsomething.la
+libsomething_la_SOURCES=$(ASN_MODULE_SOURCES) $(ASN_MODULE_HEADERS)
+
+# This file may be used as an input for make(3)
+# Remove the lines below to convert it into a pure .am file
+TARGET = progname
+CFLAGS += -I.
+OBJS=${ASN_MODULE_SOURCES:.c=.o} ${ASN_CONVERTER_SOURCES:.c=.o}
+
+all: $(TARGET)
+
+$(TARGET): ${OBJS}
+	$(CC) $(CFLAGS) -o $(TARGET) ${OBJS} $(LDFLAGS) $(LIBS)
+
+.SUFFIXES:
+.SUFFIXES: .c .o
+
+.c.o:
+	$(CC) $(CFLAGS) -o $@ -c $<
+
+clean:
+	rm -f $(TARGET)
+	rm -f $(OBJS)
+
+regen: regenerate-from-asn1-source
+
+regenerate-from-asn1-source:
+	asn1c CryptoConditions.asn
+
--- a/src/cryptoconditions/src/asn/NativeEnumerated.c
+++ b/src/cryptoconditions/src/asn/NativeEnumerated.c
@@ -0,0 +1,207 @@
+/*-
+ * Copyright (c) 2004, 2007 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+/*
+ * Read the NativeInteger.h for the explanation wrt. differences between
+ * INTEGER and NativeInteger.
+ * Basically, both are decoders and encoders of ASN.1 INTEGER type, but this
+ * implementation deals with the standard (machine-specific) representation
+ * of them instead of using the platform-independent buffer.
+ */
+#include <asn_internal.h>
+#include <NativeEnumerated.h>
+
+/*
+ * NativeEnumerated basic type description.
+ */
+static const ber_tlv_tag_t asn_DEF_NativeEnumerated_tags[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (10 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_NativeEnumerated = {
+	"ENUMERATED",			/* The ASN.1 type is still ENUMERATED */
+	"ENUMERATED",
+	NativeInteger_free,
+	NativeInteger_print,
+	asn_generic_no_constraint,
+	NativeInteger_decode_ber,
+	NativeInteger_encode_der,
+	NativeInteger_decode_xer,
+	NativeEnumerated_encode_xer,
+	NativeEnumerated_decode_uper,
+	NativeEnumerated_encode_uper,
+	0, /* Use generic outmost tag fetcher */
+	asn_DEF_NativeEnumerated_tags,
+	sizeof(asn_DEF_NativeEnumerated_tags) / sizeof(asn_DEF_NativeEnumerated_tags[0]),
+	asn_DEF_NativeEnumerated_tags,	/* Same as above */
+	sizeof(asn_DEF_NativeEnumerated_tags) / sizeof(asn_DEF_NativeEnumerated_tags[0]),
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
+asn_enc_rval_t
+NativeEnumerated_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
+        int ilevel, enum xer_encoder_flags_e flags,
+                asn_app_consume_bytes_f *cb, void *app_key) {
+	asn_INTEGER_specifics_t *specs=(asn_INTEGER_specifics_t *)td->specifics;
+        asn_enc_rval_t er;
+        const long *native = (const long *)sptr;
+	const asn_INTEGER_enum_map_t *el;
+
+        (void)ilevel;
+        (void)flags;
+
+        if(!native) ASN__ENCODE_FAILED;
+
+	el = INTEGER_map_value2enum(specs, *native);
+	if(el) {
+		size_t srcsize = el->enum_len + 5;
+		char *src = (char *)alloca(srcsize);
+
+		er.encoded = snprintf(src, srcsize, "<%s/>", el->enum_name);
+		assert(er.encoded > 0 && (size_t)er.encoded < srcsize);
+		if(cb(src, er.encoded, app_key) < 0) ASN__ENCODE_FAILED;
+		ASN__ENCODED_OK(er);
+	} else {
+		ASN_DEBUG("ASN.1 forbids dealing with "
+			"unknown value of ENUMERATED type");
+		ASN__ENCODE_FAILED;
+	}
+}
+
+asn_dec_rval_t
+NativeEnumerated_decode_uper(asn_codec_ctx_t *opt_codec_ctx,
+	asn_TYPE_descriptor_t *td, asn_per_constraints_t *constraints,
+	void **sptr, asn_per_data_t *pd) {
+	asn_INTEGER_specifics_t *specs = (asn_INTEGER_specifics_t *)td->specifics;
+	asn_dec_rval_t rval = { RC_OK, 0 };
+	long *native = (long *)*sptr;
+	asn_per_constraint_t *ct;
+	long value;
+
+	(void)opt_codec_ctx;
+
+	if(constraints) ct = &constraints->value;
+	else if(td->per_constraints) ct = &td->per_constraints->value;
+	else ASN__DECODE_FAILED;	/* Mandatory! */
+	if(!specs) ASN__DECODE_FAILED;
+
+	if(!native) {
+		native = (long *)(*sptr = CALLOC(1, sizeof(*native)));
+		if(!native) ASN__DECODE_FAILED;
+	}
+
+	ASN_DEBUG("Decoding %s as NativeEnumerated", td->name);
+
+	if(ct->flags & APC_EXTENSIBLE) {
+		int inext = per_get_few_bits(pd, 1);
+		if(inext < 0) ASN__DECODE_STARVED;
+		if(inext) ct = 0;
+	}
+
+	if(ct && ct->range_bits >= 0) {
+		value = per_get_few_bits(pd, ct->range_bits);
+		if(value < 0) ASN__DECODE_STARVED;
+		if(value >= (specs->extension
+			? specs->extension - 1 : specs->map_count))
+			ASN__DECODE_FAILED;
+	} else {
+		if(!specs->extension)
+			ASN__DECODE_FAILED;
+		/*
+		 * X.691, #10.6: normally small non-negative whole number;
+		 */
+		value = uper_get_nsnnwn(pd);
+		if(value < 0) ASN__DECODE_STARVED;
+		value += specs->extension - 1;
+		if(value >= specs->map_count)
+			ASN__DECODE_FAILED;
+	}
+
+	*native = specs->value2enum[value].nat_value;
+	ASN_DEBUG("Decoded %s = %ld", td->name, *native);
+
+	return rval;
+}
+
+static int
+NativeEnumerated__compar_value2enum(const void *ap, const void *bp) {
+	const asn_INTEGER_enum_map_t *a = ap;
+	const asn_INTEGER_enum_map_t *b = bp;
+	if(a->nat_value == b->nat_value)
+		return 0;
+	if(a->nat_value < b->nat_value)
+		return -1;
+	return 1;
+}
+
+asn_enc_rval_t
+NativeEnumerated_encode_uper(asn_TYPE_descriptor_t *td,
+	asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po) {
+	asn_INTEGER_specifics_t *specs = (asn_INTEGER_specifics_t *)td->specifics;
+	asn_enc_rval_t er;
+	long native, value;
+	asn_per_constraint_t *ct;
+	int inext = 0;
+	asn_INTEGER_enum_map_t key;
+	const asn_INTEGER_enum_map_t *kf;
+
+	if(!sptr) ASN__ENCODE_FAILED;
+	if(!specs) ASN__ENCODE_FAILED;
+
+	if(constraints) ct = &constraints->value;
+	else if(td->per_constraints) ct = &td->per_constraints->value;
+	else ASN__ENCODE_FAILED;	/* Mandatory! */
+
+	ASN_DEBUG("Encoding %s as NativeEnumerated", td->name);
+
+	er.encoded = 0;
+
+	native = *(long *)sptr;
+	if(native < 0) ASN__ENCODE_FAILED;
+
+	key.nat_value = native;
+	kf = bsearch(&key, specs->value2enum, specs->map_count,
+		sizeof(key), NativeEnumerated__compar_value2enum);
+	if(!kf) {
+		ASN_DEBUG("No element corresponds to %ld", native);
+		ASN__ENCODE_FAILED;
+	}
+	value = kf - specs->value2enum;
+
+	if(ct->range_bits >= 0) {
+		int cmpWith = specs->extension
+				? specs->extension - 1 : specs->map_count;
+		if(value >= cmpWith)
+			inext = 1;
+	}
+	if(ct->flags & APC_EXTENSIBLE) {
+		if(per_put_few_bits(po, inext, 1))
+			ASN__ENCODE_FAILED;
+		if(inext) ct = 0;
+	} else if(inext) {
+		ASN__ENCODE_FAILED;
+	}
+
+	if(ct && ct->range_bits >= 0) {
+		if(per_put_few_bits(po, value, ct->range_bits))
+			ASN__ENCODE_FAILED;
+		ASN__ENCODED_OK(er);
+	}
+
+	if(!specs->extension)
+		ASN__ENCODE_FAILED;
+
+	/*
+	 * X.691, #10.6: normally small non-negative whole number;
+	 */
+	ASN_DEBUG("value = %ld, ext = %d, inext = %d, res = %ld",
+		value, specs->extension, inext,
+		value - (inext ? (specs->extension - 1) : 0));
+	if(uper_put_nsnnwn(po, value - (inext ? (specs->extension - 1) : 0)))
+		ASN__ENCODE_FAILED;
+
+	ASN__ENCODED_OK(er);
+}
+
--- a/src/cryptoconditions/src/asn/NativeEnumerated.h
+++ b/src/cryptoconditions/src/asn/NativeEnumerated.h
@@ -0,0 +1,32 @@
+/*-
+ * Copyright (c) 2004, 2005, 2006 Lev Walkin <vlm@lionet.info>.
+ * All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+/*
+ * This type differs from the standard ENUMERATED in that it is modelled using
+ * the fixed machine type (long, int, short), so it can hold only values of
+ * limited length. There is no type (i.e., NativeEnumerated_t, any integer type
+ * will do).
+ * This type may be used when integer range is limited by subtype constraints.
+ */
+#ifndef	_NativeEnumerated_H_
+#define	_NativeEnumerated_H_
+
+#include <NativeInteger.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern asn_TYPE_descriptor_t asn_DEF_NativeEnumerated;
+
+xer_type_encoder_f NativeEnumerated_encode_xer;
+per_type_decoder_f NativeEnumerated_decode_uper;
+per_type_encoder_f NativeEnumerated_encode_uper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _NativeEnumerated_H_ */
--- a/src/cryptoconditions/src/asn/NativeInteger.c
+++ b/src/cryptoconditions/src/asn/NativeInteger.c
@@ -0,0 +1,332 @@
+/*-
+ * Copyright (c) 2004, 2005, 2006 Lev Walkin <vlm@lionet.info>.
+ * All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+/*
+ * Read the NativeInteger.h for the explanation wrt. differences between
+ * INTEGER and NativeInteger.
+ * Basically, both are decoders and encoders of ASN.1 INTEGER type, but this
+ * implementation deals with the standard (machine-specific) representation
+ * of them instead of using the platform-independent buffer.
+ */
+#include <asn_internal.h>
+#include <NativeInteger.h>
+
+/*
+ * NativeInteger basic type description.
+ */
+static const ber_tlv_tag_t asn_DEF_NativeInteger_tags[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+asn_TYPE_descriptor_t asn_DEF_NativeInteger = {
+	"INTEGER",			/* The ASN.1 type is still INTEGER */
+	"INTEGER",
+	NativeInteger_free,
+	NativeInteger_print,
+	asn_generic_no_constraint,
+	NativeInteger_decode_ber,
+	NativeInteger_encode_der,
+	NativeInteger_decode_xer,
+	NativeInteger_encode_xer,
+	NativeInteger_decode_uper,	/* Unaligned PER decoder */
+	NativeInteger_encode_uper,	/* Unaligned PER encoder */
+	0, /* Use generic outmost tag fetcher */
+	asn_DEF_NativeInteger_tags,
+	sizeof(asn_DEF_NativeInteger_tags) / sizeof(asn_DEF_NativeInteger_tags[0]),
+	asn_DEF_NativeInteger_tags,	/* Same as above */
+	sizeof(asn_DEF_NativeInteger_tags) / sizeof(asn_DEF_NativeInteger_tags[0]),
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	0	/* No specifics */
+};
+
+/*
+ * Decode INTEGER type.
+ */
+asn_dec_rval_t
+NativeInteger_decode_ber(asn_codec_ctx_t *opt_codec_ctx,
+	asn_TYPE_descriptor_t *td,
+	void **nint_ptr, const void *buf_ptr, size_t size, int tag_mode) {
+	asn_INTEGER_specifics_t *specs=(asn_INTEGER_specifics_t *)td->specifics;
+	long *native = (long *)*nint_ptr;
+	asn_dec_rval_t rval;
+	ber_tlv_len_t length;
+
+	/*
+	 * If the structure is not there, allocate it.
+	 */
+	if(native == NULL) {
+		native = (long *)(*nint_ptr = CALLOC(1, sizeof(*native)));
+		if(native == NULL) {
+			rval.code = RC_FAIL;
+			rval.consumed = 0;
+			return rval;
+		}
+	}
+
+	ASN_DEBUG("Decoding %s as INTEGER (tm=%d)",
+		td->name, tag_mode);
+
+	/*
+	 * Check tags.
+	 */
+	rval = ber_check_tags(opt_codec_ctx, td, 0, buf_ptr, size,
+			tag_mode, 0, &length, 0);
+	if(rval.code != RC_OK)
+		return rval;
+
+	ASN_DEBUG("%s length is %d bytes", td->name, (int)length);
+
+	/*
+	 * Make sure we have this length.
+	 */
+	buf_ptr = ((const char *)buf_ptr) + rval.consumed;
+	size -= rval.consumed;
+	if(length > (ber_tlv_len_t)size) {
+		rval.code = RC_WMORE;
+		rval.consumed = 0;
+		return rval;
+	}
+
+	/*
+	 * ASN.1 encoded INTEGER: buf_ptr, length
+	 * Fill the native, at the same time checking for overflow.
+	 * If overflow occured, return with RC_FAIL.
+	 */
+	{
+		INTEGER_t tmp;
+		union {
+			const void *constbuf;
+			void *nonconstbuf;
+		} unconst_buf;
+		long l;
+
+		unconst_buf.constbuf = buf_ptr;
+		tmp.buf = (uint8_t *)unconst_buf.nonconstbuf;
+		tmp.size = length;
+
+		if((specs&&specs->field_unsigned)
+			? asn_INTEGER2ulong(&tmp, (unsigned long *)&l) /* sic */
+			: asn_INTEGER2long(&tmp, &l)) {
+			rval.code = RC_FAIL;
+			rval.consumed = 0;
+			return rval;
+		}
+
+		*native = l;
+	}
+
+	rval.code = RC_OK;
+	rval.consumed += length;
+
+	ASN_DEBUG("Took %ld/%ld bytes to encode %s (%ld)",
+		(long)rval.consumed, (long)length, td->name, (long)*native);
+
+	return rval;
+}
+
+/*
+ * Encode the NativeInteger using the standard INTEGER type DER encoder.
+ */
+asn_enc_rval_t
+NativeInteger_encode_der(asn_TYPE_descriptor_t *sd, void *ptr,
+	int tag_mode, ber_tlv_tag_t tag,
+	asn_app_consume_bytes_f *cb, void *app_key) {
+	unsigned long native = *(unsigned long *)ptr;	/* Disable sign ext. */
+	asn_enc_rval_t erval;
+	INTEGER_t tmp;
+
+#ifdef	WORDS_BIGENDIAN		/* Opportunistic optimization */
+
+	tmp.buf = (uint8_t *)&native;
+	tmp.size = sizeof(native);
+
+#else	/* Works even if WORDS_BIGENDIAN is not set where should've been */
+	uint8_t buf[sizeof(native)];
+	uint8_t *p;
+
+	/* Prepare a fake INTEGER */
+	for(p = buf + sizeof(buf) - 1; p >= buf; p--, native >>= 8)
+		*p = (uint8_t)native;
+
+	tmp.buf = buf;
+	tmp.size = sizeof(buf);
+#endif	/* WORDS_BIGENDIAN */
+	
+	/* Encode fake INTEGER */
+	erval = INTEGER_encode_der(sd, &tmp, tag_mode, tag, cb, app_key);
+	if(erval.encoded == -1) {
+		assert(erval.structure_ptr == &tmp);
+		erval.structure_ptr = ptr;
+	}
+	return erval;
+}
+
+/*
+ * Decode the chunk of XML text encoding INTEGER.
+ */
+asn_dec_rval_t
+NativeInteger_decode_xer(asn_codec_ctx_t *opt_codec_ctx,
+	asn_TYPE_descriptor_t *td, void **sptr, const char *opt_mname,
+		const void *buf_ptr, size_t size) {
+	asn_INTEGER_specifics_t *specs=(asn_INTEGER_specifics_t *)td->specifics;
+	asn_dec_rval_t rval;
+	INTEGER_t st;
+	void *st_ptr = (void *)&st;
+	long *native = (long *)*sptr;
+
+	if(!native) {
+		native = (long *)(*sptr = CALLOC(1, sizeof(*native)));
+		if(!native) ASN__DECODE_FAILED;
+	}
+
+	memset(&st, 0, sizeof(st));
+	rval = INTEGER_decode_xer(opt_codec_ctx, td, &st_ptr, 
+		opt_mname, buf_ptr, size);
+	if(rval.code == RC_OK) {
+		long l;
+		if((specs&&specs->field_unsigned)
+			? asn_INTEGER2ulong(&st, (unsigned long *)&l) /* sic */
+			: asn_INTEGER2long(&st, &l)) {
+			rval.code = RC_FAIL;
+			rval.consumed = 0;
+		} else {
+			*native = l;
+		}
+	} else {
+		/*
+		 * Cannot restart from the middle;
+		 * there is no place to save state in the native type.
+		 * Request a continuation from the very beginning.
+		 */
+		rval.consumed = 0;
+	}
+	ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_INTEGER, &st);
+	return rval;
+}
+
+
+asn_enc_rval_t
+NativeInteger_encode_xer(asn_TYPE_descriptor_t *td, void *sptr,
+	int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	asn_INTEGER_specifics_t *specs=(asn_INTEGER_specifics_t *)td->specifics;
+	char scratch[32];	/* Enough for 64-bit int */
+	asn_enc_rval_t er;
+	const long *native = (const long *)sptr;
+
+	(void)ilevel;
+	(void)flags;
+
+	if(!native) ASN__ENCODE_FAILED;
+
+	er.encoded = snprintf(scratch, sizeof(scratch),
+			(specs && specs->field_unsigned)
+			? "%lu" : "%ld", *native);
+	if(er.encoded <= 0 || (size_t)er.encoded >= sizeof(scratch)
+		|| cb(scratch, er.encoded, app_key) < 0)
+		ASN__ENCODE_FAILED;
+
+	ASN__ENCODED_OK(er);
+}
+
+asn_dec_rval_t
+NativeInteger_decode_uper(asn_codec_ctx_t *opt_codec_ctx,
+	asn_TYPE_descriptor_t *td,
+	asn_per_constraints_t *constraints, void **sptr, asn_per_data_t *pd) {
+
+	asn_INTEGER_specifics_t *specs=(asn_INTEGER_specifics_t *)td->specifics;
+	asn_dec_rval_t rval;
+	long *native = (long *)*sptr;
+	INTEGER_t tmpint;
+	void *tmpintptr = &tmpint;
+
+	(void)opt_codec_ctx;
+	ASN_DEBUG("Decoding NativeInteger %s (UPER)", td->name);
+
+	if(!native) {
+		native = (long *)(*sptr = CALLOC(1, sizeof(*native)));
+		if(!native) ASN__DECODE_FAILED;
+	}
+
+	memset(&tmpint, 0, sizeof tmpint);
+	rval = INTEGER_decode_uper(opt_codec_ctx, td, constraints,
+				   &tmpintptr, pd);
+	if(rval.code == RC_OK) {
+		if((specs&&specs->field_unsigned)
+			? asn_INTEGER2ulong(&tmpint, (unsigned long *)native)
+			: asn_INTEGER2long(&tmpint, native))
+			rval.code = RC_FAIL;
+		else
+			ASN_DEBUG("NativeInteger %s got value %ld",
+				td->name, *native);
+	}
+	ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_INTEGER, &tmpint);
+
+	return rval;
+}
+
+asn_enc_rval_t
+NativeInteger_encode_uper(asn_TYPE_descriptor_t *td,
+	asn_per_constraints_t *constraints, void *sptr, asn_per_outp_t *po) {
+	asn_INTEGER_specifics_t *specs=(asn_INTEGER_specifics_t *)td->specifics;
+	asn_enc_rval_t er;
+	long native;
+	INTEGER_t tmpint;
+
+	if(!sptr) ASN__ENCODE_FAILED;
+
+	native = *(long *)sptr;
+
+	ASN_DEBUG("Encoding NativeInteger %s %ld (UPER)", td->name, native);
+
+	memset(&tmpint, 0, sizeof(tmpint));
+	if((specs&&specs->field_unsigned)
+		? asn_ulong2INTEGER(&tmpint, native)
+		: asn_long2INTEGER(&tmpint, native))
+		ASN__ENCODE_FAILED;
+	er = INTEGER_encode_uper(td, constraints, &tmpint, po);
+	ASN_STRUCT_FREE_CONTENTS_ONLY(asn_DEF_INTEGER, &tmpint);
+	return er;
+}
+
+/*
+ * INTEGER specific human-readable output.
+ */
+int
+NativeInteger_print(asn_TYPE_descriptor_t *td, const void *sptr, int ilevel,
+	asn_app_consume_bytes_f *cb, void *app_key) {
+	asn_INTEGER_specifics_t *specs=(asn_INTEGER_specifics_t *)td->specifics;
+	const long *native = (const long *)sptr;
+	char scratch[32];	/* Enough for 64-bit int */
+	int ret;
+
+	(void)td;	/* Unused argument */
+	(void)ilevel;	/* Unused argument */
+
+	if(native) {
+		ret = snprintf(scratch, sizeof(scratch),
+			(specs && specs->field_unsigned)
+			? "%lu" : "%ld", *native);
+		assert(ret > 0 && (size_t)ret < sizeof(scratch));
+		return (cb(scratch, ret, app_key) < 0) ? -1 : 0;
+	} else {
+		return (cb("<absent>", 8, app_key) < 0) ? -1 : 0;
+	}
+}
+
+void
+NativeInteger_free(asn_TYPE_descriptor_t *td, void *ptr, int contents_only) {
+
+	if(!td || !ptr)
+		return;
+
+	ASN_DEBUG("Freeing %s as INTEGER (%d, %p, Native)",
+		td->name, contents_only, ptr);
+
+	if(!contents_only) {
+		FREEMEM(ptr);
+	}
+}
+
--- a/src/cryptoconditions/src/asn/NativeInteger.h
+++ b/src/cryptoconditions/src/asn/NativeInteger.h
@@ -0,0 +1,37 @@
+/*-
+ * Copyright (c) 2004 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+/*
+ * This type differs from the standard INTEGER in that it is modelled using
+ * the fixed machine type (long, int, short), so it can hold only values of
+ * limited length. There is no type (i.e., NativeInteger_t, any integer type
+ * will do).
+ * This type may be used when integer range is limited by subtype constraints.
+ */
+#ifndef	_NativeInteger_H_
+#define	_NativeInteger_H_
+
+#include <asn_application.h>
+#include <INTEGER.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern asn_TYPE_descriptor_t asn_DEF_NativeInteger;
+
+asn_struct_free_f  NativeInteger_free;
+asn_struct_print_f NativeInteger_print;
+ber_type_decoder_f NativeInteger_decode_ber;
+der_type_encoder_f NativeInteger_encode_der;
+xer_type_decoder_f NativeInteger_decode_xer;
+xer_type_encoder_f NativeInteger_encode_xer;
+per_type_decoder_f NativeInteger_decode_uper;
+per_type_encoder_f NativeInteger_encode_uper;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _NativeInteger_H_ */
--- a/src/cryptoconditions/src/asn/OCTET_STRING.c
+++ b/src/cryptoconditions/src/asn/OCTET_STRING.c
--- a/src/cryptoconditions/src/asn/OCTET_STRING.h
+++ b/src/cryptoconditions/src/asn/OCTET_STRING.h
@@ -0,0 +1,86 @@
+/*-
+ * Copyright (c) 2003 Lev Walkin <vlm@lionet.info>. All rights reserved.
+ * Redistribution and modifications are permitted subject to BSD license.
+ */
+#ifndef	_OCTET_STRING_H_
+#define	_OCTET_STRING_H_
+
+#include <asn_application.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct OCTET_STRING {
+	uint8_t *buf;	/* Buffer with consecutive OCTET_STRING bits */
+	int size;	/* Size of the buffer */
+
+	asn_struct_ctx_t _asn_ctx;	/* Parsing across buffer boundaries */
+} OCTET_STRING_t;
+
+extern asn_TYPE_descriptor_t asn_DEF_OCTET_STRING;
+
+asn_struct_free_f OCTET_STRING_free;
+asn_struct_print_f OCTET_STRING_print;
+asn_struct_print_f OCTET_STRING_print_utf8;
+ber_type_decoder_f OCTET_STRING_decode_ber;
+der_type_encoder_f OCTET_STRING_encode_der;
+xer_type_decoder_f OCTET_STRING_decode_xer_hex;		/* Hexadecimal */
+xer_type_decoder_f OCTET_STRING_decode_xer_binary;	/* 01010111010 */
+xer_type_decoder_f OCTET_STRING_decode_xer_utf8;	/* ASCII/UTF-8 */
+xer_type_encoder_f OCTET_STRING_encode_xer;
+xer_type_encoder_f OCTET_STRING_encode_xer_utf8;
+per_type_decoder_f OCTET_STRING_decode_uper;
+per_type_encoder_f OCTET_STRING_encode_uper;
+
+/******************************
+ * Handy conversion routines. *
+ ******************************/
+
+/*
+ * This function clears the previous value of the OCTET STRING (if any)
+ * and then allocates a new memory with the specified content (str/size).
+ * If size = -1, the size of the original string will be determined
+ * using strlen(str).
+ * If str equals to NULL, the function will silently clear the
+ * current contents of the OCTET STRING.
+ * Returns 0 if it was possible to perform operation, -1 otherwise.
+ */
+int OCTET_STRING_fromBuf(OCTET_STRING_t *s, const char *str, int size);
+
+/* Handy conversion from the C string into the OCTET STRING. */
+#define	OCTET_STRING_fromString(s, str)	OCTET_STRING_fromBuf(s, str, -1)
+
+/*
+ * Allocate and fill the new OCTET STRING and return a pointer to the newly
+ * allocated object. NULL is permitted in str: the function will just allocate
+ * empty OCTET STRING.
+ */
+OCTET_STRING_t *OCTET_STRING_new_fromBuf(asn_TYPE_descriptor_t *td,
+	const char *str, int size);
+
+/****************************
+ * Internally useful stuff. *
+ ****************************/
+
+typedef const struct asn_OCTET_STRING_specifics_s {
+	/*
+	 * Target structure description.
+	 */
+	int struct_size;	/* Size of the structure */
+	int ctx_offset;		/* Offset of the asn_struct_ctx_t member */
+
+	enum asn_OS_Subvariant {
+		ASN_OSUBV_ANY,	/* The open type (ANY) */
+		ASN_OSUBV_BIT,	/* BIT STRING */
+		ASN_OSUBV_STR,	/* String types, not {BMP,Universal}String  */
+		ASN_OSUBV_U16,	/* 16-bit character (BMPString) */
+		ASN_OSUBV_U32	/* 32-bit character (UniversalString) */
+	} subvariant;
+} asn_OCTET_STRING_specifics_t;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _OCTET_STRING_H_ */
--- a/src/cryptoconditions/src/asn/PrefixFingerprintContents.c
+++ b/src/cryptoconditions/src/asn/PrefixFingerprintContents.c
@@ -0,0 +1,209 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "Crypto-Conditions"
+ * 	found in "CryptoConditions.asn"
+ */
+
+#include "PrefixFingerprintContents.h"
+
+static int
+maxMessageLength_3_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	
+	if(!sptr) {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	
+	/* Constraint check succeeded */
+	return 0;
+}
+
+/*
+ * This type is implemented using NativeInteger,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+maxMessageLength_3_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_NativeInteger.free_struct;
+	td->print_struct   = asn_DEF_NativeInteger.print_struct;
+	td->check_constraints = asn_DEF_NativeInteger.check_constraints;
+	td->ber_decoder    = asn_DEF_NativeInteger.ber_decoder;
+	td->der_encoder    = asn_DEF_NativeInteger.der_encoder;
+	td->xer_decoder    = asn_DEF_NativeInteger.xer_decoder;
+	td->xer_encoder    = asn_DEF_NativeInteger.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeInteger.uper_decoder;
+	td->uper_encoder   = asn_DEF_NativeInteger.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeInteger.per_constraints;
+	td->elements       = asn_DEF_NativeInteger.elements;
+	td->elements_count = asn_DEF_NativeInteger.elements_count;
+     /* td->specifics      = asn_DEF_NativeInteger.specifics;	// Defined explicitly */
+}
+
+static void
+maxMessageLength_3_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	maxMessageLength_3_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+static int
+maxMessageLength_3_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	maxMessageLength_3_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+static asn_dec_rval_t
+maxMessageLength_3_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	maxMessageLength_3_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+static asn_enc_rval_t
+maxMessageLength_3_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	maxMessageLength_3_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+static asn_dec_rval_t
+maxMessageLength_3_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	maxMessageLength_3_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+static asn_enc_rval_t
+maxMessageLength_3_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	maxMessageLength_3_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+static int
+memb_maxMessageLength_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	
+	if(!sptr) {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	
+	/* Constraint check succeeded */
+	return 0;
+}
+
+static const asn_INTEGER_specifics_t asn_SPC_maxMessageLength_specs_3 = {
+	0,	0,	0,	0,	0,
+	0,	/* Native long size */
+	1	/* Unsigned representation */
+};
+static const ber_tlv_tag_t asn_DEF_maxMessageLength_tags_3[] = {
+	(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+static /* Use -fall-defs-global to expose */
+asn_TYPE_descriptor_t asn_DEF_maxMessageLength_3 = {
+	"maxMessageLength",
+	"maxMessageLength",
+	maxMessageLength_3_free,
+	maxMessageLength_3_print,
+	maxMessageLength_3_constraint,
+	maxMessageLength_3_decode_ber,
+	maxMessageLength_3_encode_der,
+	maxMessageLength_3_decode_xer,
+	maxMessageLength_3_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_maxMessageLength_tags_3,
+	sizeof(asn_DEF_maxMessageLength_tags_3)
+		/sizeof(asn_DEF_maxMessageLength_tags_3[0]) - 1, /* 1 */
+	asn_DEF_maxMessageLength_tags_3,	/* Same as above */
+	sizeof(asn_DEF_maxMessageLength_tags_3)
+		/sizeof(asn_DEF_maxMessageLength_tags_3[0]), /* 2 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	&asn_SPC_maxMessageLength_specs_3	/* Additional specs */
+};
+
+static asn_TYPE_member_t asn_MBR_PrefixFingerprintContents_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct PrefixFingerprintContents, prefix),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_OCTET_STRING,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"prefix"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct PrefixFingerprintContents, maxMessageLength),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_maxMessageLength_3,
+		memb_maxMessageLength_constraint_1,
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"maxMessageLength"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct PrefixFingerprintContents, subcondition),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		+1,	/* EXPLICIT tag at current level */
+		&asn_DEF_Condition,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"subcondition"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_PrefixFingerprintContents_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_PrefixFingerprintContents_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* prefix */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* maxMessageLength */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* subcondition */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_PrefixFingerprintContents_specs_1 = {
+	sizeof(struct PrefixFingerprintContents),
+	offsetof(struct PrefixFingerprintContents, _asn_ctx),
+	asn_MAP_PrefixFingerprintContents_tag2el_1,
+	3,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	-1,	/* Start extensions */
+	-1	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_PrefixFingerprintContents = {
+	"PrefixFingerprintContents",
+	"PrefixFingerprintContents",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_PrefixFingerprintContents_tags_1,
+	sizeof(asn_DEF_PrefixFingerprintContents_tags_1)
+		/sizeof(asn_DEF_PrefixFingerprintContents_tags_1[0]), /* 1 */
+	asn_DEF_PrefixFingerprintContents_tags_1,	/* Same as above */
+	sizeof(asn_DEF_PrefixFingerprintContents_tags_1)
+		/sizeof(asn_DEF_PrefixFingerprintContents_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_PrefixFingerprintContents_1,
+	3,	/* Elements count */
+	&asn_SPC_PrefixFingerprintContents_specs_1	/* Additional specs */
+};
+
--- a/src/cryptoconditions/src/asn/PrefixFingerprintContents.h
+++ b/src/cryptoconditions/src/asn/PrefixFingerprintContents.h
@@ -0,0 +1,42 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "Crypto-Conditions"
+ * 	found in "CryptoConditions.asn"
+ */
+
+#ifndef	_PrefixFingerprintContents_H_
+#define	_PrefixFingerprintContents_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <OCTET_STRING.h>
+#include <NativeInteger.h>
+#include "Condition.h"
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* PrefixFingerprintContents */
+typedef struct PrefixFingerprintContents {
+	OCTET_STRING_t	 prefix;
+	unsigned long	 maxMessageLength;
+	Condition_t	 subcondition;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} PrefixFingerprintContents_t;
+
+/* Implementation */
+/* extern asn_TYPE_descriptor_t asn_DEF_maxMessageLength_3;	// (Use -fall-defs-global to expose) */
+extern asn_TYPE_descriptor_t asn_DEF_PrefixFingerprintContents;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _PrefixFingerprintContents_H_ */
+#include <asn_internal.h>
--- a/src/cryptoconditions/src/asn/PrefixFulfillment.c
+++ b/src/cryptoconditions/src/asn/PrefixFulfillment.c
@@ -0,0 +1,209 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "Crypto-Conditions"
+ * 	found in "CryptoConditions.asn"
+ */
+
+#include "PrefixFulfillment.h"
+
+static int
+maxMessageLength_3_constraint(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	
+	if(!sptr) {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	
+	/* Constraint check succeeded */
+	return 0;
+}
+
+/*
+ * This type is implemented using NativeInteger,
+ * so here we adjust the DEF accordingly.
+ */
+static void
+maxMessageLength_3_inherit_TYPE_descriptor(asn_TYPE_descriptor_t *td) {
+	td->free_struct    = asn_DEF_NativeInteger.free_struct;
+	td->print_struct   = asn_DEF_NativeInteger.print_struct;
+	td->check_constraints = asn_DEF_NativeInteger.check_constraints;
+	td->ber_decoder    = asn_DEF_NativeInteger.ber_decoder;
+	td->der_encoder    = asn_DEF_NativeInteger.der_encoder;
+	td->xer_decoder    = asn_DEF_NativeInteger.xer_decoder;
+	td->xer_encoder    = asn_DEF_NativeInteger.xer_encoder;
+	td->uper_decoder   = asn_DEF_NativeInteger.uper_decoder;
+	td->uper_encoder   = asn_DEF_NativeInteger.uper_encoder;
+	if(!td->per_constraints)
+		td->per_constraints = asn_DEF_NativeInteger.per_constraints;
+	td->elements       = asn_DEF_NativeInteger.elements;
+	td->elements_count = asn_DEF_NativeInteger.elements_count;
+     /* td->specifics      = asn_DEF_NativeInteger.specifics;	// Defined explicitly */
+}
+
+static void
+maxMessageLength_3_free(asn_TYPE_descriptor_t *td,
+		void *struct_ptr, int contents_only) {
+	maxMessageLength_3_inherit_TYPE_descriptor(td);
+	td->free_struct(td, struct_ptr, contents_only);
+}
+
+static int
+maxMessageLength_3_print(asn_TYPE_descriptor_t *td, const void *struct_ptr,
+		int ilevel, asn_app_consume_bytes_f *cb, void *app_key) {
+	maxMessageLength_3_inherit_TYPE_descriptor(td);
+	return td->print_struct(td, struct_ptr, ilevel, cb, app_key);
+}
+
+static asn_dec_rval_t
+maxMessageLength_3_decode_ber(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const void *bufptr, size_t size, int tag_mode) {
+	maxMessageLength_3_inherit_TYPE_descriptor(td);
+	return td->ber_decoder(opt_codec_ctx, td, structure, bufptr, size, tag_mode);
+}
+
+static asn_enc_rval_t
+maxMessageLength_3_encode_der(asn_TYPE_descriptor_t *td,
+		void *structure, int tag_mode, ber_tlv_tag_t tag,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	maxMessageLength_3_inherit_TYPE_descriptor(td);
+	return td->der_encoder(td, structure, tag_mode, tag, cb, app_key);
+}
+
+static asn_dec_rval_t
+maxMessageLength_3_decode_xer(asn_codec_ctx_t *opt_codec_ctx, asn_TYPE_descriptor_t *td,
+		void **structure, const char *opt_mname, const void *bufptr, size_t size) {
+	maxMessageLength_3_inherit_TYPE_descriptor(td);
+	return td->xer_decoder(opt_codec_ctx, td, structure, opt_mname, bufptr, size);
+}
+
+static asn_enc_rval_t
+maxMessageLength_3_encode_xer(asn_TYPE_descriptor_t *td, void *structure,
+		int ilevel, enum xer_encoder_flags_e flags,
+		asn_app_consume_bytes_f *cb, void *app_key) {
+	maxMessageLength_3_inherit_TYPE_descriptor(td);
+	return td->xer_encoder(td, structure, ilevel, flags, cb, app_key);
+}
+
+static int
+memb_maxMessageLength_constraint_1(asn_TYPE_descriptor_t *td, const void *sptr,
+			asn_app_constraint_failed_f *ctfailcb, void *app_key) {
+	
+	if(!sptr) {
+		ASN__CTFAIL(app_key, td, sptr,
+			"%s: value not given (%s:%d)",
+			td->name, __FILE__, __LINE__);
+		return -1;
+	}
+	
+	
+	/* Constraint check succeeded */
+	return 0;
+}
+
+static const asn_INTEGER_specifics_t asn_SPC_maxMessageLength_specs_3 = {
+	0,	0,	0,	0,	0,
+	0,	/* Native long size */
+	1	/* Unsigned representation */
+};
+static const ber_tlv_tag_t asn_DEF_maxMessageLength_tags_3[] = {
+	(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+	(ASN_TAG_CLASS_UNIVERSAL | (2 << 2))
+};
+static /* Use -fall-defs-global to expose */
+asn_TYPE_descriptor_t asn_DEF_maxMessageLength_3 = {
+	"maxMessageLength",
+	"maxMessageLength",
+	maxMessageLength_3_free,
+	maxMessageLength_3_print,
+	maxMessageLength_3_constraint,
+	maxMessageLength_3_decode_ber,
+	maxMessageLength_3_encode_der,
+	maxMessageLength_3_decode_xer,
+	maxMessageLength_3_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_maxMessageLength_tags_3,
+	sizeof(asn_DEF_maxMessageLength_tags_3)
+		/sizeof(asn_DEF_maxMessageLength_tags_3[0]) - 1, /* 1 */
+	asn_DEF_maxMessageLength_tags_3,	/* Same as above */
+	sizeof(asn_DEF_maxMessageLength_tags_3)
+		/sizeof(asn_DEF_maxMessageLength_tags_3[0]), /* 2 */
+	0,	/* No PER visible constraints */
+	0, 0,	/* No members */
+	&asn_SPC_maxMessageLength_specs_3	/* Additional specs */
+};
+
+static asn_TYPE_member_t asn_MBR_PrefixFulfillment_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct PrefixFulfillment, prefix),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_OCTET_STRING,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"prefix"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct PrefixFulfillment, maxMessageLength),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_maxMessageLength_3,
+		memb_maxMessageLength_constraint_1,
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"maxMessageLength"
+		},
+	{ ATF_POINTER, 0, offsetof(struct PrefixFulfillment, subfulfillment),
+		(ASN_TAG_CLASS_CONTEXT | (2 << 2)),
+		+1,	/* EXPLICIT tag at current level */
+		&asn_DEF_Fulfillment,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"subfulfillment"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_PrefixFulfillment_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_PrefixFulfillment_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* prefix */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 }, /* maxMessageLength */
+    { (ASN_TAG_CLASS_CONTEXT | (2 << 2)), 2, 0, 0 } /* subfulfillment */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_PrefixFulfillment_specs_1 = {
+	sizeof(struct PrefixFulfillment),
+	offsetof(struct PrefixFulfillment, _asn_ctx),
+	asn_MAP_PrefixFulfillment_tag2el_1,
+	3,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	-1,	/* Start extensions */
+	-1	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_PrefixFulfillment = {
+	"PrefixFulfillment",
+	"PrefixFulfillment",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_PrefixFulfillment_tags_1,
+	sizeof(asn_DEF_PrefixFulfillment_tags_1)
+		/sizeof(asn_DEF_PrefixFulfillment_tags_1[0]), /* 1 */
+	asn_DEF_PrefixFulfillment_tags_1,	/* Same as above */
+	sizeof(asn_DEF_PrefixFulfillment_tags_1)
+		/sizeof(asn_DEF_PrefixFulfillment_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_PrefixFulfillment_1,
+	3,	/* Elements count */
+	&asn_SPC_PrefixFulfillment_specs_1	/* Additional specs */
+};
+
--- a/src/cryptoconditions/src/asn/PrefixFulfillment.h
+++ b/src/cryptoconditions/src/asn/PrefixFulfillment.h
@@ -0,0 +1,47 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "Crypto-Conditions"
+ * 	found in "CryptoConditions.asn"
+ */
+
+#ifndef	_PrefixFulfillment_H_
+#define	_PrefixFulfillment_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <OCTET_STRING.h>
+#include <NativeInteger.h>
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Forward declarations */
+struct Fulfillment;
+
+/* PrefixFulfillment */
+typedef struct PrefixFulfillment {
+	OCTET_STRING_t	 prefix;
+	unsigned long	 maxMessageLength;
+	struct Fulfillment	*subfulfillment;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} PrefixFulfillment_t;
+
+/* Implementation */
+/* extern asn_TYPE_descriptor_t asn_DEF_maxMessageLength_3;	// (Use -fall-defs-global to expose) */
+extern asn_TYPE_descriptor_t asn_DEF_PrefixFulfillment;
+
+#ifdef __cplusplus
+}
+#endif
+
+/* Referred external types */
+#include "Fulfillment.h"
+
+#endif	/* _PrefixFulfillment_H_ */
+#include <asn_internal.h>
--- a/src/cryptoconditions/src/asn/PreimageFulfillment.c
+++ b/src/cryptoconditions/src/asn/PreimageFulfillment.c
@@ -0,0 +1,58 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "Crypto-Conditions"
+ * 	found in "CryptoConditions.asn"
+ */
+
+#include "PreimageFulfillment.h"
+
+static asn_TYPE_member_t asn_MBR_PreimageFulfillment_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct PreimageFulfillment, preimage),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_OCTET_STRING,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"preimage"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_PreimageFulfillment_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_PreimageFulfillment_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* preimage */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_PreimageFulfillment_specs_1 = {
+	sizeof(struct PreimageFulfillment),
+	offsetof(struct PreimageFulfillment, _asn_ctx),
+	asn_MAP_PreimageFulfillment_tag2el_1,
+	1,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	-1,	/* Start extensions */
+	-1	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_PreimageFulfillment = {
+	"PreimageFulfillment",
+	"PreimageFulfillment",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_PreimageFulfillment_tags_1,
+	sizeof(asn_DEF_PreimageFulfillment_tags_1)
+		/sizeof(asn_DEF_PreimageFulfillment_tags_1[0]), /* 1 */
+	asn_DEF_PreimageFulfillment_tags_1,	/* Same as above */
+	sizeof(asn_DEF_PreimageFulfillment_tags_1)
+		/sizeof(asn_DEF_PreimageFulfillment_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_PreimageFulfillment_1,
+	1,	/* Elements count */
+	&asn_SPC_PreimageFulfillment_specs_1	/* Additional specs */
+};
+
--- a/src/cryptoconditions/src/asn/PreimageFulfillment.h
+++ b/src/cryptoconditions/src/asn/PreimageFulfillment.h
@@ -0,0 +1,37 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "Crypto-Conditions"
+ * 	found in "CryptoConditions.asn"
+ */
+
+#ifndef	_PreimageFulfillment_H_
+#define	_PreimageFulfillment_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <OCTET_STRING.h>
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* PreimageFulfillment */
+typedef struct PreimageFulfillment {
+	OCTET_STRING_t	 preimage;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} PreimageFulfillment_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_PreimageFulfillment;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _PreimageFulfillment_H_ */
+#include <asn_internal.h>
--- a/src/cryptoconditions/src/asn/RsaFingerprintContents.c
+++ b/src/cryptoconditions/src/asn/RsaFingerprintContents.c
@@ -0,0 +1,58 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "Crypto-Conditions"
+ * 	found in "CryptoConditions.asn"
+ */
+
+#include "RsaFingerprintContents.h"
+
+static asn_TYPE_member_t asn_MBR_RsaFingerprintContents_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct RsaFingerprintContents, modulus),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_OCTET_STRING,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"modulus"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_RsaFingerprintContents_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_RsaFingerprintContents_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 } /* modulus */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_RsaFingerprintContents_specs_1 = {
+	sizeof(struct RsaFingerprintContents),
+	offsetof(struct RsaFingerprintContents, _asn_ctx),
+	asn_MAP_RsaFingerprintContents_tag2el_1,
+	1,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	-1,	/* Start extensions */
+	-1	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_RsaFingerprintContents = {
+	"RsaFingerprintContents",
+	"RsaFingerprintContents",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_RsaFingerprintContents_tags_1,
+	sizeof(asn_DEF_RsaFingerprintContents_tags_1)
+		/sizeof(asn_DEF_RsaFingerprintContents_tags_1[0]), /* 1 */
+	asn_DEF_RsaFingerprintContents_tags_1,	/* Same as above */
+	sizeof(asn_DEF_RsaFingerprintContents_tags_1)
+		/sizeof(asn_DEF_RsaFingerprintContents_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_RsaFingerprintContents_1,
+	1,	/* Elements count */
+	&asn_SPC_RsaFingerprintContents_specs_1	/* Additional specs */
+};
+
--- a/src/cryptoconditions/src/asn/RsaFingerprintContents.h
+++ b/src/cryptoconditions/src/asn/RsaFingerprintContents.h
@@ -0,0 +1,37 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "Crypto-Conditions"
+ * 	found in "CryptoConditions.asn"
+ */
+
+#ifndef	_RsaFingerprintContents_H_
+#define	_RsaFingerprintContents_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <OCTET_STRING.h>
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* RsaFingerprintContents */
+typedef struct RsaFingerprintContents {
+	OCTET_STRING_t	 modulus;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} RsaFingerprintContents_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_RsaFingerprintContents;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _RsaFingerprintContents_H_ */
+#include <asn_internal.h>
--- a/src/cryptoconditions/src/asn/RsaSha256Fulfillment.c
+++ b/src/cryptoconditions/src/asn/RsaSha256Fulfillment.c
@@ -0,0 +1,68 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "Crypto-Conditions"
+ * 	found in "CryptoConditions.asn"
+ */
+
+#include "RsaSha256Fulfillment.h"
+
+static asn_TYPE_member_t asn_MBR_RsaSha256Fulfillment_1[] = {
+	{ ATF_NOFLAGS, 0, offsetof(struct RsaSha256Fulfillment, modulus),
+		(ASN_TAG_CLASS_CONTEXT | (0 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_OCTET_STRING,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"modulus"
+		},
+	{ ATF_NOFLAGS, 0, offsetof(struct RsaSha256Fulfillment, signature),
+		(ASN_TAG_CLASS_CONTEXT | (1 << 2)),
+		-1,	/* IMPLICIT tag at current level */
+		&asn_DEF_OCTET_STRING,
+		0,	/* Defer constraints checking to the member type */
+		0,	/* PER is not compiled, use -gen-PER */
+		0,
+		"signature"
+		},
+};
+static const ber_tlv_tag_t asn_DEF_RsaSha256Fulfillment_tags_1[] = {
+	(ASN_TAG_CLASS_UNIVERSAL | (16 << 2))
+};
+static const asn_TYPE_tag2member_t asn_MAP_RsaSha256Fulfillment_tag2el_1[] = {
+    { (ASN_TAG_CLASS_CONTEXT | (0 << 2)), 0, 0, 0 }, /* modulus */
+    { (ASN_TAG_CLASS_CONTEXT | (1 << 2)), 1, 0, 0 } /* signature */
+};
+static asn_SEQUENCE_specifics_t asn_SPC_RsaSha256Fulfillment_specs_1 = {
+	sizeof(struct RsaSha256Fulfillment),
+	offsetof(struct RsaSha256Fulfillment, _asn_ctx),
+	asn_MAP_RsaSha256Fulfillment_tag2el_1,
+	2,	/* Count of tags in the map */
+	0, 0, 0,	/* Optional elements (not needed) */
+	-1,	/* Start extensions */
+	-1	/* Stop extensions */
+};
+asn_TYPE_descriptor_t asn_DEF_RsaSha256Fulfillment = {
+	"RsaSha256Fulfillment",
+	"RsaSha256Fulfillment",
+	SEQUENCE_free,
+	SEQUENCE_print,
+	SEQUENCE_constraint,
+	SEQUENCE_decode_ber,
+	SEQUENCE_encode_der,
+	SEQUENCE_decode_xer,
+	SEQUENCE_encode_xer,
+	0, 0,	/* No PER support, use "-gen-PER" to enable */
+	0,	/* Use generic outmost tag fetcher */
+	asn_DEF_RsaSha256Fulfillment_tags_1,
+	sizeof(asn_DEF_RsaSha256Fulfillment_tags_1)
+		/sizeof(asn_DEF_RsaSha256Fulfillment_tags_1[0]), /* 1 */
+	asn_DEF_RsaSha256Fulfillment_tags_1,	/* Same as above */
+	sizeof(asn_DEF_RsaSha256Fulfillment_tags_1)
+		/sizeof(asn_DEF_RsaSha256Fulfillment_tags_1[0]), /* 1 */
+	0,	/* No PER visible constraints */
+	asn_MBR_RsaSha256Fulfillment_1,
+	2,	/* Elements count */
+	&asn_SPC_RsaSha256Fulfillment_specs_1	/* Additional specs */
+};
+
--- a/src/cryptoconditions/src/asn/RsaSha256Fulfillment.h
+++ b/src/cryptoconditions/src/asn/RsaSha256Fulfillment.h
@@ -0,0 +1,38 @@
+/*
+ * Generated by asn1c-0.9.28 (http://lionet.info/asn1c)
+ * From ASN.1 module "Crypto-Conditions"
+ * 	found in "CryptoConditions.asn"
+ */
+
+#ifndef	_RsaSha256Fulfillment_H_
+#define	_RsaSha256Fulfillment_H_
+
+
+#include <asn_application.h>
+
+/* Including external dependencies */
+#include <OCTET_STRING.h>
+#include <constr_SEQUENCE.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* RsaSha256Fulfillment */
+typedef struct RsaSha256Fulfillment {
+	OCTET_STRING_t	 modulus;
+	OCTET_STRING_t	 signature;
+	
+	/* Context for parsing across buffer boundaries */
+	asn_struct_ctx_t _asn_ctx;
+} RsaSha256Fulfillment_t;
+
+/* Implementation */
+extern asn_TYPE_descriptor_t asn_DEF_RsaSha256Fulfillment;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif	/* _RsaSha256Fulfillment_H_ */
+#include <asn_internal.h>
--- a/Show More
+++ b/Show More