@@ -1,21 +1,16 @@
 #!/usr/bin/env python
 
-from re import A
 import reference
 import json
 from secp256k1 import *
 from bitcoin_utils import deser_txid, hash160, COutPoint
 import bip32
 from copy import deepcopy
-from importlib import reload
 from typing import Tuple, List
-reload(reference)
-
-G = ECKey().set(1).get_pubkey()
-sending_test_vectors = []
+from itertools import permutations
 
 HRP="sp"
-#TODO: use clearly mock signatures, e.g. 010203040506...
+
 def derive_silent_payment_key_pair(seed: bytes) -> Tuple[ECKey, ECKey, ECPubKey, ECPubKey]:
     SCAN_KEY = "m/352h/0h/0h/1h/0"
     SPEND_KEY = "m/352h/0h/0h/0h/0"
@@ -28,7 +23,6 @@ def derive_silent_payment_key_pair(seed: bytes) -> Tuple[ECKey, ECKey, ECPubKey,
 
     return scan, spend, Scan, Spend
 
-
 def get_key_pair(index, seed=b'deadbeef', derivation='m/0h'):
 
     master = bip32.BIP32.from_seed(seed)
@@ -37,12 +31,6 @@ def get_key_pair(index, seed=b'deadbeef', derivation='m/0h'):
 
     return d, P
 
-def add_private_keys(inputs, input_priv_keys):
-    for x, i in enumerate(inputs):
-        i['private_key'] = input_priv_keys[x][0].get_bytes().hex()
-
-    return inputs
-
 def get_p2pkh_scriptsig(pub_key, priv_key):
     msg = hashlib.sha256(b'message').digest()
     sig = priv_key.sign_ecdsa(msg, low_s=False, rfc6979=True).hex()
@@ -74,37 +62,46 @@ def serialize_witness_stack(stack_items):
         result += f'{size:02x}' + item
     return result
 
-def new_test_case():
-    recipient =  {
-        "given": {
-            "vin": [],
-            "outputs": [],
-            "key_material": {
-                "spend_priv_key": "hex",
-                "scan_priv_key": "hex",
-            },
-            "labels": [],
-        },
-        "expected": {
-            "addresses": [],
-            "outputs": [],
-        }
-    }
-    sender = {
-        "given": {
-            "vin": [],
-            "recipients": []
-        },
-        "expected": {
-            "outputs": [],
-        }
-    }
-    test_case = {
-        "comment": "",
-        "sending": [],
-        "receiving": [],
-    }
-    return sender, recipient, test_case
+def unique_permutations(lst):
+    # Generate all permutations of the list
+    perms = permutations(lst, len(lst))
+    unique_perms = set(perms)
+    unique_perms_list = list(unique_perms)
+    return unique_perms_list
+
+def create_output_permutations(input_priv_keys: List[Tuple[ECKey, bool]], input_hash: bytes, recipients: List[str], hrp="tsp") -> List[List[str]]:
+    G = ECKey().set(1).get_pubkey()
+    negated_keys = []
+    for key, is_xonly in input_priv_keys:
+        k = ECKey().set(key.get_bytes())
+        if is_xonly and k.get_pubkey().get_y() % 2 != 0:
+            k.negate()
+        negated_keys.append(k)
+
+    a_sum = sum(negated_keys)
+    all_outputs = []
+    for permutation in unique_permutations(recipients):
+        silent_payment_groups: Dict[ECPubKey, List[ECPubKey]] = {}
+        for recipient in permutation:
+            B_scan, B_m = reference.decode_silent_payment_address(recipient, hrp=hrp)
+            if B_scan in silent_payment_groups:
+                silent_payment_groups[B_scan].append(B_m)
+            else:
+                silent_payment_groups[B_scan] = [B_m]
+        outputs = []
+        for B_scan, B_m_values in silent_payment_groups.items():
+            ecdh_shared_secret = input_hash * a_sum * B_scan
+            k = 0
+            for B_m in B_m_values:
+                t_k = TaggedHash("BIP0352/SharedSecret", ecdh_shared_secret.get_bytes(False) + reference.ser_uint32(k))
+                P_km = B_m + t_k * G
+                outputs.append(P_km.get_bytes().hex())
+                k += 1
+        all_outputs.append(outputs)
+    set_of_sets = set()
+    for s in all_outputs:
+        set_of_sets.add(frozenset(s))
+    return [sorted(list(fz)) for fz in set_of_sets]
 
 def custom_sort(sublist):
     return tuple(sorted(sublist))
@@ -160,7 +157,7 @@ def generated_sender(inputs, addrs,):
     else:
         A_sum = sum(input_pubkeys)
         input_hash = reference.get_input_hash([o.outpoint for o in vins], A_sum)
-        outputs = reference.create_outputs(input_priv_keys, input_hash, addrs, hrp=HRP)
+        outputs = create_output_permutations(input_priv_keys, input_hash, addrs, hrp=HRP)
         sender['expected']['outputs'] = sort_list_of_lists(outputs)
     return deepcopy(sender)
 
@@ -247,6 +244,8 @@ def generated_recipient(inputs, output_set: List[str], scan_key: ECKey, spend_ke
     recipient['given']['vin'] = deepcopy(inputs_receiver)
     return deepcopy(recipient)
 
+# Test cases
+
 def generate_labeled_output_tests():
 
     test_cases = []
@@ -282,7 +281,6 @@ def generate_labeled_output_tests():
         test_cases.append(generated_test_case(inputs, b_scan, b_spend, addresses, labels=label_ints, comment=comments[i]))
     return test_cases
 
-
 def generate_single_output_outpoint_tests():
 
     outpoint_test_cases = [
@@ -339,7 +337,6 @@ def generate_single_output_outpoint_tests():
         test_cases.append(generated_test_case(inputs, b_scan, b_spend, [address], labels=[], comment=comments[i]))
     return test_cases
 
-
 def generate_multiple_output_tests():
 
     outpoints = [
@@ -380,78 +377,6 @@ def generate_multiple_output_tests():
     ]
     return test_cases
 
-
-# In[13]:
-
-
-def generate_paying_to_self_test():
-
-    msg = hashlib.sha256(b'message').digest()
-    aux = hashlib.sha256(b'random auxiliary data').digest()
-    outpoints = [
-        ("f4184fc596403b9d638783cf57adfe4c75c605f6356fbc91338530e9831e9e16", 0),
-        ("a1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d", 0)
-    ]
-
-    sender_bip32_seed = 'deadbeef'
-    recipient_bip32_seed = 'deadbeef'
-    i1, I1 = get_key_pair(0, seed=bytes.fromhex(sender_bip32_seed))
-    i2, I2 = get_key_pair(1)
-    input_priv_keys = [(i1, False), (i2, False)]
-    input_pub_keys = [I1, I2]
-
-    sender, recipient, test_case = new_test_case()
-    sender['given']['outpoints'] = outpoints
-    recipient['given']['outpoints'] = outpoints
-    sender['given']['input_priv_keys'].extend([i1.get_bytes().hex(), i2.get_bytes().hex()])
-    recipient['given']['input_pub_keys'].extend([I1.get_bytes(False).hex(), I2.get_bytes(False).hex()])
-
-    b_scan, b_spend, B_scan, B_spend = create_silent_payment_key_pair(bytes.fromhex(recipient_bip32_seed))
-    recipient['given']['bip32_seed'] = recipient_bip32_seed
-    recipient['given']['scan_priv_key'] = b_scan.get_bytes().hex()
-    recipient['given']['spend_priv_key'] = b_spend.get_bytes().hex()
-    address = reference.encode_silent_payment_address(B_scan, B_spend, hrp=HRP)
-
-    sender['given']['recipients'].extend([address])
-    recipient['expected']['addresses'].extend([address])
-
-    A_sum = sum(input_pub_keys)
-    deterministic_nonce = reference.get_input_hash([COutPoint(deser_txid(o[0]), o[1]) for o in outpoints], A_sum)
-    outputs = reference.create_outputs(input_priv_keys, deterministic_nonce, [address], hrp=HRP)
-    set_of_sets = set()
-    for output_set in outputs:
-        generated_set = {tuple(d.items()) for d in output_set}
-        set_of_sets.add(frozenset(generated_set))
-
-    sender['expected']['outputs'] = [[o[1][1] for o in pubkey_set] for pubkey_set in set_of_sets]
-
-    expected_sets = []
-    for output_set in set_of_sets:
-        tmp = []
-        for t in output_set:
-            o = dict(t)
-
-            pubkey = ECPubKey().set(bytes.fromhex(o['pub_key']))
-            full_private_key = b_spend.add(
-                bytes.fromhex(o['priv_key_tweak'])
-            )
-            if full_private_key.get_pubkey().get_y()%2 != 0:
-                full_private_key.negate()
-
-            sig = full_private_key.sign_schnorr(msg, aux)
-            assert pubkey.verify_schnorr(sig, msg)
-            o['signature'] = sig.hex()
-            tmp.append(t)
-        expected_sets.append(tmp)
-
-    recipient['given']['outputs'] = [o[1][1] for output_set in set_of_sets for o in output_set]
-    recipient['expected']['outputs'] = expected_sets
-    test_case['sending'].extend([sender])
-    test_case['receiving'].extend([recipient])
-
-    return test_case
-
-
 def generate_multiple_outputs_with_labels_tests():
 
     outpoints = [
@@ -500,7 +425,6 @@ def generate_multiple_outputs_with_labels_tests():
 
     return test_cases
 
-
 def generate_single_output_input_tests():
 
     outpoints = [
@@ -590,7 +514,6 @@ def generate_single_output_input_tests():
 
     return test_cases
 
-
 def generate_change_tests():
 
     outpoints = [
@@ -626,71 +549,6 @@ def generate_change_tests():
     test_case['receiving'].append(generated_recipient(inputs, test_case['sending'][0]['expected']['outputs'][0], scan1, spend1, labels=[]))
     return [test_case]
 
-
-# In[17]:
-
-
-def generate_unknown_segwit_ver_test():
-    sender, recipient, test_case = new_test_case()
-
-    msg = hashlib.sha256(b'message').digest()
-    aux = hashlib.sha256(b'random auxiliary data').digest()
-    outpoints = [
-            ("f4184fc596403b9d638783cf57adfe4c75c605f6356fbc91338530e9831e9e16", 0),
-            ("a1075db55d416d3ca199f55b6084e2115b9345e16c5cf302fc80e9d5fbf5d48d", 0),
-    ]
-    sender_bip32_seed = 'deadbeef'
-    recipient_bip32_seed = 'f00dbabe'
-    scan, spend, Scan, Spend = derive_silent_payment_key_pair(bytes.fromhex(recipient_bip32_seed))
-    address = reference.encode_silent_payment_address(Scan, Spend, hrp=HRP)
-    addresses = [address]
-
-    recipient['given']['key_material']['scan_priv_key'] = scan.get_bytes().hex()
-    recipient['given']['key_material']['spend_priv_key'] = spend.get_bytes().hex()
-
-    inputs = []
-    input_priv_keys = []
-    input_pub_keys = []
-
-    ## included
-    # p2pkh
-    i = len(inputs)
-    priv, pub = get_key_pair(i, seed=bytes.fromhex(sender_bip32_seed))
-    inputs += [{
-        'prevout': list(outpoints[i]) + [get_p2pkh_scriptsig(pub, priv), ""],
-        'scriptPubKey': get_p2pkh_scriptPubKey(pub),
-    }]
-    input_priv_keys += [(priv, False)]
-    input_pub_keys += [pub]
-
-    # unknown segwit version 
-    i = len(inputs)
-    priv, pub = get_key_pair(i, seed=bytes.fromhex(sender_bip32_seed))
-    sig = priv.sign_ecdsa(msg, low_s=False, rfc6979=True).hex()
-    inputs += [{
-        'prevout': list(outpoints[i]) + ["", serialize_witness_stack([sig, pub.get_bytes(False).hex()])],
-        'scriptPubKey': "5214" + hash160(pub.get_bytes(False)),
-    }]
-    input_priv_keys += [(priv, False)]
-    input_pub_keys += [pub]
-
-    sender['given']['recipients'] = addresses
-    sender['given']['inputs'] = add_private_keys(deepcopy(inputs), input_priv_keys)
-    # TODO: encode failure of sending explicitly 
-    test_case['sending'].extend([sender])
-
-    recipient['given']['inputs'] = inputs
-    # create plausible outputs
-    # a) using all detected keys
-    outputs_a = reference.create_outputs(input_priv_keys, reference.hash_outpoints(outpoints), addresses, hrp=HRP)
-    # b) using only p2pkh input
-    outputs_b = reference.create_outputs(input_priv_keys[:1], reference.hash_outpoints(outpoints), addresses, hrp=HRP)
-    recipient['given']['outputs'] = [outputs_a[0][0], outputs_b[0][0]]
-    test_case['receiving'].extend([recipient])
-
-    test_case["comment"] = "Skipped tx: unknown segwit version input"
-    return [test_case]
-
 def generate_taproot_with_nums_point_test():
 
     outpoints = [
@@ -1042,7 +900,6 @@ def generate_no_outputs_tests():
     return test_cases
 
 def generate_no_valid_inputs_tests():
-    sender, recipient, test_case = new_test_case()
 
     outpoints = [
         ("f4184fc596403b9d638783cf57adfe4c75c605f6356fbc91338530e9831e9e16", 0),
@@ -1088,10 +945,6 @@ def generate_no_valid_inputs_tests():
     regular_p2tr1 = get_key_pair(i, seed=bytes.fromhex(sender_bip32_seed))[1].get_bytes(True).hex()
     regular_p2tr2 = get_key_pair(i+1, seed=bytes.fromhex(sender_bip32_seed))[1].get_bytes(True).hex()
 
-    sender['expected']['outputs'] = []
-    recipient['given']['outputs'] = [regular_p2tr1, regular_p2tr2]
-    recipient['expected']['outputs'] = []
-
     test_cases = [
         generated_test_case(inputs, scan, spend, addresses, labels=[], comment="No valid inputs, sender generates no outputs"),
     ]