daod: setup for running zk dao contract

bin/daod/demo/main.py

@@ -186,10 +186,12 @@ def main(argv):
 
     builder = TransactionBuilder(ec)
     builder.add_clear_input(initial_supply, token_id, signature_secret)
+    # Address of deployed contract in our example is 0xdao_ruleset
     spend_hook = b"0xdao_ruleset"
     # This can be a simple hash of the items passed into the ZK proof
     # up to corresponding linked ZK proof to interpret however they need.
-    user_data = b""
+    # In out case, it's the bulla for the DAO
+    user_data = dao_tx.revealed.bulla
     builder.add_output(initial_supply, token_id, public, spend_hook, user_data)
     tx = builder.build()
 
@@ -247,8 +249,12 @@ def main(argv):
     assert coin == tx.outputs[0].mint_proof.get_revealed().coin
     all_coins = set([coin])
 
+    # Used to export user_data from this coin so it can be accessed
+    # by 0xdao_ruleset
+    user_data_blind = ec.random_base()
+
     builder = TransactionBuilder(ec)
-    builder.add_input(all_coins, secret, note)
+    builder.add_input(all_coins, secret, note, user_data_blind)
 
     secret2 = ec.random_scalar()
     public2 = ec.multiply(secret, ec.G)
@@ -264,9 +270,25 @@ def main(argv):
         return -1
     state.apply(update)
 
+    assert len(tx.inputs) == 1
     # At least one input has this field value which means the 0xdao_ruleset
     # is invoked.
-    assert tx.inputs[0].revealed.spend_hook == b"0xdao_ruleset"
+    input = tx.inputs[0]
+    assert input.revealed.spend_hook == b"0xdao_ruleset"
+    assert input.revealed.enc_user_data == ff_hash(ec.p, user_data,
+                                                   user_data_blind)
+    bulla = ff_hash(
+        ec.p,
+        proposal_auth_public[0],
+        proposal_auth_public[1],
+        threshold,
+        quorum
+    )
+    assert user_data == bulla
+
+    # Now enforce DAO rules:
+    # 1. valid signed proposal
+    # 2. positive number of votes
 
     return 0
 

bin/daod/demo/tx.py

@@ -17,11 +17,12 @@ class TransactionBuilder:
         clear_input.signature_secret = signature_secret
         self.clear_inputs.append(clear_input)
 
-    def add_input(self, all_coins, secret, note):
+    def add_input(self, all_coins, secret, note, user_data_blind):
         input = ClassNamespace()
         input.all_coins = all_coins
         input.secret = secret
         input.note = note
+        input.user_data_blind = user_data_blind
         self.inputs.append(input)
 
     def add_output(self, value, token_id, public, spend_hook, user_data):
@@ -71,7 +72,8 @@ class TransactionBuilder:
                 input.note.value, input.note.token_id, input.note.value_blind,
                 token_blind, input.note.serial, input.note.coin_blind,
                 input.secret, input.note.spend_hook, input.note.user_data,
-                input.all_coins, signature_secret, self.ec)
+                input.user_data_blind, input.all_coins, signature_secret,
+                self.ec)
             tx_input.revealed = tx_input.burn_proof.get_revealed()
             tx.inputs.append(tx_input)
 
@@ -201,8 +203,8 @@ class Transaction:
 class BurnProof:
 
     def __init__(self, value, token_id, value_blind, token_blind, serial,
-                 coin_blind, secret, spend_hook, user_data, all_coins,
-                 signature_secret, ec):
+                 coin_blind, secret, spend_hook, user_data, user_data_blind,
+                 all_coins, signature_secret, ec):
         self.value = value
         self.token_id = token_id
         self.value_blind = value_blind
@@ -212,6 +214,7 @@ class BurnProof:
         self.secret = secret
         self.spend_hook = spend_hook
         self.user_data = user_data
+        self.user_data_blind = user_data_blind
         self.all_coins = all_coins
         self.signature_secret = signature_secret
 
@@ -236,6 +239,13 @@ class BurnProof:
         # This is fully public, no merkle tree or anything
         revealed.spend_hook = self.spend_hook
 
+        # Re-export user_data field for access by other contracts
+        revealed.enc_user_data = ff_hash(
+            self.ec.p,
+            self.user_data,
+            self.user_data_blind
+        )
+
         return revealed
 
     def verify(self, public):