diff --git a/2.3-tapscript.ipynb b/2.3-tapscript.ipynb index 592bf0abd..71fb3759f 100644 --- a/2.3-tapscript.ipynb +++ b/2.3-tapscript.ipynb @@ -6,14 +6,12 @@ "metadata": {}, "outputs": [], "source": [ - "import hashlib\n", - "\n", "import util\n", "from test_framework.address import program_to_witness\n", "from test_framework.key import generate_key_pair\n", "from test_framework.messages import CTxInWitness, ser_string, sha256\n", "from test_framework.musig import generate_musig_key\n", - "from test_framework.script import tagged_hash, TapLeaf, TapTree, TaprootSignatureHash, SIGHASH_ALL_TAPROOT" + "from test_framework.script import hash160, SIGHASH_ALL_TAPROOT, tagged_hash, TapLeaf, TaprootSignatureHash, TapTree" ] }, { @@ -98,8 +96,7 @@ "privkey, pubkey = generate_key_pair()\n", "\n", "# Generate tapscript\n", - "pk_tapscript = TapLeaf()\n", - "pk_tapscript.construct_pk(pubkey)\n", + "pk_tapscript = TapLeaf().construct_pk(pubkey)\n", "\n", "print(\"Tapscript operations:\")\n", "for op in pk_tapscript.script:\n", @@ -187,8 +184,7 @@ "privkey3, pubkey3 = generate_key_pair()\n", "\n", "# Generate tapscript\n", - "csa_tapscript = TapLeaf()\n", - "csa_tapscript.construct_csa(2, [pubkey1, pubkey2, pubkey3])\n", + "csa_tapscript = TapLeaf().construct_csa(2, [pubkey1, pubkey2, pubkey3])\n", "\n", "print(\"CSA tapscript operations:\")\n", "for op in csa_tapscript.script:\n", @@ -270,7 +266,27 @@ "## Part 2: Tapscript descriptors\n", "\n", "A tapscript descriptor is a human-readable language expression which maps to a unique output. We propose each tapscript descriptor to be encapsulated by a tapscript tag `ts`, which can be updated in future tapleaf versions. \n", - "* `ts(pk(key))`, `ts(csa(key))`, ..." + "* `ts(pk(key))`, `ts(csa(key))`, ...\n", + "\n", + "### Combining public keys with hashlocks and delays\n", + "\n", + "We also propose tapscript descriptors which describe outputs combining public keys with both hashlocks and delays. The following is a brief overview of the hashlock and delay implementations used in this chapter.\n", + "\n", + "**A hashlock consumes a 32B preimage and checks the hash digest for correctness:**\n", + "\n", + "1. A 32B size guard checks that the spending preimage size is exactly 32B.\n", + "2. A `hash160` operation produces a 20B digest of the pre-image.\n", + "3. An equality check is performed for the hashed preimage and the hashlock digest.\n", + "\n", + "Where: `hash160(data) = ripemd160(sha256(data))`\n", + "\n", + "**Note:** The hashlock contains a size guard (1) to ensure that the preimage in the spending witness cannot be impractically large. Consider the example of an atomic swap between two chains. If the data push limits for the two chains differ, it will be possible that one transaction is spendable and the other is not, even though they feature identical hashlocks. The preimage may simply exceed the data push limit for one of the chains.\n", + "\n", + "**A delay is implemented with an nSequence check:**\n", + "\n", + "1. The `nSequence` field in a spending transaction input encodes a minimum delay between the confirmation of the referenced output and its spending.\n", + "2. The spending transaction must be encoded with `version >= 2` to activate `nSequence` delay encoding.\n", + "3. A `checksequenceverify` opcode in a delay-enforcing output script will check the `nSequence` value of the spending transaction input." ] }, { @@ -285,17 +301,19 @@ " * 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", - " \n", - " \n", - "* `ts(pkolder(key, delay))`\n", + " * Hashlock: `hash160(32B-preimage)`\n", + "\n", + "\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`)" ] }, @@ -306,9 +324,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", @@ -320,9 +338,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" @@ -339,17 +357,16 @@ "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().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()))" ] }, @@ -366,16 +383,22 @@ " * Note: for n < m, empty signature elements (zero) must be provided.\n", " \n", "\n", - "* `ts(csaolder(k, [key0, key1, ...], hash))`\n", - " * Witness: `[signature], [signature], ...`\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(csahasholder(k, [key0, key1, ...], hash, time))`\n", - " * Witness: `[signature], [signature], ..., [32B pre-image]`" + "* `ts(csa_delay(k, [key0, key1, ...], hash, time))`\n", + " * Witness: `[signature], [signature], ...`\n", + " * Spendable after delay (with `nSequence > delay`)\n", + "\n", + "\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`)" ] }, { @@ -385,9 +408,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." ] @@ -396,12 +419,13 @@ "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", - "* Hashlock with the preimage `sha256(b'secret')`\n", + "* `OP_HASH160` hashlock with the preimage `sha256(b'secret')`\n", + " * `OP_HASH160` is equivalent to `ripemd160(sha256(preimage))`\n", "* Delay of 20 blocks" ] }, @@ -419,22 +443,22 @@ "print(\"pubkey2: {}\\n\".format(pubkey2.get_bytes().hex()))\n", "\n", "# Method: 32B preimage - sha256(bytes)\n", - "# Method: 20B digest - hashlib.new('ripemd160', bytes).digest()\n", + "# Method: 20B digest - hash160(bytes)\n", "secret = b'secret'\n", "preimage = # TODO: implement\n", "digest = # TODO: implement\n", "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()))" ] }, @@ -478,7 +502,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." ] }, { @@ -513,7 +537,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", @@ -547,7 +571,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." ] }, { @@ -657,7 +681,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/2.4-taptree.ipynb b/2.4-taptree.ipynb index 18926dc44..2fcc1c97e 100644 --- a/2.4-taptree.ipynb +++ b/2.4-taptree.ipynb @@ -146,14 +146,10 @@ "metadata": {}, "outputs": [], "source": [ - "tapleafA = TapLeaf()\n", - "tapleafB = TapLeaf()\n", - "tapleafC = TapLeaf()\n", - "\n", "# Construct tapleafs\n", - "tapleafA.construct_pk(pubkeyA)\n", - "tapleafB.construct_pk(pubkeyB)\n", - "tapleafC.construct_pk(pubkeyC)\n", + "tapleafA = TapLeaf().construct_pk(pubkeyA)\n", + "tapleafB = TapLeaf().construct_pk(pubkeyB)\n", + "tapleafC = TapLeaf().construct_pk(pubkeyC)\n", "\n", "# Construct taptree nodes.\n", "tapbranchAB = Tapbranch(tapleafA, tapleafB)\n", diff --git a/3.1-degrading-multisig-case-study.ipynb b/3.1-degrading-multisig-case-study.ipynb index 52567be8d..b452c4913 100644 --- a/3.1-degrading-multisig-case-study.ipynb +++ b/3.1-degrading-multisig-case-study.ipynb @@ -149,18 +149,16 @@ "outputs": [], "source": [ "# Tapscripts - 2 main keys & 1 backup key\n", - "# Use construct_csaolder() to construct the tapscript\n", - "tapscript_2a, tapscript_2b, ... = # TODO: implement\n", + "# Use construct_csa_delay() to construct the tapscript\n", "delay = # TODO: implement\n", - "tapscript_2a.construct_csaolder(... # TODO: implement\n", - "tapscript_2b.construct_csaolder(... # TODO: implement\n", + "tapscript_2a = # TODO: implement\n", + "tapscript_2b = # 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 = # TODO: implement\n", + "tapscript_3b = # 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 2d8ee2d43..0a95472a6 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" ] }, { @@ -21,23 +21,22 @@ "print(\"pubkey2: {}\\n\".format(pubkey1.get_bytes().hex()))\n", "\n", "# Method: 32B preimage - sha256(bytes)\n", - "# Method: 20B digest - hashlib.new('ripemd160', bytes).digest()\n", + "# Method: 20B digest - hash160(bytes)\n", "secret = b'secret'\n", "preimage = sha256(secret)\n", - "digest = hashlib.new('ripemd160', preimage).digest()\n", + "digest = hash160(preimage)\n", "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().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 +57,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 +81,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 +107,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/2.4-taptree-solutions.ipynb b/solutions/2.4-taptree-solutions.ipynb index f209617d2..622db6632 100644 --- a/solutions/2.4-taptree-solutions.ipynb +++ b/solutions/2.4-taptree-solutions.ipynb @@ -78,14 +78,10 @@ "privkeyD, pubkeyD = generate_key_pair()\n", "\n", "# Construct Pay-to-Pubkey TapLeafs and Taptree.\n", - "TapLeafA = TapLeaf()\n", - "TapLeafB = TapLeaf()\n", - "TapLeafC = TapLeaf()\n", - "TapLeafD = TapLeaf()\n", - "TapLeafA.construct_pk(pubkeyA)\n", - "TapLeafB.construct_pk(pubkeyB)\n", - "TapLeafC.construct_pk(pubkeyC)\n", - "TapLeafD.construct_pk(pubkeyD)\n", + "TapLeafA = TapLeaf().construct_pk(pubkeyA)\n", + "TapLeafB = TapLeaf().construct_pk(pubkeyB)\n", + "TapLeafC = TapLeaf().construct_pk(pubkeyC)\n", + "TapLeafD = TapLeaf().construct_pk(pubkeyD)\n", "\n", "# Create a Taptree with tapleafs and huffman constructor.\n", "# Method: TapTree.huffman_constructor(tuple_list)\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..e2643aa51 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." ] @@ -53,28 +53,19 @@ "outputs": [], "source": [ "# Tapscripts - 2 main keys & 1 backup key\n", - "tapscript_2a = TapLeaf()\n", - "tapscript_2b = TapLeaf()\n", - "tapscript_2c = TapLeaf()\n", - "tapscript_2d = TapLeaf()\n", - "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 = TapLeaf().construct_csa_delay(3, [main_pubkeyA, main_pubkeyB, backup_pubkeyD], delay)\n", + "tapscript_2b = TapLeaf().construct_csa_delay(3, [main_pubkeyA, main_pubkeyC, backup_pubkeyD], delay)\n", + "tapscript_2c = TapLeaf().construct_csa_delay(3, [main_pubkeyB, main_pubkeyC, backup_pubkeyD], delay)\n", + "tapscript_2d = TapLeaf().construct_csa_delay(3, [main_pubkeyA, main_pubkeyB, backup_pubkeyE], delay)\n", + "tapscript_2e = TapLeaf().construct_csa_delay(3, [main_pubkeyA, main_pubkeyC, backup_pubkeyE], delay)\n", + "tapscript_2f = TapLeaf().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 = TapLeaf().construct_csa_delay(3, [main_pubkeyA, backup_pubkeyD, backup_pubkeyE], long_delay)\n", + "tapscript_3b = TapLeaf().construct_csa_delay(3, [main_pubkeyB, backup_pubkeyD, backup_pubkeyE], long_delay)\n", + "tapscript_3c = TapLeaf().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 4363bbf00..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.ripemd160(data) + 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.ripemd160(data)) + 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,36 +921,36 @@ 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.ripemd160(data) + 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) - hash_node = miniscript.ripemd160(data) + hash_node = miniscript.hash160(data) v_hash_node = miniscript.v(hash_node) 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])) @@ -1274,8 +1274,8 @@ def decode(string): tag, exprs = miniscript._parse(string) # Return terminal expressions: - # ['pk','pk_h','older','after','sha256','hash256','ripemd160','hash160','1','0']: - if tag in ['pk','pk_h', 'older', 'ripemd160', 'thresh_csa']: + # ['pk','pk_h','older','after','sha256','hash256','hash160','hash160','1','0']: + if tag in ['pk','pk_h', 'older', 'hash160', 'thresh_csa']: if tag in ['pk', 'pk_h']: key_b = bytes.fromhex(exprs[0]) @@ -1285,7 +1285,7 @@ def decode(string): n = int(exprs[0]) return getattr(miniscript, tag)(n) - elif tag in ['ripemd160']: + elif tag in ['hash160']: digest = bytes.fromhex(exprs[0]) return getattr(miniscript, tag)(digest) @@ -1357,9 +1357,9 @@ def older(n): return node_type(script=script, nsat=nsat, sat_xy=sat_xy, sat_z=sat_z, typ=typ, corr=corr, mal=mal,children=children) @staticmethod - def ripemd160(data): + def hash160(data): assert(len(data) == 20) - script = lambda x: [OP_SIZE, CScriptNum(32), OP_EQUALVERIFY, OP_RIPEMD160, data, OP_EQUAL] + script = lambda x: [OP_SIZE, CScriptNum(32), OP_EQUALVERIFY, OP_HASH160, data, OP_EQUAL] nsat = lambda x: [b'\x00'*32] # Not non-malleably. sat_xy = lambda x: [('preimage', data)] sat_z = lambda x: [False]