From 40e459588224b5657989742778c99f7bff880ff8 Mon Sep 17 00:00:00 2001 From: JamesC Date: Fri, 1 Nov 2019 16:25:13 +0100 Subject: [PATCH] Updated tapscript descriptors Ran the following shell script to subsitute old/new descriptors in repository. Order of sed invocations matter. sed -i -e 's/pkhasholder/pk_hashlock_delay/g' $(git grep -l pkhasholder) sed -i -e 's/pkhash/pk_hashlock/g' $(git grep -l pkhash) sed -i -e 's/pkolder/pk_delay/g' $(git grep -l pkolder) sed -i -e 's/csahasholder/csa_hashlock_delay/g' $(git grep -l \ csahasholder) sed -i -e 's/csahash/csa_hashlock/g' $(git grep -l csahash) sed -i -e 's/csaolder/csa_delay/g' $(git grep -l csaolder) --- 2.3-tapscript.ipynb | 60 +++++++++---------- 3.1-degrading-multisig-case-study.ipynb | 10 ++-- solutions/2.3-tapscript-solutions.ipynb | 18 +++--- ...rading-multisig-case-study-solutions.ipynb | 36 +++++------ test_framework/script.py | 60 +++++++++---------- 5 files changed, 92 insertions(+), 92 deletions(-) diff --git a/2.3-tapscript.ipynb b/2.3-tapscript.ipynb index 5949e0cbf..5d6273416 100644 --- a/2.3-tapscript.ipynb +++ b/2.3-tapscript.ipynb @@ -303,17 +303,17 @@ " * Witness: `[signature]`\n", " \n", " \n", - "* `ts(pkhash(key, 20B-hash-digest))`\n", + "* `ts(pk_hashlock(key, 20B-hash-digest))`\n", " * Witness: `[signature]`,`[32B-preimage]`\n", " * Hashlock: `hash160(32B-preimage)`\n", "\n", "\n", - "* `ts(pkolder(key, delay))`\n", + "* `ts(pk_delay(key, delay))`\n", " * Witness: `[signature]`\n", " * Spendable after delay (with `nSequence > delay`)\n", " \n", " \n", - "* `ts(pkhasholder(key, 20B-hash-digest, delay))`\n", + "* `ts(pk_hashlock_delay(key, 20B-hash-digest, delay))`\n", " * Witness: `[signature]`,`[32B-preimage]`\n", " * Hashlock: `hash160(32B-preimage)`\n", " * Spendable after delay (with `nSequence > delay`)" @@ -326,9 +326,9 @@ "We also provide pay-to-pubkey tapscript constructors for for the `TapLeaf` class. \n", "\n", "* `TapLeaf.construct_pk(ECPubKey)`\n", - "* `TapLeaf.construct_pkhash(ECPubKey, 20B-hash-digest)`\n", - "* `TapLeaf.construct_pkolder(ECPubKey, delay)`\n", - "* `TapLeaf.construct_pkhasholder(ECPubKey, 20B-hash-digest, delay)`\n", + "* `TapLeaf.construct_pk_hashlock(ECPubKey, 20B-hash-digest)`\n", + "* `TapLeaf.construct_pk_delay(ECPubKey, delay)`\n", + "* `TapLeaf.construct_pk_hashlock_delay(ECPubKey, 20B-hash-digest, delay)`\n", "\n", "The descriptor string can be recalled with:\n", "* `TapLeaf.desc`\n", @@ -340,9 +340,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### 2.3.4 Example: Generating a `pkolder` tapscript\n", + "#### 2.3.4 Example: Generating a `pk_delay` tapscript\n", "\n", - "We construct a `pkolder` tapscript with the following locking conditions:\n", + "We construct a `pk_delay` tapscript with the following locking conditions:\n", "\n", "* 2-of-2 MuSig public key\n", "* Delay of 20 blocks" @@ -359,17 +359,17 @@ "privkey2, pubkey2 = generate_key_pair()\n", "c_map, pk_musig = generate_musig_key([pubkey1, pubkey2])\n", "\n", - "# Generate pkolder tapscript\n", - "pkolder_tapscript = TapLeaf()\n", - "pkolder_tapscript.construct_pkolder(pk_musig, 20)\n", - "print(\"Tapscript descriptor:\", pkolder_tapscript.desc, \"\\n\")\n", + "# Generate pk_delay tapscript\n", + "pk_delay_tapscript = TapLeaf()\n", + "pk_delay_tapscript.construct_pk_delay(pk_musig, 20)\n", + "print(\"Tapscript descriptor:\", pk_delay_tapscript.desc, \"\\n\")\n", "\n", "print(\"Tapscript operations:\")\n", - "for op in pkolder_tapscript.script:\n", + "for op in pk_delay_tapscript.script:\n", " print(op.hex()) if isinstance(op, bytes) else print(op)\n", "\n", "print(\"\\nSatisfying witness elements:\")\n", - "for element, value in pkolder_tapscript.sat:\n", + "for element, value in pk_delay_tapscript.sat:\n", " print(\"{}, {}\".format(element, value.hex()))" ] }, @@ -387,18 +387,18 @@ " \n", "\n", "\n", - "* `ts(csahash(k, [key0, key1, ...], hash, time))`\n", + "* `ts(csa_hashlock(k, [key0, key1, ...], hash, time))`\n", " * Witness: `[signature], [signature], ..., [32B pre-image]`\n", " * Hashlock: `hash160(32B-preimage)`\n", "\n", "\n", "\n", - "* `ts(csaolder(k, [key0, key1, ...], hash, time))`\n", + "* `ts(csa_delay(k, [key0, key1, ...], hash, time))`\n", " * Witness: `[signature], [signature], ...`\n", " * Spendable after delay (with `nSequence > delay`)\n", "\n", "\n", - "* `ts(csahasholder(k, [key0, key1, ...], hash, time))`\n", + "* `ts(csa_hashlock_delay(k, [key0, key1, ...], hash, time))`\n", " * Witness: `[signature], [signature], ..., [32B pre-image]`\n", " * Hashlock: `hash160(32B-preimage)`\n", " * Spendable after delay (with `nSequence > delay`)" @@ -411,9 +411,9 @@ "We also provide checksigadd tapscript constructors for for the `TapLeaf` class. \n", "\n", "* `TapLeaf.construct_csa(k, [ECPubKey, ECPubKey, ...])`\n", - "* `TapLeaf.construct_csahash(k, [ECPubKey, ECPubKey, ...], 20B-hash-digest)`\n", - "* `TapLeaf.construct_csaolder(k, [ECPubKey, ECPubKey, ...], delay)`\n", - "* `TapLeaf.construct_csahasholder(k, [ECPubKey, ECPubKey, ...], 20B-hash-digest, delay)`\n", + "* `TapLeaf.construct_csa_hashlock(k, [ECPubKey, ECPubKey, ...], 20B-hash-digest)`\n", + "* `TapLeaf.construct_csa_delay(k, [ECPubKey, ECPubKey, ...], delay)`\n", + "* `TapLeaf.construct_csa_hashlock_delay(k, [ECPubKey, ECPubKey, ...], 20B-hash-digest, delay)`\n", "\n", "**Note:** Any single public key in CSA tapscripts can be generated with multi-party schemes such as MuSig." ] @@ -422,9 +422,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### 2.3.5 _Programming Exercise:_ Generate a 2-of-2 `csahasholder` tapscript\n", + "#### 2.3.5 _Programming Exercise:_ Generate a 2-of-2 `csa_hashlock_delay` tapscript\n", "\n", - "Construct a `csahasholder` tapscript with the following locking conditions:\n", + "Construct a `csa_hashlock_delay` tapscript with the following locking conditions:\n", "\n", "* 2-of-2 public keys\n", "* `OP_HASH160` hashlock with the preimage `sha256(b'secret')`\n", @@ -453,15 +453,15 @@ "delay = # TODO: implement\n", "\n", "# Construct tapscript\n", - "csahasholder_tapscript = # TODO: implement\n", - "print(\"Descriptor:\", csahasholder_tapscript.desc, \"\\n\")\n", + "csa_hashlock_delay_tapscript = # TODO: implement\n", + "print(\"Descriptor:\", csa_hashlock_delay_tapscript.desc, \"\\n\")\n", "\n", "print(\"Tapscript operations:\")\n", - "for op in csahasholder_tapscript.script:\n", + "for op in csa_hashlock_delay_tapscript.script:\n", " print(op.hex()) if isinstance(op, bytes) else print(op)\n", "\n", "print(\"\\nSatisfying witness elements:\")\n", - "for element, value in csahasholder_tapscript.sat:\n", + "for element, value in csa_hashlock_delay_tapscript.sat:\n", " print(\"{}, {}\".format(element, value.hex()))" ] }, @@ -505,7 +505,7 @@ "\n", "* Use the `tagged_hash()` function to compute a tagged hash.\n", "* Generate an internal public key.\n", - "* Compute the taptweak from a single `csahasholder_tapscript` commitment." + "* Compute the taptweak from a single `csa_hashlock_delay_tapscript` commitment." ] }, { @@ -540,7 +540,7 @@ "metadata": {}, "outputs": [], "source": [ - "taptree = TapTree(key=pubkey_internal, root=csahasholder_tapscript)\n", + "taptree = TapTree(key=pubkey_internal, root=csa_hashlock_delay_tapscript)\n", "segwit_v1_script, tap_tweak_constructed, control_map = taptree.construct()\n", "\n", "assert taptweak == tap_tweak_constructed\n", @@ -574,7 +574,7 @@ "source": [ "#### Example 2.3.8: Generate a single tapscript segwit v1 address\n", "\n", - "In this example, we construct segwit v1 output for spending along the single script path. We will reuse the previously generated segwit v1 witness program which has the `csahasholder` tapscript committed to it, and encode it to a bech32 address." + "In this example, we construct segwit v1 output for spending along the single script path. We will reuse the previously generated segwit v1 witness program which has the `csa_hashlock_delay` tapscript committed to it, and encode it to a bech32 address." ] }, { @@ -684,7 +684,7 @@ "source": [ "#### _Programming Exercise 2.3.12:_ Add the witness and test acceptance of the transaction\n", "\n", - "Remember to revisit the satisfying witness elements for `csahasholder_tapscript` constructed in exercise 2.3.5:\n", + "Remember to revisit the satisfying witness elements for `csa_hashlock_delay_tapscript` constructed in exercise 2.3.5:\n", "* Preimage\n", "* Signature for pubkey2\n", "* Signature for pubkey1\n", diff --git a/3.1-degrading-multisig-case-study.ipynb b/3.1-degrading-multisig-case-study.ipynb index 52567be8d..65748793a 100644 --- a/3.1-degrading-multisig-case-study.ipynb +++ b/3.1-degrading-multisig-case-study.ipynb @@ -149,18 +149,18 @@ "outputs": [], "source": [ "# Tapscripts - 2 main keys & 1 backup key\n", - "# Use construct_csaolder() to construct the tapscript\n", + "# Use construct_csa_delay() to construct the tapscript\n", "tapscript_2a, tapscript_2b, ... = # TODO: implement\n", "delay = # TODO: implement\n", - "tapscript_2a.construct_csaolder(... # TODO: implement\n", - "tapscript_2b.construct_csaolder(... # TODO: implement\n", + "tapscript_2a.construct_csa_delay(... # TODO: implement\n", + "tapscript_2b.construct_csa_delay(... # TODO: implement\n", "... # TODO: implement\n", "\n", "# Tapscripts - 1 main keys & 2 backup keys\n", "tapscript_3a, tapscript_3b, ... # TODO: implement\n", "long_delay = # TODO: implement\n", - "tapscript_3a.construct_csaolder(... # TODO: implement\n", - "tapscript_3b.construct_csaolder(... # TODO: implement\n", + "tapscript_3a.construct_csa_delay(... # TODO: implement\n", + "tapscript_3b.construct_csa_delay(... # TODO: implement\n", "... # TODO: implement\n", "\n", "# Set list of backup tapscripts\n", diff --git a/solutions/2.3-tapscript-solutions.ipynb b/solutions/2.3-tapscript-solutions.ipynb index 9ba3d43a0..7c96a9e00 100644 --- a/solutions/2.3-tapscript-solutions.ipynb +++ b/solutions/2.3-tapscript-solutions.ipynb @@ -4,7 +4,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "#### 2.3.5 _Programming Exercise:_ Generate a 2-of-2 `csahasholder` tapscript" + "#### 2.3.5 _Programming Exercise:_ Generate a 2-of-2 `csa_hashlock_delay` tapscript" ] }, { @@ -28,16 +28,16 @@ "delay = 20\n", "\n", "# Construct tapscript\n", - "csahasholder_tapscript = TapLeaf()\n", - "csahasholder_tapscript.construct_csahasholder(2, [pubkey1, pubkey2], digest, delay)\n", - "print(\"Descriptor:\", csahasholder_tapscript.desc, \"\\n\")\n", + "csa_hashlock_delay_tapscript = TapLeaf()\n", + "csa_hashlock_delay_tapscript.construct_csa_hashlock_delay(2, [pubkey1, pubkey2], digest, delay)\n", + "print(\"Descriptor:\", csa_hashlock_delay_tapscript.desc, \"\\n\")\n", "\n", "print(\"Tapscript operations:\")\n", - "for op in csahasholder_tapscript.script:\n", + "for op in csa_hashlock_delay_tapscript.script:\n", " print(op.hex()) if isinstance(op, bytes) else print(op)\n", "\n", "print(\"\\nSatisfying witness elements:\")\n", - "for element, value in csahasholder_tapscript.sat:\n", + "for element, value in csa_hashlock_delay_tapscript.sat:\n", " print(\"{}, {}\".format(element, value.hex()))" ] }, @@ -58,7 +58,7 @@ "\n", "# Method: ser_string(Cscript) prepends compact size.\n", "TAPSCRIPT_VER = bytes([0xc0])\n", - "tapleaf = tagged_hash(\"TapLeaf\", TAPSCRIPT_VER + ser_string(csahasholder_tapscript.script))\n", + "tapleaf = tagged_hash(\"TapLeaf\", TAPSCRIPT_VER + ser_string(csa_hashlock_delay_tapscript.script))\n", "taptweak = tagged_hash(\"TapTweak\", pubkey_internal.get_bytes() + tapleaf)\n", "print(\"Your constructed taptweak is: {}.\".format(taptweak.hex()))" ] @@ -82,7 +82,7 @@ " SIGHASH_ALL_TAPROOT,\n", " input_index=0,\n", " scriptpath=True,\n", - " tapscript=csahasholder_tapscript.script)\n", + " tapscript=csa_hashlock_delay_tapscript.script)\n", "\n", "# Sign with both privkeys\n", "signature1 = privkey1.sign_schnorr(sighash)\n", @@ -108,7 +108,7 @@ "# Add witness to transaction\n", "# Tip: Witness stack for script path - [satisfying elements for tapscript] [TapLeaf.script] [controlblock]\n", "# Tip: Controlblock for a tapscript in control_map[TapLeaf.script]\n", - "witness_elements = [preimage, signature2, signature1, csahasholder_tapscript.script, control_map[csahasholder_tapscript.script]]\n", + "witness_elements = [preimage, signature2, signature1, csa_hashlock_delay_tapscript.script, control_map[csa_hashlock_delay_tapscript.script]]\n", "spending_tx.wit.vtxinwit.append(CTxInWitness(witness_elements))\n", "\n", "print(\"Spending transaction:\\n{}\\n\".format(spending_tx))\n", diff --git a/solutions/3.1-degrading-multisig-case-study-solutions.ipynb b/solutions/3.1-degrading-multisig-case-study-solutions.ipynb index e47a571dd..f5519a1af 100644 --- a/solutions/3.1-degrading-multisig-case-study-solutions.ipynb +++ b/solutions/3.1-degrading-multisig-case-study-solutions.ipynb @@ -25,16 +25,16 @@ "\n", "1. Internalkey: `MuSig(pkA, pkB, pkC)`\n", "2. 2 main keys & 1 backup key:\n", - " - `csaolder(3, pkA, pkB, pkD, 3 days)`\n", - " - `csaolder(3, pkA, pkC, pkD, 3 days)`\n", - " - `csaolder(3, pkB, pkC, pkD, 3 days)`\n", - " - `csaolder(3, pkA, pkB, pkE, 3 days)`\n", - " - `csaolder(3, pkA, pkC, pkE, 3 days)`\n", - " - `csaolder(3, pkB, pkC, pkE, 3 days)`\n", + " - `csa_delay(3, pkA, pkB, pkD, 3 days)`\n", + " - `csa_delay(3, pkA, pkC, pkD, 3 days)`\n", + " - `csa_delay(3, pkB, pkC, pkD, 3 days)`\n", + " - `csa_delay(3, pkA, pkB, pkE, 3 days)`\n", + " - `csa_delay(3, pkA, pkC, pkE, 3 days)`\n", + " - `csa_delay(3, pkB, pkC, pkE, 3 days)`\n", "3. 1 main keys & 2 backup keys:\n", - " - `csaolder(3, pkA, pkD, pkE, 10 days)`\n", - " - `csaolder(3, pkB, pkD, pkE, 10 days)`\n", - " - `csaolder(3, pkC, pkD, pkE, 10 days)`\n", + " - `csa_delay(3, pkA, pkD, pkE, 10 days)`\n", + " - `csa_delay(3, pkB, pkD, pkE, 10 days)`\n", + " - `csa_delay(3, pkC, pkD, pkE, 10 days)`\n", "\n", "**Note: since backup keys cannot participate in MuSig, all possible key combinations are enumerated in different leaves of the Taptree." ] @@ -60,21 +60,21 @@ "tapscript_2e = TapLeaf()\n", "tapscript_2f = TapLeaf()\n", "delay = 3*24*6\n", - "tapscript_2a.construct_csaolder(3, [main_pubkeyA, main_pubkeyB, backup_pubkeyD], delay)\n", - "tapscript_2b.construct_csaolder(3, [main_pubkeyA, main_pubkeyC, backup_pubkeyD], delay)\n", - "tapscript_2c.construct_csaolder(3, [main_pubkeyB, main_pubkeyC, backup_pubkeyD], delay)\n", - "tapscript_2d.construct_csaolder(3, [main_pubkeyA, main_pubkeyB, backup_pubkeyE], delay)\n", - "tapscript_2e.construct_csaolder(3, [main_pubkeyA, main_pubkeyC, backup_pubkeyE], delay)\n", - "tapscript_2f.construct_csaolder(3, [main_pubkeyB, main_pubkeyC, backup_pubkeyE], delay)\n", + "tapscript_2a.construct_csa_delay(3, [main_pubkeyA, main_pubkeyB, backup_pubkeyD], delay)\n", + "tapscript_2b.construct_csa_delay(3, [main_pubkeyA, main_pubkeyC, backup_pubkeyD], delay)\n", + "tapscript_2c.construct_csa_delay(3, [main_pubkeyB, main_pubkeyC, backup_pubkeyD], delay)\n", + "tapscript_2d.construct_csa_delay(3, [main_pubkeyA, main_pubkeyB, backup_pubkeyE], delay)\n", + "tapscript_2e.construct_csa_delay(3, [main_pubkeyA, main_pubkeyC, backup_pubkeyE], delay)\n", + "tapscript_2f.construct_csa_delay(3, [main_pubkeyB, main_pubkeyC, backup_pubkeyE], delay)\n", "\n", "# Tapscripts - 1 main keys & 2 backup keys\n", "tapscript_3a = TapLeaf()\n", "tapscript_3b = TapLeaf()\n", "tapscript_3c = TapLeaf()\n", "long_delay = 10*24*6\n", - "tapscript_3a.construct_csaolder(3, [main_pubkeyA, backup_pubkeyD, backup_pubkeyE], long_delay)\n", - "tapscript_3b.construct_csaolder(3, [main_pubkeyB, backup_pubkeyD, backup_pubkeyE], long_delay)\n", - "tapscript_3c.construct_csaolder(3, [main_pubkeyC, backup_pubkeyD, backup_pubkeyE], long_delay)\n", + "tapscript_3a.construct_csa_delay(3, [main_pubkeyA, backup_pubkeyD, backup_pubkeyE], long_delay)\n", + "tapscript_3b.construct_csa_delay(3, [main_pubkeyB, backup_pubkeyD, backup_pubkeyE], long_delay)\n", + "tapscript_3c.construct_csa_delay(3, [main_pubkeyC, backup_pubkeyD, backup_pubkeyE], long_delay)\n", "\n", "# Set list of backup tapscripts\n", "# Suggestion: Include tapscripts with 3d timelocks first, then those with 10d timelocks\n", diff --git a/test_framework/script.py b/test_framework/script.py index 92a1a9adc..7510f7826 100644 --- a/test_framework/script.py +++ b/test_framework/script.py @@ -888,29 +888,29 @@ def construct_pk(self, key): #ECPubKey self.desc = TapLeaf._desc_serializer('pk',key.get_bytes().hex()) return self - def construct_pkolder(self, key, delay): #ECPubKey, int + def construct_pk_delay(self, key, delay): #ECPubKey, int pk_node = miniscript.pk(key.get_bytes()) older_node = miniscript.older(delay) v_c_pk_node = miniscript.v(miniscript.c(pk_node)) self._set_miniscript(miniscript.and_v(v_c_pk_node, older_node)) - self.desc = TapLeaf._desc_serializer('pkolder', key.get_bytes().hex(), str(delay)) + self.desc = TapLeaf._desc_serializer('pk_delay', key.get_bytes().hex(), str(delay)) return self - def construct_pkhash(self, key, data): #ECPubKey, 20B, int + def construct_pk_hashlock(self, key, data): #ECPubKey, 20B, int pk_node = miniscript.pk(key.get_bytes()) hash_node = miniscript.hash160(data) v_c_pk_node = miniscript.v(miniscript.c(pk_node)) self._set_miniscript(miniscript.and_v(v_c_pk_node, hash_node)) - self.desc = TapLeaf._desc_serializer('pkhash', key.get_bytes().hex(), data.hex()) + self.desc = TapLeaf._desc_serializer('pk_hashlock', key.get_bytes().hex(), data.hex()) return self - def construct_pkhasholder(self, key, data, delay): #ECPubKey, 20B, int + def construct_pk_hashlock_delay(self, key, data, delay): #ECPubKey, 20B, int pk_node = miniscript.pk(key.get_bytes()) older_node = miniscript.older(delay) v_hash_node = miniscript.v(miniscript.hash160(data)) v_c_pk_node = miniscript.v(miniscript.c(pk_node)) self._set_miniscript(miniscript.and_v(v_c_pk_node, miniscript.and_v(v_hash_node, older_node))) - self.desc = TapLeaf._desc_serializer('pkhasholder', key.get_bytes().hex(), data.hex(),str(delay)) + self.desc = TapLeaf._desc_serializer('pk_hashlock_delay', key.get_bytes().hex(), data.hex(),str(delay)) return self def construct_csa(self, k, pkv): @@ -921,27 +921,27 @@ def construct_csa(self, k, pkv): self.desc = TapLeaf._desc_serializer('csa', str(k), *keys_string) return self - def construct_csaolder(self, k, pkv, delay): + def construct_csa_delay(self, k, pkv, delay): keys_data = [key.get_bytes() for key in pkv] thresh_csa_node = miniscript.thresh_csa(k, *keys_data) v_thresh_csa_node = miniscript.v(thresh_csa_node) older_node = miniscript.older(delay) self._set_miniscript(miniscript.and_v(v_thresh_csa_node, older_node)) keys_string = [data.hex() for data in keys_data] - self.desc = TapLeaf._desc_serializer('csaolder', str(k), *keys_string, str(delay)) + self.desc = TapLeaf._desc_serializer('csa_delay', str(k), *keys_string, str(delay)) return self - def construct_csahash(self, k, pkv, data): + def construct_csa_hashlock(self, k, pkv, data): keys_data = [key.get_bytes() for key in pkv] thresh_csa_node = miniscript.thresh_csa(k, *keys_data) v_thresh_csa_node = miniscript.v(thresh_csa_node) hash_node = miniscript.hash160(data) self._set_miniscript(miniscript.and_v(v_thresh_csa_node, hash_node)) keys_string = [data.hex() for data in keys_data] - self.desc = TapLeaf._desc_serializer('csahash', str(k), *keys_string, data.hex()) + self.desc = TapLeaf._desc_serializer('csa_hashlock', str(k), *keys_string, data.hex()) return self - def construct_csahasholder(self, k, pkv, data, delay): + def construct_csa_hashlock_delay(self, k, pkv, data, delay): keys_data = [key.get_bytes() for key in pkv] thresh_csa_node = miniscript.thresh_csa(k, *keys_data) v_thresh_csa_node = miniscript.v(thresh_csa_node) @@ -950,7 +950,7 @@ def construct_csahasholder(self, k, pkv, data, delay): older_node = miniscript.older(delay) self._set_miniscript(miniscript.and_v(v_thresh_csa_node, miniscript.and_v(v_hash_node, older_node))) keys_string = [data.hex() for data in keys_data] - self.desc = TapLeaf._desc_serializer('csahasholder', str(k), *keys_string, data.hex(),str(delay)) + self.desc = TapLeaf._desc_serializer('csa_hashlock_delay', str(k), *keys_string, data.hex(),str(delay)) return self def _set_miniscript(self, miniscript): @@ -978,28 +978,28 @@ def from_desc(self,string): pk.set(bytes.fromhex(args[0])) self.construct_pk(pk) - elif tss[:8] == 'pkolder(': - expr_s = ParseDesc(tss, 'pkolder' ,'(' ,')') + elif tss[:8] == 'pk_delay(': + expr_s = ParseDesc(tss, 'pk_delay' ,'(' ,')') args = self._param_parser(expr_s) pk = ECPubKey() pk.set(bytes.fromhex(args[0])) - self.construct_pkolder(pk, int(args[1])) + self.construct_pk_delay(pk, int(args[1])) - elif tss[:7] == 'pkhash(': - expr_s = ParseDesc(tss, 'pkhash' ,'(' ,')') + elif tss[:7] == 'pk_hashlock(': + expr_s = ParseDesc(tss, 'pk_hashlock' ,'(' ,')') args = self._param_parser(expr_s) pk = ECPubKey() pk.set(bytes.fromhex(args[0])) data = bytes.fromhex(args[1]) - self.construct_pkhash(pk, data) + self.construct_pk_hashlock(pk, data) - elif tss[:12] == 'pkhasholder(': - expr_s = ParseDesc(tss, 'pkhasholder' ,'(' ,')') + elif tss[:12] == 'pk_hashlock_delay(': + expr_s = ParseDesc(tss, 'pk_hashlock_delay' ,'(' ,')') args = self._param_parser(expr_s) pk = ECPubKey() pk.set(bytes.fromhex(args[0])) data = bytes.fromhex(args[1]) - self.construct_pkhasholder(pk, data, int(args[2])) + self.construct_pk_hashlock_delay(pk, data, int(args[2])) elif tss[:4] == 'csa(': expr_s = ParseDesc(tss, 'csa' ,'(' ,')') @@ -1012,8 +1012,8 @@ def from_desc(self,string): pkv.append(pk) self.construct_csa(k, pkv) - elif tss[:9] == 'csaolder(': - expr_s = ParseDesc(tss, 'csaolder' ,'(' ,')') + elif tss[:9] == 'csa_delay(': + expr_s = ParseDesc(tss, 'csa_delay' ,'(' ,')') args = self._param_parser(expr_s) k = int(args[0]) pkv = [] @@ -1022,10 +1022,10 @@ def from_desc(self,string): pk.set(bytes.fromhex(key_string)) pkv.append(pk) delay = int(args[-1]) - self.construct_csaolder(k, pkv, delay) + self.construct_csa_delay(k, pkv, delay) - elif tss[:8] == 'csahash(': - expr_s = ParseDesc(tss, 'csahash' ,'(' ,')') + elif tss[:8] == 'csa_hashlock(': + expr_s = ParseDesc(tss, 'csa_hashlock' ,'(' ,')') args = self._param_parser(expr_s) k = int(args[0]) pkv = [] @@ -1034,10 +1034,10 @@ def from_desc(self,string): pk.set(bytes.fromhex(key_string)) pkv.append(pk) data = bytes.fromhex(args[-1]) - self.construct_csahash(k, pkv, data) + self.construct_csa_hashlock(k, pkv, data) - elif tss[:13] == 'csahasholder(': - expr_s = ParseDesc(tss, 'csahasholder' ,'(' ,')') + elif tss[:13] == 'csa_hashlock_delay(': + expr_s = ParseDesc(tss, 'csa_hashlock_delay' ,'(' ,')') args = self._param_parser(expr_s) k = int(args[0]) pkv = [] @@ -1047,7 +1047,7 @@ def from_desc(self,string): pkv.append(pk) data = bytes.fromhex(args[-2]) delay = int(args[-1]) - self.construct_csahasholder(k, pkv, data, delay) + self.construct_csa_hashlock_delay(k, pkv, data, delay) elif tss[:4] =='raw(': self.script = CScript(binascii.unhexlify(tss[4:-1]))