├── .nojekyll
├── LICENSE
├── README.md
├── combinations.js
├── index.html
└── old-index.html


/.nojekyll:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 | Creative Commons Legal Code
  2 | 
  3 | CC0 1.0 Universal
  4 | 
  5 |     CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE
  6 |     LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN
  7 |     ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS
  8 |     INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES
  9 |     REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS
 10 |     PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM
 11 |     THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED
 12 |     HEREUNDER.
 13 | 
 14 | Statement of Purpose
 15 | 
 16 | The laws of most jurisdictions throughout the world automatically confer
 17 | exclusive Copyright and Related Rights (defined below) upon the creator
 18 | and subsequent owner(s) (each and all, an "owner") of an original work of
 19 | authorship and/or a database (each, a "Work").
 20 | 
 21 | Certain owners wish to permanently relinquish those rights to a Work for
 22 | the purpose of contributing to a commons of creative, cultural and
 23 | scientific works ("Commons") that the public can reliably and without fear
 24 | of later claims of infringement build upon, modify, incorporate in other
 25 | works, reuse and redistribute as freely as possible in any form whatsoever
 26 | and for any purposes, including without limitation commercial purposes.
 27 | These owners may contribute to the Commons to promote the ideal of a free
 28 | culture and the further production of creative, cultural and scientific
 29 | works, or to gain reputation or greater distribution for their Work in
 30 | part through the use and efforts of others.
 31 | 
 32 | For these and/or other purposes and motivations, and without any
 33 | expectation of additional consideration or compensation, the person
 34 | associating CC0 with a Work (the "Affirmer"), to the extent that he or she
 35 | is an owner of Copyright and Related Rights in the Work, voluntarily
 36 | elects to apply CC0 to the Work and publicly distribute the Work under its
 37 | terms, with knowledge of his or her Copyright and Related Rights in the
 38 | Work and the meaning and intended legal effect of CC0 on those rights.
 39 | 
 40 | 1. Copyright and Related Rights. A Work made available under CC0 may be
 41 | protected by copyright and related or neighboring rights ("Copyright and
 42 | Related Rights"). Copyright and Related Rights include, but are not
 43 | limited to, the following:
 44 | 
 45 |   i. the right to reproduce, adapt, distribute, perform, display,
 46 |      communicate, and translate a Work;
 47 |  ii. moral rights retained by the original author(s) and/or performer(s);
 48 | iii. publicity and privacy rights pertaining to a person's image or
 49 |      likeness depicted in a Work;
 50 |  iv. rights protecting against unfair competition in regards to a Work,
 51 |      subject to the limitations in paragraph 4(a), below;
 52 |   v. rights protecting the extraction, dissemination, use and reuse of data
 53 |      in a Work;
 54 |  vi. database rights (such as those arising under Directive 96/9/EC of the
 55 |      European Parliament and of the Council of 11 March 1996 on the legal
 56 |      protection of databases, and under any national implementation
 57 |      thereof, including any amended or successor version of such
 58 |      directive); and
 59 | vii. other similar, equivalent or corresponding rights throughout the
 60 |      world based on applicable law or treaty, and any national
 61 |      implementations thereof.
 62 | 
 63 | 2. Waiver. To the greatest extent permitted by, but not in contravention
 64 | of, applicable law, Affirmer hereby overtly, fully, permanently,
 65 | irrevocably and unconditionally waives, abandons, and surrenders all of
 66 | Affirmer's Copyright and Related Rights and associated claims and causes
 67 | of action, whether now known or unknown (including existing as well as
 68 | future claims and causes of action), in the Work (i) in all territories
 69 | worldwide, (ii) for the maximum duration provided by applicable law or
 70 | treaty (including future time extensions), (iii) in any current or future
 71 | medium and for any number of copies, and (iv) for any purpose whatsoever,
 72 | including without limitation commercial, advertising or promotional
 73 | purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each
 74 | member of the public at large and to the detriment of Affirmer's heirs and
 75 | successors, fully intending that such Waiver shall not be subject to
 76 | revocation, rescission, cancellation, termination, or any other legal or
 77 | equitable action to disrupt the quiet enjoyment of the Work by the public
 78 | as contemplated by Affirmer's express Statement of Purpose.
 79 | 
 80 | 3. Public License Fallback. Should any part of the Waiver for any reason
 81 | be judged legally invalid or ineffective under applicable law, then the
 82 | Waiver shall be preserved to the maximum extent permitted taking into
 83 | account Affirmer's express Statement of Purpose. In addition, to the
 84 | extent the Waiver is so judged Affirmer hereby grants to each affected
 85 | person a royalty-free, non transferable, non sublicensable, non exclusive,
 86 | irrevocable and unconditional license to exercise Affirmer's Copyright and
 87 | Related Rights in the Work (i) in all territories worldwide, (ii) for the
 88 | maximum duration provided by applicable law or treaty (including future
 89 | time extensions), (iii) in any current or future medium and for any number
 90 | of copies, and (iv) for any purpose whatsoever, including without
 91 | limitation commercial, advertising or promotional purposes (the
 92 | "License"). The License shall be deemed effective as of the date CC0 was
 93 | applied by Affirmer to the Work. Should any part of the License for any
 94 | reason be judged legally invalid or ineffective under applicable law, such
 95 | partial invalidity or ineffectiveness shall not invalidate the remainder
 96 | of the License, and in such case Affirmer hereby affirms that he or she
 97 | will not (i) exercise any of his or her remaining Copyright and Related
 98 | Rights in the Work or (ii) assert any associated claims and causes of
 99 | action with respect to the Work, in either case contrary to Affirmer's
100 | express Statement of Purpose.
101 | 
102 | 4. Limitations and Disclaimers.
103 | 
104 |  a. No trademark or patent rights held by Affirmer are waived, abandoned,
105 |     surrendered, licensed or otherwise affected by this document.
106 |  b. Affirmer offers the Work as-is and makes no representations or
107 |     warranties of any kind concerning the Work, express, implied,
108 |     statutory or otherwise, including without limitation warranties of
109 |     title, merchantability, fitness for a particular purpose, non
110 |     infringement, or the absence of latent or other defects, accuracy, or
111 |     the present or absence of errors, whether or not discoverable, all to
112 |     the greatest extent permissible under applicable law.
113 |  c. Affirmer disclaims responsibility for clearing rights of other persons
114 |     that may apply to the Work or any use thereof, including without
115 |     limitation any person's Copyright and Related Rights in the Work.
116 |     Further, Affirmer disclaims responsibility for obtaining any necessary
117 |     consents, permissions or other rights required for any use of the
118 |     Work.
119 |  d. Affirmer understands and acknowledges that Creative Commons is not a
120 |     party to this document and has no duty or obligation with respect to
121 |     this CC0 or use of the Work.
122 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Bitvm workshop
 2 | Basic bitvm app that demonstrates 5 principles of bitvm:
 3 | - Multiparty computation
 4 | - State transfer
 5 | - Off chain computation
 6 | - Fraud proofs
 7 | - Tapleaf guards
 8 | 
 9 | # Warning
10 | The code is a work in progress and doesn't fully work yet, do not expect much
11 | 
12 | # Workshop video
13 | https://www.youtube.com/watch?v=LwH9fhY4uGA
14 | 
15 | # Slideshow
16 | http://tinyurl.com/bitvm-workshop
17 | 
18 | # How to use
19 | - Open up [Mutiny Textnet Tx Broadcaster](https://mutinynet.com/tx/push)
20 | - And [Mutiny Testnet Faucet](https://faucet.mutinynet.com/)
21 | - [Open bit tac toe by clicking this link](https://supertestnet.github.io/bitvm-workshop/)
22 | - On the bit tac toe page, open your web browser's console (ctrl+shift+i in firefox, otherwise Menu > More Tools > Web Developer Tools > Console)
23 | - Click Play and follow the promps. They are a bit confusing so consider watching [this video](https://www.youtube.com/watch?v=LwH9fhY4uGA) to see how it's *supposed* to work. And remember, this software is only half baked, so be prepared for disappointment
24 | 
25 | # Resources
26 | - whitepaper: https://bitvm.org/bitvm.pdf
27 | - WIP implementation: https://github.com/supertestnet/tapleaf-circuits/
28 | - bitcoin magazine explainer: https://bitcoinmagazine.com/technical/the-big-deal-with-bitvm-arbitrary-computation-now-possible-on-bitcoin-without-a-fork
29 | - simple explainer: https://github.com/fiksn/bitvm-explained
30 | - LN+ explainer: https://lightningnetwork.plus/posts/450
31 | - base58 explainer: https://twitter.com/base58btc/status/1711728898730242112
32 | 


--------------------------------------------------------------------------------
/combinations.js:
--------------------------------------------------------------------------------
  1 | /*
  2 |  *  Licensed under the MIT license.
  3 |  *  http://www.opensource.org/licenses/mit-license.php
  4 |  *
  5 |  *  References:
  6 |  *    http://www.ruby-doc.org/core-2.0/Array.html#method-i-combination
  7 |  *    http://www.ruby-doc.org/core-2.0/Array.html#method-i-permutation
  8 |  */
  9 | 
 10 | (function(root, factory) {
 11 |   if (typeof define === 'function' && define.amd) {
 12 |     define([], factory)
 13 |   } else if (typeof exports === 'object') {
 14 |     module.exports = factory()
 15 |   } else {
 16 |     root.G = factory()
 17 |   }
 18 | }(this, function() {
 19 | 
 20 | 'use strict'
 21 | 
 22 | /** @exports G */
 23 | const G = {
 24 | 
 25 |   clones: false,
 26 | 
 27 |   /**
 28 |    * Calculates a factorial
 29 |    * @param {Number} n - The number to operate the factorial on.
 30 |    * @returns {Number} n!
 31 |    */
 32 |   factorial: function factorial(n) {
 33 |     for (var ans = 1; n; ans *= n--);
 34 |     return ans
 35 |   },
 36 | 
 37 |   /**
 38 |    * Converts a number to the factorial number system. Digits are in least significant order.
 39 |    * @param {Number} n - Integer in base 10
 40 |    * @returns {Array} digits of n in factoradic in least significant order
 41 |    */
 42 |   factoradic: function factoradic(n) {
 43 |     let radix = 1
 44 |     for (var digit = 1; radix < n; radix *= ++digit);
 45 |     if (radix > n) radix /= digit--
 46 |     let result = [0]
 47 |     for (; digit; radix /= digit--) {
 48 |       result[digit] = Math.floor(n / radix)
 49 |       n %= radix
 50 |     }
 51 |     return result
 52 |   },
 53 | 
 54 |   /**
 55 |    * Calculates the number of possible permutations of "k" elements in a set of size "n".
 56 |    * @param {Number} n - Number of elements in the set.
 57 |    * @param {Number} k - Number of elements to choose from the set.
 58 |    * @returns {Number} n P k
 59 |    */
 60 |   P: function P(n, k) {
 61 |     return this.factorial(n) / this.factorial(n - k)
 62 |   },
 63 | 
 64 |   /**
 65 |    * Calculates the number of possible combinations of "k" elements in a set of size "n".
 66 |    * @param {Number} n - Number of elements in the set.
 67 |    * @param {Number} k - Number of elements to choose from the set.
 68 |    * @returns {Number} n C k
 69 |    */
 70 |   C: function C(n, k) {
 71 |     return this.P(n, k) / this.factorial(k)
 72 |   },
 73 | 
 74 |   /**
 75 |    * Higher level method for counting number of possible combinations of "k" elements from a set of size "n".
 76 |    * @param {Number} n - Number of elements in the set.
 77 |    * @param {Number} k - Number of elements to choose from the set.
 78 |    * @param {Object} [options]
 79 |    * @param {Boolean} options.replace - Is replacement allowed after each choice?
 80 |    * @param {Boolean} options.ordered - Does the order of the choices matter?
 81 |    * @returns {Number} Number of possible combinations.
 82 |    */
 83 |   choices: function choices(n, k, options = {}) {
 84 |     if (options.replace) {
 85 |       if (options.ordered) {
 86 |         return Math.pow(n, k)
 87 |       } else {
 88 |         return this.C(n + k - 1, k)
 89 |       }
 90 |     } else {
 91 |       if (options.ordered) {
 92 |         return this.P(n, k)
 93 |       } else {
 94 |         return this.C(n, k)
 95 |       }
 96 |     }
 97 |   },
 98 | 
 99 |   /**
100 |    * Generates all combinations of a set.
101 |    * @param {Array|String} arr - The set of elements.
102 |    * @param {Number} [size=arr.length] - Number of elements to choose from the set.
103 |    * @returns {Generator} yields each combination as an array
104 |    */
105 |   combination: function* combination(arr, size = arr.length) {
106 |     let that = this
107 |     let end = arr.length - 1
108 |     let data = []
109 |     yield* combinationUtil(0, 0)
110 |     function* combinationUtil(start, index) {
111 |       if (index === size) { // Current combination is ready to be processed, yield it
112 |         return yield that.clones ? data.slice() : data // .slice() is a JS idiom for shallow cloning an array
113 |       }
114 |       // replace index with all possible elements. The condition
115 |       // "end - i + 1 >= size - index" makes sure that including one element
116 |       // at index will make a combination with remaining elements
117 |       // at remaining positions
118 |       for (let i = start; i <= end && end - i + 1 >= size - index; i++) {
119 |         data[index] = arr[i]
120 |         yield* combinationUtil(i + 1, index + 1)
121 |       }
122 |     }
123 |   },
124 | 
125 |   /**
126 |    * Generates all permutations of a set.
127 |    * @param {Array|String} arr - The set of elements.
128 |    * @param {Number} [size=arr.length] - Number of elements to choose from the set.
129 |    * @returns {Generator} yields each permutation as an array
130 |    */
131 |   permutation: function* permutation(arr, size = arr.length) {
132 |     let that = this
133 |     let len = arr.length
134 |     if (size === len) { // switch to Heap's algorithm. it's more efficient
135 |       return yield* heapsAlg(arr, that.clones)
136 |     }
137 |     let data = []
138 |     let indecesUsed = [] // permutations do not repeat elements. keep track of the indeces of the elements already used
139 |     yield* permutationUtil(0)
140 |     function* permutationUtil(index) {
141 |       if (index === size) {
142 |         return yield that.clones ? data.slice() : data
143 |       }
144 |       for (let i = 0; i < len; i++) {
145 |         if (!indecesUsed[i]) {
146 |           indecesUsed[i] = true
147 |           data[index] = arr[i]
148 |           yield *permutationUtil(index + 1)
149 |           indecesUsed[i] = false
150 |         }
151 |       }
152 |     }
153 |   },
154 | 
155 |   /**
156 |   * Generates all possible subsets of a set (a.k.a. power set).
157 |   * @param {Array|String} arr - The set of elements.
158 |   * @returns {Generator} yields each subset as an array
159 |   */
160 |   powerSet: function* powerSet(arr) {
161 |     let that = this
162 |     let len = arr.length
163 |     let data = []
164 |     yield* powerUtil(0, 0)
165 |     function* powerUtil(start, index) {
166 |       data.length = index
167 |       yield that.clones ? data.slice() : data
168 |       if (index === len) {
169 |         return
170 |       }
171 |       for (let i = start; i < len; i++) {
172 |         data[index] = arr[i]
173 |         yield* powerUtil(i + 1, index + 1)
174 |       }
175 |     }
176 |   },
177 | 
178 |   /**
179 |    * Generates the permutation of the combinations of a set.
180 |    * @param {Array|String} arr - The set of elements.
181 |    * @returns {Generator} yields each permutation as an array
182 |    */
183 |   permutationCombination: function* permutationCombination(arr) {
184 |     let that = this
185 |     let len = arr.length
186 |     let data = []
187 |     let indecesUsed = []
188 |     yield* permutationUtil(0)
189 |     function* permutationUtil(index) {
190 |       data.length = index
191 |       yield that.clones ? data.slice() : data
192 |       if (index === len) {
193 |         return
194 |       }
195 |       for (let i = 0; i < len; i++) {
196 |         if (!indecesUsed[i]) {
197 |           indecesUsed[i] = true
198 |           data[index] = arr[i]
199 |           yield *permutationUtil(index + 1)
200 |           indecesUsed[i] = false
201 |         }
202 |       }
203 |     }
204 |   },
205 | 
206 |   /**
207 |    * Generates all possible "numbers" from the digits of a set.
208 |    * @param {Array|String} arr - The set of digits.
209 |    * @param {Number} [size=arr.length] - How many digits will be in the numbers.
210 |    * @returns {Generator} yields all digits as an array
211 |    */
212 |   baseN: function* baseN(arr, size = arr.length) {
213 |     let that = this
214 |     let len = arr.length
215 |     let data = []
216 |     yield* baseNUtil(0)
217 |     function* baseNUtil(index) {
218 |       if (index === size) {
219 |         return yield that.clones ? data.slice() : data
220 |       }
221 |       for (let i = 0; i < len; i++) {
222 |         data[index] = arr[i]
223 |         yield* baseNUtil(index + 1)
224 |       }
225 |     }
226 |   },
227 | 
228 |   /**
229 |    * Infinite generator for all possible "numbers" from a set of digits.
230 |    * @param {Array|String} arr - The set of digits
231 |    * @returns {Generator} yields all digits as an array
232 |    */
233 |   baseNAll: function* permutationAll(arr) {
234 |     for (let len = 1; true; len++) {
235 |       yield* this.baseN(arr, len)
236 |     }
237 |   },
238 | 
239 |   /**
240 |    * Generates the cartesian product of the sets.
241 |    * @param {...(Array|String)} sets - variable number of sets of n elements.
242 |    * @returns {Generator} yields each product as an array
243 |    */
244 |   cartesian: function* cartesian(...sets) {
245 |     let that = this
246 |     let data = []
247 |     yield* cartesianUtil(0)
248 |     function* cartesianUtil(index) {
249 |       if (index === sets.length) {
250 |         return yield that.clones ? data.slice() : data
251 |       }
252 |       for (let i = 0; i < sets[index].length; i++) {
253 |         data[index] = sets[index][i]
254 |         yield* cartesianUtil(index + 1)
255 |       }
256 |     }
257 |   },
258 | 
259 |   /**
260 |    * Shuffles an array in place using the Fisher–Yates shuffle.
261 |    * @param {Array} arr - A set of elements.
262 |    * @returns {Array} a random, unbiased perutation of arr
263 |    */
264 |   shuffle: function shuffle(arr) {
265 |     for (let i = arr.length - 1; i > 0; i--) {
266 |       let j = Math.floor(Math.random() * (i + 1))
267 |       swap(arr, i, j)
268 |     }
269 |     return arr
270 |   }
271 | 
272 | }
273 | 
274 | 
275 | let clone = { clones: true }
276 | clone.combination = G.combination
277 | clone.permutation = G.permutation
278 | clone.powerSet = G.powerSet
279 | clone.permutationCombination = G.permutationCombination
280 | clone.baseN = G.baseN
281 | clone.baseNAll = G.baseNAll
282 | clone.cartesian = G.cartesian
283 | 
284 | G.clone = clone
285 | 
286 | 
287 | 
288 | /*
289 |  * More efficient alorithm for permutations of All elements in an array. Doesn't
290 |  * work for "sub-permutations", e.g. permutations of 3 elements from [1, 2, 3, 4, 5]
291 |  */
292 | function* heapsAlg(arr, clone) {
293 |   let size = arr.length
294 |   if (typeof arr === 'string') {
295 |     arr = arr.split('')
296 |   }
297 |   yield* heapsUtil(0)
298 |   function* heapsUtil(index) {
299 |     if (index === size) {
300 |       return yield clone ? arr.slice() : arr
301 |     }
302 | 
303 |     for (let j = index; j < size; j++) {
304 |       swap(arr, index, j)
305 |       yield* heapsUtil(index + 1)
306 |       swap(arr, index, j)
307 |     }
308 |   }
309 | }
310 | 
311 | /*
312 |  * Swaps two array elements.
313 |  */
314 | function swap(arr, i, j) {
315 |   let len = arr.length
316 |   if (i >= len || j >= len) {
317 |     console.warn('Swapping an array\'s elements past its length.')
318 |   }
319 |   let temp = arr[j]
320 |   arr[j] = arr[i]
321 |   arr[i] = temp
322 |   return arr
323 | }
324 | 
325 | 
326 | return G
327 | 
328 | }));


--------------------------------------------------------------------------------
/index.html:
--------------------------------------------------------------------------------
   1 | <!DOCTYPE html>
   2 | <html>
   3 | <head>
   4 |     <meta charset="UTF-8">
   5 |     <meta name="viewport" content="width=device-width, user-scalable=no">
   6 |     <script src="https://unpkg.com/@cmdcode/tapscript@1.4.0"></script>
   7 |     <script src="https://bundle.run/noble-secp256k1@1.2.14"></script>
   8 |     <script src="https://unpkg.com/@dashincubator/ripemd160/ripemd160.js"></script>
   9 |     <script src="https://supertestnet.github.io/bitvm-workshop/combinations.js"></script>
  10 |     <script>
  11 |         var $ = document.querySelector.bind( document );
  12 |         var $$ = document.querySelectorAll.bind( document );
  13 |         var hexToBytes = hex => Uint8Array.from( hex.match( /.{1,2}/g ).map( byte => parseInt( byte, 16 ) ) );
  14 |         var bytesToHex = bytes => bytes.reduce( ( str, byte ) => str + byte.toString( 16 ).padStart( 2, "0" ), "" );
  15 |         var rmd160 = s => {
  16 |             if ( typeof s == "string" ) s = new TextEncoder().encode( s );
  17 |             var hash = RIPEMD160.create();
  18 |             hash.update( new Uint8Array( s ) );
  19 |             return bytesToHex( hash.digest() );
  20 |         }
  21 |         var waitASec=num=>new Promise(res=>setTimeout(res,num*1000));
  22 |         var waitForMove = async () => {
  23 |             if ( !num ) await waitASec( 1 );
  24 |             return num || waitForMove();
  25 |         }
  26 |     </script>
  27 |     <script>
  28 |         var contract = [];
  29 |         var hashes = [];
  30 |         var fraud_occurred = false;
  31 |         var victory_achieved = false;
  32 |         var alice = {
  33 |             privkey: "ab".repeat( 32 ),
  34 |             scripts: [],
  35 |             trees: [],
  36 |             preimages: [],
  37 |             hashes: [],
  38 |             accept_preimages: [],
  39 |             accept_hashes: [],
  40 |             bobs_moves: [],
  41 |             bobs_squares: [],
  42 |             bobs_acks: [],
  43 |         }
  44 |         alice[ "pubkey" ] = nobleSecp256k1.getPublicKey( alice[ "privkey" ], true ).substring( 2 );
  45 |         var funding_address = tapscript.Address.p2tr.fromPubKey( alice[ "pubkey" ], 'testnet' );
  46 |         var alices_preimage;
  47 |         var alices_hash;
  48 |         var alices_move;
  49 |         var bob = {
  50 |             privkey: "ba".repeat( 32 ),
  51 |             scripts: [],
  52 |             trees: [],
  53 |             preimages: [],
  54 |             hashes: [],
  55 |             accept_preimages: [],
  56 |             accept_hashes: [],
  57 |             alices_moves: [],
  58 |             alices_squares: [],
  59 |             alices_acks: [],
  60 |         }
  61 |         bob[ "pubkey" ] = nobleSecp256k1.getPublicKey( bob[ "privkey" ], true ).substring( 2 );
  62 |         var bobs_preimage;
  63 |         var bobs_hash;
  64 |         var bobs_move;
  65 |     </script>
  66 |     <script>
  67 |         var i; for ( i=0; i<45; i++ ) {
  68 |             var preimage = nobleSecp256k1.utils.randomPrivateKey();
  69 |             preimage = Array.from( preimage );
  70 |             preimage.splice( 0, 12 );
  71 |             preimage = new Uint8Array( preimage );
  72 |             var hash = rmd160( preimage );
  73 |             preimage = bytesToHex( preimage );
  74 |             alice[ "preimages" ].push( preimage );
  75 |             alice[ "hashes" ].push( hash );
  76 |         }
  77 |     </script>
  78 |     <script>
  79 |         var i; for ( i=0; i<9*4; i++ ) {
  80 |             var preimage = nobleSecp256k1.utils.randomPrivateKey();
  81 |             preimage = Array.from( preimage );
  82 |             preimage.splice( 0, 12 );
  83 |             preimage = new Uint8Array( preimage );
  84 |             var hash = rmd160( preimage );
  85 |             preimage = bytesToHex( preimage );
  86 |             bob[ "preimages" ].push( preimage );
  87 |             bob[ "hashes" ].push( hash );
  88 |         }
  89 |     </script>
  90 |     <script>
  91 |         var i; for ( i=0; i<9*4; i++ ) {
  92 |             var preimage = nobleSecp256k1.utils.randomPrivateKey();
  93 |             preimage = Array.from( preimage );
  94 |             preimage.splice( 0, 12 );
  95 |             preimage = new Uint8Array( preimage );
  96 |             var hash = rmd160( preimage );
  97 |             preimage = bytesToHex( preimage );
  98 |             alice[ "accept_preimages" ].push( preimage );
  99 |             alice[ "accept_hashes" ].push( hash );
 100 |         }
 101 |     </script>
 102 |     <script>
 103 |         var i; for ( i=0; i<9*5; i++ ) {
 104 |             var preimage = nobleSecp256k1.utils.randomPrivateKey();
 105 |             preimage = Array.from( preimage );
 106 |             preimage.splice( 0, 12 );
 107 |             preimage = new Uint8Array( preimage );
 108 |             var hash = rmd160( preimage );
 109 |             preimage = bytesToHex( preimage );
 110 |             bob[ "accept_preimages" ].push( preimage );
 111 |             bob[ "accept_hashes" ].push( hash );
 112 |         }
 113 |     </script>
 114 |     <style>
 115 |         html,input{line-height:1.25}*{box-sizing:border-box;font-size:1.15rem;font-family:Arial,sans-serif}html{max-width:800px;padding:0;margin:auto}body{margin:3rem 1rem}h1{font-size:2rem}h2{font-size:1.5rem}input{width:100%;height:1.8rem;font-size:1.15rem;border:1px solid grey}.tictacbox{display:flex;width:100%;justify-content:center}.gameboard{display:flex;width:15rem}.square{height:5rem;width:5rem;cursor:pointer;display:flex;justify-content:center;align-items:center}.col2 div{border-right:1px solid #000;border-left:1px solid #000}.square4,.square5,.square6{border-top:1px solid #000;border-bottom:1px solid #000}
 116 |     </style>
 117 | </head>
 118 | <body>
 119 |     <h1>Welcome to bit tac toe</h1>
 120 |     <p><button onclick="init()">Play</button></p>
 121 |     <div class="tictacbox">
 122 |         <div class="gameboard">
 123 |             <div class="col1">
 124 |                 <div class="square square1"></div>
 125 |                 <div class="square square4"></div>
 126 |                 <div class="square square7"></div>
 127 |             </div>
 128 |             <div class="col2">
 129 |                 <div class="square square2"></div>
 130 |                 <div class="square square5"></div>
 131 |                 <div class="square square8"></div>
 132 |             </div>
 133 |             <div class="col3">
 134 |                 <div class="square square3"></div>
 135 |                 <div class="square square6"></div>
 136 |                 <div class="square square9"></div>
 137 |             </div>
 138 |         </div>
 139 |     </div>
 140 |     <script>
 141 |         var type = 1;var num;var game_on;
 142 |         $$( '.square' ).forEach( item => {item.onclick = () => {
 143 |             if ( !game_on ) return;
 144 |             var conf = true;
 145 |             if ( item.innerHTML ) conf = confirm( `This is an illegal move! Your opponent will be able to take your money. Click ok to do it anyway` );
 146 |             if ( !conf ) return;
 147 |             var symbol = `<span style="font-size: 200%;">&times;</span>`
 148 |             if ( !type ) symbol = `&#9711`;
 149 |             item.innerHTML = symbol;
 150 |             type = !type;
 151 |             var a = item.classList[ 1 ];
 152 |             num = Number( a.substring( a.length - 1, a.length ) );
 153 |         }});
 154 |     </script>
 155 |     <script>
 156 |         var contract = [];
 157 |         var hashes = [];
 158 |         var fraud_occurred = false;
 159 |         var victory_achieved = false;
 160 |         var alice = {
 161 |             privkey: "ab".repeat( 32 ),
 162 |             scripts: [],
 163 |             trees: [],
 164 |             preimages: [],
 165 |             hashes: [],
 166 |             accept_preimages: [],
 167 |             accept_hashes: [],
 168 |             bobs_moves: [],
 169 |             bobs_squares: [],
 170 |             bobs_acks: [],
 171 |         }
 172 |         alice[ "pubkey" ] = nobleSecp256k1.getPublicKey( alice[ "privkey" ], true ).substring( 2 );
 173 |         var funding_address = tapscript.Address.p2tr.fromPubKey( alice[ "pubkey" ], 'testnet' );
 174 |         var alices_preimage;
 175 |         var alices_hash;
 176 |         var alices_move;
 177 |         var bob = {
 178 |             privkey: "ba".repeat( 32 ),
 179 |             scripts: [],
 180 |             trees: [],
 181 |             preimages: [],
 182 |             hashes: [],
 183 |             accept_preimages: [],
 184 |             accept_hashes: [],
 185 |             alices_moves: [],
 186 |             alices_squares: [],
 187 |             alices_acks: [],
 188 |         }
 189 |         bob[ "pubkey" ] = nobleSecp256k1.getPublicKey( bob[ "privkey" ], true ).substring( 2 );
 190 |         var bobs_preimage;
 191 |         var bobs_hash;
 192 |         var bobs_move;
 193 |     </script>
 194 |     <script>
 195 |         var i; for ( i=0; i<9*5; i++ ) {
 196 |             var preimage = nobleSecp256k1.utils.randomPrivateKey();
 197 |             preimage = Array.from( preimage );
 198 |             preimage.splice( 0, 12 );
 199 |             preimage = new Uint8Array( preimage );
 200 |             var hash = rmd160( preimage );
 201 |             preimage = bytesToHex( preimage );
 202 |             alice[ "preimages" ].push( preimage );
 203 |             alice[ "hashes" ].push( hash );
 204 |         }
 205 |     </script>
 206 |     <script>
 207 |         var i; for ( i=0; i<9*4; i++ ) {
 208 |             var preimage = nobleSecp256k1.utils.randomPrivateKey();
 209 |             preimage = Array.from( preimage );
 210 |             preimage.splice( 0, 12 );
 211 |             preimage = new Uint8Array( preimage );
 212 |             var hash = rmd160( preimage );
 213 |             preimage = bytesToHex( preimage );
 214 |             bob[ "preimages" ].push( preimage );
 215 |             bob[ "hashes" ].push( hash );
 216 |         }
 217 |     </script>
 218 |     <script>
 219 |         var i; for ( i=0; i<9*4; i++ ) {
 220 |             var preimage = nobleSecp256k1.utils.randomPrivateKey();
 221 |             preimage = Array.from( preimage );
 222 |             preimage.splice( 0, 12 );
 223 |             preimage = new Uint8Array( preimage );
 224 |             var hash = rmd160( preimage );
 225 |             preimage = bytesToHex( preimage );
 226 |             alice[ "accept_preimages" ].push( preimage );
 227 |             alice[ "accept_hashes" ].push( hash );
 228 |         }
 229 |     </script>
 230 |     <script>
 231 |         var i; for ( i=0; i<9*5; i++ ) {
 232 |             var preimage = nobleSecp256k1.utils.randomPrivateKey();
 233 |             preimage = Array.from( preimage );
 234 |             preimage.splice( 0, 12 );
 235 |             preimage = new Uint8Array( preimage );
 236 |             var hash = rmd160( preimage );
 237 |             preimage = bytesToHex( preimage );
 238 |             bob[ "accept_preimages" ].push( preimage );
 239 |             bob[ "accept_hashes" ].push( hash );
 240 |         }
 241 |     </script>
 242 |     <script>
 243 |         sessionStorage[ "cell_0" ] = `___|`;
 244 |         sessionStorage[ "cell_1" ] = `___|`;
 245 |         sessionStorage[ "cell_2" ] = `___`;
 246 |         sessionStorage[ "cell_3" ] = `___|`;
 247 |         sessionStorage[ "cell_4" ] = `___|`;
 248 |         sessionStorage[ "cell_5" ] = `___`;
 249 |         sessionStorage[ "cell_6" ] = `___|`;
 250 |         sessionStorage[ "cell_7" ] = `___|`;
 251 |         sessionStorage[ "cell_8" ] = `___`;
 252 |         console.log( sessionStorage[ "cell_0" ] + sessionStorage[ "cell_1" ] + sessionStorage[ "cell_2" ] );
 253 |         console.log( sessionStorage[ "cell_3" ] + sessionStorage[ "cell_4" ] + sessionStorage[ "cell_5" ] );
 254 |         console.log( sessionStorage[ "cell_6" ] + sessionStorage[ "cell_7" ] + sessionStorage[ "cell_8" ] );
 255 |     </script>
 256 |     <script>
 257 |         var alicesTurn = turn => {
 258 |             var original_turn = turn;
 259 |             turn = turn * 9;
 260 |             // The first two scripts are simple -- one is the 'happy
 261 |             // path' whereby Alice and Bob cooperate, the other lets
 262 |             // Bob takes Alice's money if Alice stops playing
 263 |             var alices_turn_scripts = [
 264 |                 [ 0, alice[ "pubkey" ], "OP_CHECKSIGADD", bob[ "pubkey" ], "OP_CHECKSIGADD", 2, "OP_EQUAL" ],
 265 |                 [ 10, "OP_CHECKSEQUENCEVERIFY", bob[ "pubkey" ], "OP_CHECKSIG" ],
 266 |             ];
 267 |             // this third script is more complex -- it forces Alice
 268 |             // to reveal one of 9 preimages to represent marking an
 269 |             // X in one of 9 squares of a tic tac toe board
 270 |             var i; for ( i=turn; i<turn + 9; i++ ) {
 271 |                 if ( turn === 0 ) {
 272 |                     var initial_tapleaf_preimage = "";
 273 |                     var initial_tapleaf_guard = "9c1185a5c5e9fc54612808977ee8f548b2258d31";
 274 |                     var tapleaf_guard = initial_tapleaf_guard;
 275 |                     var initial_accept_preimage = "";
 276 |                     var initial_accept_guard = "9c1185a5c5e9fc54612808977ee8f548b2258d31";
 277 |                     var accept_guard = initial_accept_guard;
 278 |                 } else {
 279 |                     var tapleaf_guard = bob[ "hashes" ][i-9];
 280 |                     var accept_guard = alice[ "accept_hashes" ][i-9];
 281 |                 }
 282 |                 var alices_turn_third_script = [
 283 |                     "OP_RIPEMD160",
 284 |                     tapleaf_guard,
 285 |                     "OP_EQUALVERIFY",
 286 |                     "OP_RIPEMD160",
 287 |                     accept_guard,
 288 |                     "OP_EQUALVERIFY",
 289 |                     "OP_RIPEMD160",
 290 |                     "OP_DUP",
 291 |                     alice[ "hashes" ][ turn ],
 292 |                     "OP_EQUAL",
 293 |                     "OP_SWAP",
 294 |                 ];
 295 |                 var j; for ( j=turn + 1; j<turn + 9; j++ ) {
 296 |                     alices_turn_third_script.push( ...[
 297 |                         "OP_DUP",
 298 |                         alice[ "hashes" ][ j ],
 299 |                         "OP_EQUAL",
 300 |                         "OP_ROT",
 301 |                         "OP_ADD",
 302 |                         "OP_SWAP",
 303 |                     ]);
 304 |                 }
 305 |                 alices_turn_third_script.push( ...[
 306 |                     "OP_DROP",
 307 |                     "OP_VERIFY",
 308 |                     0, alice[ "pubkey" ], "OP_CHECKSIGADD", bob[ "pubkey" ], "OP_CHECKSIGADD", 2, "OP_EQUAL",
 309 |                 ]);
 310 |                 alices_turn_scripts.push( alices_turn_third_script );
 311 |             }
 312 |             var i; for ( i=1; i<5; i++ ) {
 313 |                 var combinations = [];
 314 |                 var hashes = [ ...bob[ "hashes" ] ];
 315 |                 hashes = hashes.splice( ( 9 * i ) - 9, 9 );
 316 |                 for ( var comb of G.combination( hashes, 2 ) ) combinations.push( Array.from( comb ) );
 317 |                 combinations.forEach( combination => {
 318 |                     alices_turn_scripts.push([
 319 |                         "OP_RIPEMD160",
 320 |                         "OP_SWAP",
 321 |                         "OP_RIPEMD160",
 322 |                         combination[ 0 ], "OP_EQUALVERIFY",
 323 |                         combination[ 1 ], "OP_EQUALVERIFY",
 324 |                         alice[ "pubkey" ],
 325 |                         "OP_CHECKSIG"
 326 |                     ]);
 327 |                 });
 328 |             }
 329 |             var i; for ( i=0; i<9; i++ ) {
 330 |                 var combinations = [];var hashes = [];
 331 |                 hashes.push( bob[ "hashes" ][ i ], bob[ "hashes" ][ i + 9 ], bob[ "hashes" ][ i + 18 ], bob[ "hashes" ][ i + 27 ] );
 332 |                 for ( var comb of G.combination( hashes, 2 ) ) combinations.push( Array.from( comb ) );
 333 |                 combinations.forEach( combination => {
 334 |                     alices_turn_scripts.push([
 335 |                         "OP_RIPEMD160",
 336 |                         "OP_SWAP",
 337 |                         "OP_RIPEMD160",
 338 |                         combination[ 0 ], "OP_EQUALVERIFY",
 339 |                         combination[ 1 ], "OP_EQUALVERIFY",
 340 |                         alice[ "pubkey" ],
 341 |                         "OP_CHECKSIG"
 342 |                     ]);
 343 |                 });
 344 |             }
 345 |             var accept_hashes = [ ...bob[ "accept_hashes" ] ];
 346 |             var reveal_hashes = [ ...bob[ "hashes" ] ];
 347 |             accept_hashes.forEach( ( item, index ) => {
 348 |                 var i; for ( i=0; i<4; i++ ) {
 349 |                     if ( i==0 ) var hashnum = index % 9;
 350 |                     if ( i==1 ) var hashnum = ( index % 9 ) + 9;
 351 |                     if ( i==2 ) var hashnum = ( index % 9 ) + 18;
 352 |                     if ( i==3 ) var hashnum = ( index % 9 ) + 27;
 353 |                     alices_turn_scripts.push([
 354 |                         "OP_RIPEMD160",
 355 |                         "OP_SWAP",
 356 |                         "OP_RIPEMD160",
 357 |                         item, "OP_EQUALVERIFY",
 358 |                         reveal_hashes[ hashnum ], "OP_EQUALVERIFY",
 359 |                         alice[ "pubkey" ], "OP_CHECKSIG"
 360 |                     ]);                      
 361 |                 }
 362 |             });
 363 |             var combinations = [];
 364 |             var i; for ( i=0; i<9; i++ ) {
 365 |     /*row1*/    if ( i == 0 ) var hashes = [0,9,18,27,1,10,19,28];
 366 |                 if ( i == 1 ) var hashes = [0,9,18,27,2,11,20,29];
 367 |                 if ( i == 2 ) var hashes = [1,10,19,28,2,11,20,29];
 368 |     /*row2*/    if ( i == 3 ) var hashes = [3,12,21,30,4,13,22,31];
 369 |                 if ( i == 4 ) var hashes = [3,12,21,30,5,14,23,32];
 370 |                 if ( i == 5 ) var hashes = [4,13,22,31,5,14,23,32];
 371 |     /*row3*/    if ( i == 6 ) var hashes = [6,15,24,33,7,16,25,34];
 372 |                 if ( i == 7 ) var hashes = [6,15,24,33,8,17,26,35];
 373 |                 if ( i == 8 ) var hashes = [7,16,25,34,8,17,26,35];
 374 |                 for ( var comb of G.combination( hashes, 2 ) ) {var comb2 = JSON.parse( JSON.stringify( comb ) ); comb2.sort((a,b)=>a-b).reverse(); if ( ( comb2[ 0 ] - comb2[ 1 ] ) % 9 && comb2[ 0 ] - comb2[ 1 ] >= 3 ) combinations.push( Array.from( comb ) );}
 375 |             }
 376 |             combinations.forEach( ( item, index ) => {
 377 |                 combinations.splice( index * 5, 1, ...JSON.parse( JSON.stringify( [combinations[ index * 5 ]].flatMap(i => Array(5).fill(i))) ) );
 378 |             });
 379 |             combinations.forEach( ( item, index ) => {
 380 |                 if ( item.length > 2 ) return;
 381 |                 if ( index < 180 ) {if ( item[ 0 ] % 3 == 0 && item[ 1 ] % 3 == 1 || item[ 1 ] % 3 == 0 && item[ 0 ] % 3 == 1 ) {if ( index % 5 == 0 ) item.push( 2 );if ( index % 5 == 1 ) item.push( 11 );if ( index % 5 == 2 ) item.push( 20 );if ( index % 5 == 3 ) item.push( 29 );if ( index % 5 == 4 ) item.push( 38 );}
 382 |                     if ( item[ 0 ] % 3 == 0 && item[ 1 ] % 3 == 2 || item[ 1 ] % 3 == 0 && item[ 0 ] % 3 == 2 ) {if ( index % 5 == 0 ) item.push( 1 );if ( index % 5 == 1 ) item.push( 10 );if ( index % 5 == 2 ) item.push( 19 );if ( index % 5 == 3 ) item.push( 28 );if ( index % 5 == 4 ) item.push( 37 );}
 383 |                     if ( item[ 0 ] % 3 == 1 && item[ 1 ] % 3 == 2 || item[ 1 ] % 3 == 1 && item[ 0 ] % 3 == 2 ) {if ( index % 5 == 0 ) item.push( 0 );if ( index % 5 == 1 ) item.push( 9 );if ( index % 5 == 2 ) item.push( 18 );if ( index % 5 == 3 ) item.push( 27 );if ( index % 5 == 4 ) item.push( 36 );}
 384 |                 }
 385 |                 if ( index >= 180 && index < 360 ) {
 386 |                     if ( item[ 0 ] % 3 == 0 && item[ 1 ] % 3 == 1 || item[ 1 ] % 3 == 0 && item[ 0 ] % 3 == 1 ) {if ( index % 5 == 0 ) item.push( 5 );if ( index % 5 == 1 ) item.push( 14 );if ( index % 5 == 2 ) item.push( 23 );if ( index % 5 == 3 ) item.push( 32 );if ( index % 5 == 4 ) item.push( 41 );}
 387 |                     if ( item[ 0 ] % 3 == 0 && item[ 1 ] % 3 == 2 || item[ 1 ] % 3 == 0 && item[ 0 ] % 3 == 2 ) {if ( index % 5 == 0 ) item.push( 4 );if ( index % 5 == 1 ) item.push( 13 );if ( index % 5 == 2 ) item.push( 22 );if ( index % 5 == 3 ) item.push( 31 );if ( index % 5 == 4 ) item.push( 40 );}
 388 |                     if ( item[ 0 ] % 3 == 1 && item[ 1 ] % 3 == 2 || item[ 1 ] % 3 == 1 && item[ 0 ] % 3 == 2 ) {if ( index % 5 == 0 ) item.push( 3 );if ( index % 5 == 1 ) item.push( 12 );if ( index % 5 == 2 ) item.push( 21 );if ( index % 5 == 3 ) item.push( 30 );if ( index % 5 == 4 ) item.push( 39 );}
 389 |                 }
 390 |                 if ( index >= 360 && index < 540 ) {if ( item[ 0 ] % 3 == 0 && item[ 1 ] % 3 == 1 || item[ 1 ] % 3 == 0 && item[ 0 ] % 3 == 1 ) {if ( index % 5 == 0 ) item.push( 8 );if ( index % 5 == 1 ) item.push( 17 );if ( index % 5 == 2 ) item.push( 26 );if ( index % 5 == 3 ) item.push( 35 );if ( index % 5 == 4 ) item.push( 44 );}
 391 |                     if ( item[ 0 ] % 3 == 0 && item[ 1 ] % 3 == 2 || item[ 1 ] % 3 == 0 && item[ 0 ] % 3 == 2 ) {if ( index % 5 == 0 ) item.push( 7 );if ( index % 5 == 1 ) item.push( 16 );if ( index % 5 == 2 ) item.push( 25 );if ( index % 5 == 3 ) item.push( 34 );if ( index % 5 == 4 ) item.push( 43 );}
 392 |                     if ( item[ 0 ] % 3 == 1 && item[ 1 ] % 3 == 2 || item[ 1 ] % 3 == 1 && item[ 0 ] % 3 == 2 ) {if ( index % 5 == 0 ) item.push( 6 );if ( index % 5 == 1 ) item.push( 15 );if ( index % 5 == 2 ) item.push( 24 );if ( index % 5 == 3 ) item.push( 33 );if ( index % 5 == 4 ) item.push( 42 );}
 393 |                 }
 394 |             });
 395 |             combinations.forEach( combination => {
 396 |                 alices_turn_scripts.push([
 397 |                     "OP_RIPEMD160", "OP_SWAP", "OP_RIPEMD160",
 398 |                     2, "OP_ROLL",
 399 |                     "OP_RIPEMD160",
 400 |                     "OP_SWAP",
 401 |                     2, "OP_ROLL",
 402 |                     alice[ "hashes" ][ combination[ 2 ] ],
 403 |                     "OP_EQUALVERIFY",
 404 |                     bob[ "accept_hashes" ][ combination[ 1 ] ],
 405 |                     "OP_EQUALVERIFY",
 406 |                     bob[ "accept_hashes" ][ combination[ 0 ] ],
 407 |                     "OP_EQUALVERIFY",
 408 |                     //TODO: turn this into a multisig
 409 |                     alice[ "pubkey" ], "OP_CHECKSIG"
 410 |                 ]);
 411 |             });
 412 |             alice[ "trees" ].push( alices_turn_scripts.map( s => tapscript.Tap.encodeScript( s ) ) );
 413 |             alice[ "scripts" ].push( alices_turn_scripts );
 414 |             var pubkey = "ab".repeat( 32 );
 415 |             var [ tpubkey ] = tapscript.Tap.getPubKey( pubkey, { tree: alice[ "trees" ][ original_turn ] });
 416 |             var alices_turn_address = tapscript.Address.p2tr.fromPubKey( tpubkey, 'testnet' );
 417 |             return alices_turn_address;
 418 |         }
 419 |     </script>
 420 |     <script>
 421 |         var bobsTurn = turn => {
 422 |             var original_turn = turn;
 423 |             turn = turn * 9;
 424 |             var bobs_turn_scripts = [
 425 |                 [ 0, alice[ "pubkey" ], "OP_CHECKSIGADD", bob[ "pubkey" ], "OP_CHECKSIGADD", 2, "OP_EQUAL" ],
 426 |                 [ 10, "OP_CHECKSEQUENCEVERIFY", alice[ "pubkey" ], "OP_CHECKSIG" ],
 427 |             ];
 428 | 
 429 |             var i; for ( i=turn; i<turn + 9; i++ ) {
 430 |                 var tapleaf_guard = alice[ "hashes" ][ i ];
 431 |                 var accept_guard = bob[ "accept_hashes" ][ i ];
 432 |                 var bobs_turn_third_script = [
 433 |                     "OP_RIPEMD160",
 434 |                     tapleaf_guard,
 435 |                     "OP_EQUALVERIFY",
 436 |                     "OP_RIPEMD160",
 437 |                     accept_guard,
 438 |                     "OP_EQUALVERIFY",
 439 |                     "OP_RIPEMD160",
 440 |                     "OP_DUP",
 441 |                     bob[ "hashes" ][ turn ],
 442 |                     "OP_EQUAL",
 443 |                     "OP_SWAP",
 444 |                 ];
 445 |                 var j; for ( j=turn + 1; j<turn + 9; j++ ) {
 446 |                     bobs_turn_third_script.push( ...[
 447 |                         "OP_DUP",
 448 |                         bob[ "hashes"][ j ],
 449 |                         "OP_EQUAL",
 450 |                         "OP_ROT",
 451 |                         "OP_ADD",
 452 |                         "OP_SWAP",
 453 |                     ]);
 454 |                 }
 455 |                 bobs_turn_third_script.push( ...[
 456 |                     "OP_DROP",
 457 |                     "OP_VERIFY",
 458 |                     0,
 459 |                     alice[ "pubkey" ],
 460 |                     "OP_CHECKSIGADD",
 461 |                     bob[ "pubkey" ],
 462 |                     "OP_CHECKSIGADD",
 463 |                     2,
 464 |                     "OP_EQUAL",
 465 |                 ]);
 466 |                 bobs_turn_scripts.push( bobs_turn_third_script );
 467 |             }
 468 |             bob[ "scripts" ].push( bobs_turn_scripts );
 469 | 
 470 |             //allow Bob to prove fraud if Alice reveals two preimages for any of her turns
 471 |             var i; for ( i=1; i<6; i++ ) {
 472 |                 var combinations = [];
 473 |                 var hashes = [ ...alice[ "hashes" ] ];
 474 |                 hashes = hashes.splice( ( 9 * i ) - 9, 9 );
 475 |                 for ( var comb of G.combination( hashes, 2 ) ) combinations.push( Array.from( comb ) );
 476 |                 combinations.forEach( combination => {
 477 |                     bobs_turn_scripts.push([
 478 |                         "OP_RIPEMD160",
 479 |                         "OP_SWAP",
 480 |                         "OP_RIPEMD160",
 481 |                         combination[ 0 ],
 482 |                         "OP_EQUALVERIFY",
 483 |                         combination[ 1 ],
 484 |                         "OP_EQUALVERIFY",
 485 |                         bob[ "pubkey" ],
 486 |                         "OP_CHECKSIG"
 487 |                     ]);
 488 |                 });
 489 |             }
 490 | 
 491 |             var i; for ( i=0; i<9; i++ ) {
 492 |                 var combinations = [];
 493 |                 var hashes = [];
 494 |                 hashes.push( alice[ "hashes" ][ i ], alice[ "hashes" ][ i + 9 ], alice[ "hashes" ][ i + 18 ], alice[ "hashes" ][ i + 27 ], alice[ "hashes" ][ i + 36 ] );
 495 |                 for ( var comb of G.combination( hashes, 2 ) ) combinations.push( Array.from( comb ) );
 496 |                 combinations.forEach( combination => {
 497 |                     bobs_turn_scripts.push([
 498 |                         "OP_RIPEMD160",
 499 |                         "OP_SWAP",
 500 |                         "OP_RIPEMD160",
 501 |                         combination[ 0 ],
 502 |                         "OP_EQUALVERIFY",
 503 |                         combination[ 1 ],
 504 |                         "OP_EQUALVERIFY",
 505 |                         bob[ "pubkey" ],
 506 |                         "OP_CHECKSIG"
 507 |                     ]);
 508 |                 });
 509 |             }
 510 | 
 511 |             var accept_hashes = [ ...alice[ "accept_hashes" ] ];
 512 |             var reveal_hashes = [ ...alice[ "hashes" ] ];
 513 |             accept_hashes.forEach( ( item, index ) => {
 514 |                 bobs_turn_scripts.push([
 515 |                     "OP_RIPEMD160",
 516 |                     "OP_SWAP",
 517 |                     "OP_RIPEMD160",
 518 |                     item,
 519 |                     "OP_EQUALVERIFY",
 520 |                     reveal_hashes[ index % 9 ],
 521 |                     "OP_EQUALVERIFY",
 522 |                     bob[ "pubkey" ],
 523 |                     "OP_CHECKSIG"
 524 |                 ]);
 525 |                 bobs_turn_scripts.push([
 526 |                     "OP_RIPEMD160",
 527 |                     "OP_SWAP",
 528 |                     "OP_RIPEMD160",
 529 |                     item,
 530 |                     "OP_EQUALVERIFY",
 531 |                     reveal_hashes[ ( index % 9 ) + 9 ],
 532 |                     "OP_EQUALVERIFY",
 533 |                     bob[ "pubkey" ],
 534 |                     "OP_CHECKSIG"
 535 |                 ]);
 536 |                 bobs_turn_scripts.push([
 537 |                     "OP_RIPEMD160",
 538 |                     "OP_SWAP",
 539 |                     "OP_RIPEMD160",
 540 |                     item,
 541 |                     "OP_EQUALVERIFY",
 542 |                     reveal_hashes[ ( index % 9 ) + 9 + 9 ],
 543 |                     "OP_EQUALVERIFY",
 544 |                     bob[ "pubkey" ],
 545 |                     "OP_CHECKSIG"
 546 |                 ]);
 547 |                 bobs_turn_scripts.push([
 548 |                     "OP_RIPEMD160",
 549 |                     "OP_SWAP",
 550 |                     "OP_RIPEMD160",
 551 |                     item,
 552 |                     "OP_EQUALVERIFY",
 553 |                     reveal_hashes[ ( index % 9 ) + 9 + 9 + 9 ],
 554 |                     "OP_EQUALVERIFY",
 555 |                     bob[ "pubkey" ],
 556 |                     "OP_CHECKSIG"
 557 |                 ]);
 558 |                 bobs_turn_scripts.push([
 559 |                     "OP_RIPEMD160",
 560 |                     "OP_SWAP",
 561 |                     "OP_RIPEMD160",
 562 |                     item,
 563 |                     "OP_EQUALVERIFY",
 564 |                     reveal_hashes[ ( index % 9 ) + 9 + 9 + 9 + 9 ],
 565 |                     "OP_EQUALVERIFY",
 566 |                     bob[ "pubkey" ],
 567 |                     "OP_CHECKSIG"
 568 |                 ]);
 569 |             });
 570 | 
 571 |             var combinations = [];
 572 |             var i; for ( i=0; i<9; i++ ) {
 573 |                 //row 1
 574 |                 if ( i == 0 ) var hashes = [0, 9, 18, 27, 1, 10, 19, 28];
 575 |                 if ( i == 1 ) var hashes = [0, 9, 18, 27, 2, 11, 20, 29];
 576 |                 if ( i == 2 ) var hashes = [1, 10, 19, 28, 2, 11, 20, 29];
 577 |                 //row 2
 578 |                 if ( i == 3 ) var hashes = [3, 12, 21, 30, 4, 13, 22, 31];
 579 |                 if ( i == 4 ) var hashes = [3, 12, 21, 30, 5, 14, 23, 32];
 580 |                 if ( i == 5 ) var hashes = [4, 13, 22, 31, 5, 14, 23, 32];
 581 |                 //row 3
 582 |                 if ( i == 6 ) var hashes = [6, 15, 24, 33, 7, 16, 25, 34];
 583 |                 if ( i == 7 ) var hashes = [6, 15, 24, 33, 8, 17, 26, 35];
 584 |                 if ( i == 8 ) var hashes = [7, 16, 25, 34, 8, 17, 26, 35];
 585 |                 for ( var comb of G.combination( hashes, 2 ) ) {var comb2 = JSON.parse( JSON.stringify( comb ) ); comb2.sort((a,b)=>a-b).reverse(); if ( ( comb2[ 0 ] - comb2[ 1 ] ) % 9 && comb2[ 0 ] - comb2[ 1 ] >= 3 ) combinations.push( Array.from( comb ) );}
 586 |             }
 587 |             combinations.forEach( ( item, index ) => {
 588 |                 combinations.splice( index * 4, 1, ...JSON.parse( JSON.stringify( [combinations[ index * 4 ]].flatMap(i => Array(4).fill(i))) ) );
 589 |             });
 590 |             combinations.forEach( ( item, index ) => {
 591 |                 if ( item.length > 2 ) return;
 592 |                 //row 1
 593 |                 //Alice had 180 here because there were originally 108 combinations and I multiplied them by 5 for each of her 5 turns. Then I divided the result, 540, by 3 to work on rows 1, 2, and 3. But Bob only has 4 turns so he only gets 108*4 = 432 combinations, meaning 180 for him should be 432/3 = 144
 594 |                 if ( index < 144 ) {
 595 |                     if ( item[ 0 ] % 3 == 0 && item[ 1 ] % 3 == 1 || item[ 1 ] % 3 == 0 && item[ 0 ] % 3 == 1 ) {
 596 |                         if ( index % 4 == 0 ) item.push( 2 );
 597 |                         if ( index % 4 == 1 ) item.push( 11 );
 598 |                         if ( index % 4 == 2 ) item.push( 20 );
 599 |                         if ( index % 4 == 3 ) item.push( 29 );
 600 |                     }
 601 |                     if ( item[ 0 ] % 3 == 0 && item[ 1 ] % 3 == 2 || item[ 1 ] % 3 == 0 && item[ 0 ] % 3 == 2 ) {
 602 |                         if ( index % 4 == 0 ) item.push( 1 );
 603 |                         if ( index % 4 == 1 ) item.push( 10 );
 604 |                         if ( index % 4 == 2 ) item.push( 19 );
 605 |                         if ( index % 4 == 3 ) item.push( 28 );
 606 |                     }
 607 |                     if ( item[ 0 ] % 3 == 1 && item[ 1 ] % 3 == 2 || item[ 1 ] % 3 == 1 && item[ 0 ] % 3 == 2 ) {
 608 |                         if ( index % 4 == 0 ) item.push( 0 );
 609 |                         if ( index % 4 == 1 ) item.push( 9 );
 610 |                         if ( index % 4 == 2 ) item.push( 18 );
 611 |                         if ( index % 4 == 3 ) item.push( 27 );
 612 |                     }
 613 |                 }
 614 |                 //row 2
 615 |                 if ( index >= 144 && index < 288 ) {
 616 |                     if ( item[ 0 ] % 3 == 0 && item[ 1 ] % 3 == 1 || item[ 1 ] % 3 == 0 && item[ 0 ] % 3 == 1 ) {
 617 |                         if ( index % 4 == 0 ) item.push( 5 );
 618 |                         if ( index % 4 == 1 ) item.push( 14 );
 619 |                         if ( index % 4 == 2 ) item.push( 23 );
 620 |                         if ( index % 4 == 3 ) item.push( 32 );
 621 |                     }
 622 |                     if ( item[ 0 ] % 3 == 0 && item[ 1 ] % 3 == 2 || item[ 1 ] % 3 == 0 && item[ 0 ] % 3 == 2 ) {
 623 |                         if ( index % 4 == 0 ) item.push( 4 );
 624 |                         if ( index % 4 == 1 ) item.push( 13 );
 625 |                         if ( index % 4 == 2 ) item.push( 22 );
 626 |                         if ( index % 4 == 3 ) item.push( 31 );
 627 |                     }
 628 |                     if ( item[ 0 ] % 3 == 1 && item[ 1 ] % 3 == 2 || item[ 1 ] % 3 == 1 && item[ 0 ] % 3 == 2 ) {
 629 |                         if ( index % 4 == 0 ) item.push( 3 );
 630 |                         if ( index % 4 == 1 ) item.push( 12 );
 631 |                         if ( index % 4 == 2 ) item.push( 21 );
 632 |                         if ( index % 4 == 3 ) item.push( 30 );
 633 |                     }
 634 |                 }
 635 |                 //row 3
 636 |                 if ( index >= 288 && index < 432 ) {
 637 |                     if ( item[ 0 ] % 3 == 0 && item[ 1 ] % 3 == 1 || item[ 1 ] % 3 == 0 && item[ 0 ] % 3 == 1 ) {
 638 |                         if ( index % 4 == 0 ) item.push( 8 );
 639 |                         if ( index % 4 == 1 ) item.push( 17 );
 640 |                         if ( index % 4 == 2 ) item.push( 26 );
 641 |                         if ( index % 4 == 3 ) item.push( 35 );
 642 |                     }
 643 |                     if ( item[ 0 ] % 3 == 0 && item[ 1 ] % 3 == 2 || item[ 1 ] % 3 == 0 && item[ 0 ] % 3 == 2 ) {
 644 |                         if ( index % 4 == 0 ) item.push( 7 );
 645 |                         if ( index % 4 == 1 ) item.push( 16 );
 646 |                         if ( index % 4 == 2 ) item.push( 25 );
 647 |                         if ( index % 4 == 3 ) item.push( 34 );
 648 |                     }
 649 |                     if ( item[ 0 ] % 3 == 1 && item[ 1 ] % 3 == 2 || item[ 1 ] % 3 == 1 && item[ 0 ] % 3 == 2 ) {
 650 |                         if ( index % 4 == 0 ) item.push( 6 );
 651 |                         if ( index % 4 == 1 ) item.push( 15 );
 652 |                         if ( index % 4 == 2 ) item.push( 24 );
 653 |                         if ( index % 4 == 3 ) item.push( 33 );
 654 |                     }
 655 |                 }
 656 |             });
 657 |             combinations.forEach( combination => {
 658 |                 bobs_turn_scripts.push([
 659 |                     "OP_RIPEMD160",
 660 |                     "OP_SWAP",
 661 |                     "OP_RIPEMD160",
 662 |                     2,
 663 |                     "OP_ROLL",
 664 |                     "OP_RIPEMD160",
 665 |                     "OP_SWAP",
 666 |                     2,
 667 |                     "OP_ROLL",
 668 |                     bob[ "hashes" ][ combination[ 2 ] ],
 669 |                     "OP_EQUALVERIFY",
 670 |                     alice[ "accept_hashes" ][ combination[ 1 ] ],
 671 |                     "OP_EQUALVERIFY",
 672 |                     alice[ "accept_hashes" ][ combination[ 0 ] ],
 673 |                     "OP_EQUALVERIFY",
 674 |                     //todo: ensure this is a multisig path that
 675 |                     //sends the money to an address where Bob
 676 |                     //has an opportunity to prove alice cheated
 677 |                     bob[ "pubkey" ],
 678 |                     "OP_CHECKSIG"
 679 |                 ]);
 680 |             });
 681 | 
 682 |             bob[ "trees" ].push( bobs_turn_scripts.map( s => tapscript.Tap.encodeScript( s ) ) );
 683 |             var pubkey = "ab".repeat( 32 );
 684 |             var [ tpubkey ] = tapscript.Tap.getPubKey( pubkey, { tree: bob[ "trees" ][ original_turn ] });
 685 |             var bobs_turn_address = tapscript.Address.p2tr.fromPubKey( tpubkey, 'testnet' );
 686 |             return bobs_turn_address;
 687 |         }
 688 |     </script>
 689 |     <script>
 690 |         var proveDoubleTurn = ( p1, p2, opponent, self ) => {
 691 |             var h1 = rmd160( hexToBytes( p1 ) );
 692 |             var h2 = rmd160( hexToBytes( p2 ) );
 693 |             var combinations = [];
 694 |             var i; for ( i=1; i<5; i++ ) {
 695 |                 var hashes = [ ...opponent[ "hashes" ] ];
 696 |                 hashes = hashes.splice( ( 9 * i ) - 9, 9 );
 697 |                 for ( var comb of G.combination( hashes, 2 ) ) combinations.push( Array.from( comb ) );
 698 |             }
 699 |             var possibles = [];
 700 |             combinations.forEach( item => {
 701 |                 if ( item.includes( h1 ) ) possibles.push( item );
 702 |             });
 703 |             var actual;
 704 |             possibles.forEach( item => {
 705 |                 if ( item.includes( h2 ) ) actual = item;
 706 |             });
 707 |             if ( !actual ) return;
 708 |             fraud_occurred = true;
 709 |             var script = [
 710 |                 "OP_RIPEMD160",
 711 |                 "OP_SWAP",
 712 |                 "OP_RIPEMD160",
 713 |                 actual[ 0 ], "OP_EQUALVERIFY",
 714 |                 actual[ 1 ], "OP_EQUALVERIFY",
 715 |                 self[ "pubkey" ], "OP_CHECKSIG"
 716 |             ];
 717 |             var target = tapscript.Tap.encodeScript( script );
 718 |             return [ target, script ];
 719 |         }
 720 |         var proveOverwriteSelf = ( p1, p2, opponent, self ) => {
 721 |             var h1 = rmd160( hexToBytes( p1 ) );
 722 |             var h2 = rmd160( hexToBytes( p2 ) );
 723 |             var actual;
 724 |             var i; for ( i=0; i<9; i++ ) {
 725 |                 var combinations = [];var hashes = [];
 726 |                 hashes.push( opponent[ "hashes" ][ i ], opponent[ "hashes" ][ i + 9 ], opponent[ "hashes" ][ i + 18 ], opponent[ "hashes" ][ i + 27 ] );
 727 |                 for ( var comb of G.combination( hashes, 2 ) ) combinations.push( Array.from( comb ) );
 728 |                 var possibles = [];
 729 |                 combinations.forEach( item => {if ( item.includes( h1 ) ) possibles.push( item );});
 730 |                 possibles.forEach( item => {if ( item.includes( h2 ) ) actual = item;});
 731 |             }
 732 |             if ( !actual ) return;fraud_occurred = true;
 733 |             var script = [
 734 |                 "OP_RIPEMD160",
 735 |                 "OP_SWAP",
 736 |                 "OP_RIPEMD160",
 737 |                 actual[ 0 ],
 738 |                 "OP_EQUALVERIFY",
 739 |                 actual[ 1 ],
 740 |                 "OP_EQUALVERIFY",
 741 |                 self[ "pubkey" ],
 742 |                 "OP_CHECKSIG"
 743 |             ];
 744 |             var target = tapscript.Tap.encodeScript( script );
 745 |             return [ target, script ];
 746 |         }
 747 |     </script>
 748 |     <script>
 749 |         var proveOverwriteOpponent = ( p1, p2, opponent, self ) => {
 750 |             var h1 = rmd160( hexToBytes( p1 ) );
 751 |             var h2 = rmd160( hexToBytes( p2 ) );
 752 |             var actual;
 753 |             var accept_hashes = [ ...opponent[ "accept_hashes" ] ];
 754 |             var reveal_hashes = [ ...opponent[ "hashes" ] ];
 755 |             accept_hashes.forEach( ( item, index ) => {
 756 |                 if ( ( item == h1 || item == h2 ) && ( reveal_hashes[ index % 9 ] == h1 || reveal_hashes[ index % 9 ] == h2 ) ) actual = [ item, reveal_hashes[index%9] ];
 757 |                 if ( ( item == h1 || item == h2 ) && ( reveal_hashes[ ( index % 9 ) + 9 ] == h1 || reveal_hashes[ ( index % 9 ) + 9 ] == h2 ) ) actual = [ item, reveal_hashes[(index%9) + 9 ] ];
 758 |                 if ( ( item == h1 || item == h2 ) && ( reveal_hashes[ ( index % 9 ) + 18 ] == h1 || reveal_hashes[ ( index % 9 ) + 9 + 9 ] == h2 ) ) actual = [ item, reveal_hashes[(index%9) + 18 ] ];
 759 |                 if ( ( item == h1 || item == h2 ) && ( reveal_hashes[ ( index % 9 ) + 27 ] == h1 || reveal_hashes[ ( index % 9 ) + 9 + 9 + 9 ] == h2 ) ) actual = [ item, reveal_hashes[(index%9) + 27 ] ];
 760 |             });
 761 |             if ( !actual ) return;
 762 |             fraud_occurred = true;
 763 |             var script = [
 764 |                 "OP_RIPEMD160",
 765 |                 "OP_SWAP",
 766 |                 "OP_RIPEMD160",
 767 |                 actual[ 0 ],
 768 |                 "OP_EQUALVERIFY",
 769 |                 actual[ 1 ],
 770 |                 "OP_EQUALVERIFY",
 771 |                 self[ "pubkey" ],
 772 |                 "OP_CHECKSIG"
 773 |             ];
 774 |             var target = tapscript.Tap.encodeScript( script );
 775 |             return [ target, script ];
 776 |         }
 777 |     </script>
 778 |     <script>
 779 |         var proveVictory = ( p1, p2, p3, opponent, self ) => {
 780 |             var h1 = rmd160( hexToBytes( p1 ) );
 781 |             var h2 = rmd160( hexToBytes( p2 ) );
 782 |             var h3 = rmd160( hexToBytes( p3 ) );
 783 |             var actual;
 784 |             var combinations = [];
 785 |             var i; for ( i=0; i<9; i++ ) {
 786 |                 //row 1
 787 |                 if ( i == 0 ) var hashes = [0, 9, 18, 27, 1, 10, 19, 28];
 788 |                 if ( i == 1 ) var hashes = [0, 9, 18, 27, 2, 11, 20, 29];
 789 |                 if ( i == 2 ) var hashes = [1, 10, 19, 28, 2, 11, 20, 29];
 790 |                 //row 2
 791 |                 if ( i == 3 ) var hashes = [3, 12, 21, 30, 4, 13, 22, 31];
 792 |                 if ( i == 4 ) var hashes = [3, 12, 21, 30, 5, 14, 23, 32];
 793 |                 if ( i == 5 ) var hashes = [4, 13, 22, 31, 5, 14, 23, 32];
 794 |                 //row 3
 795 |                 if ( i == 6 ) var hashes = [6, 15, 24, 33, 7, 16, 25, 34];
 796 |                 if ( i == 7 ) var hashes = [6, 15, 24, 33, 8, 17, 26, 35];
 797 |                 if ( i == 8 ) var hashes = [7, 16, 25, 34, 8, 17, 26, 35];
 798 |                 for ( var comb of G.combination( hashes, 2 ) ) {var comb2 = JSON.parse( JSON.stringify( comb ) ); comb2.sort((a,b)=>a-b).reverse(); if ( ( comb2[ 0 ] - comb2[ 1 ] ) % 9 && comb2[ 0 ] - comb2[ 1 ] >= 3 ) combinations.push( Array.from( comb ) );}
 799 |             }
 800 |             combinations.forEach( ( item, index ) => {
 801 |                 combinations.splice( index * 5, 1, ...JSON.parse( JSON.stringify( [combinations[ index * 5 ]].flatMap(i => Array(5).fill(i))) ) );
 802 |             });
 803 |             combinations.forEach( ( item, index ) => {
 804 |                 if ( item.length > 2 ) return;
 805 |                 //row 1
 806 |                 if ( index < 180 ) {
 807 |                     if ( item[ 0 ] % 3 == 0 && item[ 1 ] % 3 == 1 || item[ 1 ] % 3 == 0 && item[ 0 ] % 3 == 1 ) {
 808 |                         if ( index % 5 == 0 ) item.push( 2 );
 809 |                         if ( index % 5 == 1 ) item.push( 11 );
 810 |                         if ( index % 5 == 2 ) item.push( 20 );
 811 |                         if ( index % 5 == 3 ) item.push( 29 );
 812 |                         if ( index % 5 == 4 ) item.push( 38 );
 813 |                     }
 814 |                     if ( item[ 0 ] % 3 == 0 && item[ 1 ] % 3 == 2 || item[ 1 ] % 3 == 0 && item[ 0 ] % 3 == 2 ) {
 815 |                         if ( index % 5 == 0 ) item.push( 1 );
 816 |                         if ( index % 5 == 1 ) item.push( 10 );
 817 |                         if ( index % 5 == 2 ) item.push( 19 );
 818 |                         if ( index % 5 == 3 ) item.push( 28 );
 819 |                         if ( index % 5 == 4 ) item.push( 37 );
 820 |                     }
 821 |                     if ( item[ 0 ] % 3 == 1 && item[ 1 ] % 3 == 2 || item[ 1 ] % 3 == 1 && item[ 0 ] % 3 == 2 ) {
 822 |                         if ( index % 5 == 0 ) item.push( 0 );
 823 |                         if ( index % 5 == 1 ) item.push( 9 );
 824 |                         if ( index % 5 == 2 ) item.push( 18 );
 825 |                         if ( index % 5 == 3 ) item.push( 27 );
 826 |                         if ( index % 5 == 4 ) item.push( 36 );
 827 |                     }
 828 |                 }
 829 |                 //row 2
 830 |                 if ( index >= 180 && index < 360 ) {
 831 |                     if ( item[ 0 ] % 3 == 0 && item[ 1 ] % 3 == 1 || item[ 1 ] % 3 == 0 && item[ 0 ] % 3 == 1 ) {
 832 |                         if ( index % 5 == 0 ) item.push( 5 );
 833 |                         if ( index % 5 == 1 ) item.push( 14 );
 834 |                         if ( index % 5 == 2 ) item.push( 23 );
 835 |                         if ( index % 5 == 3 ) item.push( 32 );
 836 |                         if ( index % 5 == 4 ) item.push( 41 );
 837 |                     }
 838 |                     if ( item[ 0 ] % 3 == 0 && item[ 1 ] % 3 == 2 || item[ 1 ] % 3 == 0 && item[ 0 ] % 3 == 2 ) {
 839 |                         if ( index % 5 == 0 ) item.push( 4 );
 840 |                         if ( index % 5 == 1 ) item.push( 13 );
 841 |                         if ( index % 5 == 2 ) item.push( 22 );
 842 |                         if ( index % 5 == 3 ) item.push( 31 );
 843 |                         if ( index % 5 == 4 ) item.push( 40 );
 844 |                     }
 845 |                     if ( item[ 0 ] % 3 == 1 && item[ 1 ] % 3 == 2 || item[ 1 ] % 3 == 1 && item[ 0 ] % 3 == 2 ) {
 846 |                         if ( index % 5 == 0 ) item.push( 3 );
 847 |                         if ( index % 5 == 1 ) item.push( 12 );
 848 |                         if ( index % 5 == 2 ) item.push( 21 );
 849 |                         if ( index % 5 == 3 ) item.push( 30 );
 850 |                         if ( index % 5 == 4 ) item.push( 39 );
 851 |                     }
 852 |                 }
 853 |                 //row 3
 854 |                 if ( index >= 360 && index < 540 ) {
 855 |                     if ( item[ 0 ] % 3 == 0 && item[ 1 ] % 3 == 1 || item[ 1 ] % 3 == 0 && item[ 0 ] % 3 == 1 ) {
 856 |                         if ( index % 5 == 0 ) item.push( 8 );
 857 |                         if ( index % 5 == 1 ) item.push( 17 );
 858 |                         if ( index % 5 == 2 ) item.push( 26 );
 859 |                         if ( index % 5 == 3 ) item.push( 35 );
 860 |                         if ( index % 5 == 4 ) item.push( 44 );
 861 |                     }
 862 |                     if ( item[ 0 ] % 3 == 0 && item[ 1 ] % 3 == 2 || item[ 1 ] % 3 == 0 && item[ 0 ] % 3 == 2 ) {
 863 |                         if ( index % 5 == 0 ) item.push( 7 );
 864 |                         if ( index % 5 == 1 ) item.push( 16 );
 865 |                         if ( index % 5 == 2 ) item.push( 25 );
 866 |                         if ( index % 5 == 3 ) item.push( 34 );
 867 |                         if ( index % 5 == 4 ) item.push( 43 );
 868 |                     }
 869 |                     if ( item[ 0 ] % 3 == 1 && item[ 1 ] % 3 == 2 || item[ 1 ] % 3 == 1 && item[ 0 ] % 3 == 2 ) {
 870 |                         if ( index % 5 == 0 ) item.push( 6 );
 871 |                         if ( index % 5 == 1 ) item.push( 15 );
 872 |                         if ( index % 5 == 2 ) item.push( 24 );
 873 |                         if ( index % 5 == 3 ) item.push( 33 );
 874 |                         if ( index % 5 == 4 ) item.push( 42 );
 875 |                     }
 876 |                 }
 877 |             });
 878 |             combinations.forEach( ( item, index ) => {
 879 |                 combinations[ index ][ 0 ] = opponent[ "accept_hashes" ][ item[ 0 ] ];
 880 |                 combinations[ index ][ 1 ] = opponent[ "accept_hashes" ][ item[ 1 ] ];
 881 |                 combinations[ index ][ 2 ] = self[ "hashes" ][ item[ 2 ] ];
 882 |             });
 883 |             var possibles = [];
 884 |             combinations.forEach( item => {
 885 |                 if ( item.includes( h1 ) && item.includes( h2 ) ) possibles.push( item );
 886 |             });
 887 |             possibles.forEach( item => {
 888 |                 if ( item.includes( h3 ) ) actual = item;
 889 |             });
 890 |             if ( !actual ) return;
 891 |             actual.reverse();
 892 |             victory_achieved = true;
 893 |             var script = [
 894 |                 "OP_RIPEMD160",
 895 |                 "OP_SWAP",
 896 |                 "OP_RIPEMD160",
 897 |                 2,
 898 |                 "OP_ROLL",
 899 |                 "OP_RIPEMD160",
 900 |                 "OP_SWAP",
 901 |                 2,
 902 |                 "OP_ROLL",
 903 |                 actual[ 0 ],
 904 |                 "OP_EQUALVERIFY",
 905 |                 actual[ 1 ],
 906 |                 "OP_EQUALVERIFY",
 907 |                 actual[ 2 ],
 908 |                 "OP_EQUALVERIFY",
 909 |                 //todo: ensure this is a multisig path that
 910 |                 //sends the money to an address where Bob
 911 |                 //has an opportunity to prove alice cheated
 912 |                 self[ "pubkey" ],
 913 |                 "OP_CHECKSIG"
 914 |             ];
 915 |             var target = tapscript.Tap.encodeScript( script );
 916 |             return [ target, script ];
 917 |         }
 918 |     </script>
 919 |     <script>
 920 |         var aliceChecksFraud = ( step, turn ) => {
 921 |             var bobs_preimage_2;
 922 |             // bobs_preimage_2 = prompt( `Enter bob's second preimage` );
 923 |             if ( !bobs_preimage_2 ) bobs_preimage_2 = "ab";
 924 |             var is_double_turn = proveDoubleTurn( alice[ "bobs_moves" ][ turn - 1 ], bobs_preimage_2, bob, alice );
 925 |             if ( is_double_turn ) {
 926 |                 var txdata = tapscript.Tx.create({
 927 |                     vin: [{
 928 |                         txid: contract[ step ][ "txid" ],
 929 |                         vout: contract[ step ][ "vout" ],
 930 |                         prevout: {
 931 |                             value: contract[ step ][ "amt" ],
 932 |                             scriptPubKey: tapscript.Address.toScriptPubKey( contract[ step ][ "funding_address" ] )
 933 |                         },
 934 |                     }],
 935 |                     vout: [{
 936 |                         value: contract[ step ][ "amt" ] - 500,
 937 |                         scriptPubKey: tapscript.Address.toScriptPubKey( "tb1qd28npep0s8frcm3y7dxqajkcy2m40eysplyr9v" )
 938 |                     }]
 939 |                 });
 940 |                 var target = is_double_turn[ 0 ];
 941 |                 var script = is_double_turn[ 1 ];
 942 |                 var sig = tapscript.Signer.taproot.sign( alice[ "privkey" ], txdata, 0, { extension: target });
 943 |                 var [ tpubkey, cblock ] = tapscript.Tap.getPubKey( "ab".repeat( 32 ), { tree: alice[ "trees" ][ turn ], target });
 944 |                 var bobs_preimage_1 = alice[ "bobs_moves" ][turn-1];
 945 |                 txdata.vin[ 0 ].witness = [ sig, bobs_preimage_1, bobs_preimage_2, script, cblock ];
 946 |                 var txhex = tapscript.Tx.encode( txdata ).hex;
 947 |                 console.log( "broadcast this to take bob's money:", txhex );
 948 |                 txdata.vin[ 0 ].witness = [ sig, bobs_preimage_2, bobs_preimage_1, script, cblock ];
 949 |                 var txhex = tapscript.Tx.encode( txdata ).hex;
 950 |                 console.log( "or this:", txhex );
 951 |             }
 952 |             var hash_of_bobs_preimage = rmd160( hexToBytes( alice[ "bobs_moves" ][ turn - 1 ] ) );
 953 |             var index_of_bobs_preimage = bob[ "hashes" ].indexOf( hash_of_bobs_preimage );
 954 |             var square_bobs_preimage_belongs_to = index_of_bobs_preimage % 9;
 955 |             if ( !alice[ "bobs_squares" ][ square_bobs_preimage_belongs_to ] ) {
 956 |                 alice[ "bobs_squares" ][ square_bobs_preimage_belongs_to ] = alice["bobs_moves"][turn-1];
 957 |             } else {
 958 |                 var bobs_preimage_1 = alice["bobs_moves"][turn-1];
 959 |                 var bobs_preimage_2 = alice["bobs_squares"][ square_bobs_preimage_belongs_to ];
 960 |                 var overwrites_self = proveOverwriteSelf( bobs_preimage_1, bobs_preimage_2, bob, alice );
 961 |                 if ( overwrites_self ) {
 962 |                     var txdata = tapscript.Tx.create({
 963 |                         vin: [{
 964 |                             txid: contract[ step ][ "txid" ],
 965 |                             vout: contract[ step ][ "vout" ],
 966 |                             prevout: {
 967 |                                 value: contract[ step ][ "amt" ],
 968 |                                 scriptPubKey: tapscript.Address.toScriptPubKey( contract[ step ][ "funding_address" ] )
 969 |                             },
 970 |                         }],
 971 |                         vout: [{
 972 |                             value: contract[ step ][ "amt" ] - 500,
 973 |                             scriptPubKey: tapscript.Address.toScriptPubKey( "tb1qd28npep0s8frcm3y7dxqajkcy2m40eysplyr9v" )
 974 |                         }]
 975 |                     });
 976 |                     var target = overwrites_self[ 0 ];
 977 |                     var script = overwrites_self[ 1 ];
 978 |                     var sig = tapscript.Signer.taproot.sign( alice[ "privkey" ], txdata, 0, { extension: target });
 979 |                     var [ tpubkey, cblock ] = tapscript.Tap.getPubKey( "ab".repeat( 32 ), { tree: alice[ "trees" ][ turn ], target });
 980 |                     var bobs_preimage_1 = alice["bobs_moves"][turn-1]
 981 |                     txdata.vin[ 0 ].witness = [ sig, bobs_preimage_1, bobs_preimage_2, script, cblock ];
 982 |                     var txhex = tapscript.Tx.encode( txdata ).hex;
 983 |                     console.log( "broadcast this to take bob's money:", txhex );txdata.vin[ 0 ].witness = [ sig, bobs_preimage_2, bobs_preimage_1, script, cblock ];
 984 |                     var txhex = tapscript.Tx.encode( txdata ).hex;
 985 |                     console.log( "or this:", txhex );
 986 |                 }
 987 |             }
 988 |             var hash_of_bobs_preimage = rmd160( hexToBytes( alice[ "bobs_moves" ][ turn - 1 ] ) );
 989 |             var index_of_bobs_preimage = bob[ "hashes" ].indexOf( hash_of_bobs_preimage );
 990 |             var square_bobs_preimage_belongs_to = index_of_bobs_preimage % 9;
 991 |             if ( alice[ "bobs_acks" ][ square_bobs_preimage_belongs_to ] ) {
 992 |                 var bobs_preimage_1 = alice[ "bobs_moves" ][turn-1];
 993 |                 var bobs_preimage_2 = alice[ "bobs_acks" ][ square_bobs_preimage_belongs_to ];
 994 |                 var overwrites_opponent = proveOverwriteOpponent( bobs_preimage_1, bobs_preimage_2, bob, alice );
 995 |                 if ( overwrites_opponent ) {
 996 |                     var txdata = tapscript.Tx.create({
 997 |                         vin: [{
 998 |                             txid: contract[ step ][ "txid" ],
 999 |                             vout: contract[ step ][ "vout" ],
1000 |                             prevout: {
1001 |                                 value: contract[ step ][ "amt" ],
1002 |                                 scriptPubKey: tapscript.Address.toScriptPubKey( contract[ step ][ "funding_address" ] )
1003 |                             },
1004 |                         }],
1005 |                         vout: [{
1006 |                             value: contract[ step ][ "amt" ] - 500,
1007 |                             scriptPubKey: tapscript.Address.toScriptPubKey( "tb1qd28npep0s8frcm3y7dxqajkcy2m40eysplyr9v" )
1008 |                         }]
1009 |                     });
1010 |                     var target = overwrites_opponent[ 0 ];
1011 |                     var script = overwrites_opponent[ 1 ];
1012 |                     var sig = tapscript.Signer.taproot.sign( alice[ "privkey" ], txdata, 0, { extension: target });
1013 |                     var [ tpubkey, cblock ] = tapscript.Tap.getPubKey( "ab".repeat( 32 ), { tree: alice[ "trees" ][ turn ], target });var bobs_preimage_1 = alice["bobs_moves"][turn-1];txdata.vin[ 0 ].witness = [ sig, bobs_preimage_1, bobs_preimage_2, script, cblock ];var txhex = tapscript.Tx.encode( txdata ).hex;console.log( "broadcast this to take bob's money:", txhex );txdata.vin[ 0 ].witness = [ sig, bobs_preimage_2, bobs_preimage_1, script, cblock ];var txhex = tapscript.Tx.encode( txdata ).hex;console.log( "or this:", txhex );
1014 |                 }
1015 |             }
1016 |         }
1017 |     </script>
1018 |     <script>
1019 |         var bobChecksFraud = ( step, turn ) => {
1020 |             //fraud case 1
1021 | 
1022 |             // Suppose Alice reveals alice[ "preimages" ][ 0 ]. Bob should check if a move is already saved for alice_1. If not, he should save preimage 0 for alice_1. Otherwise he should combine it with the existing alice_1 preimage, find the appropriate tapleaf that lets him take Alice's money (knowing it will never be among tapleaves 0---2 but will be one of the 36 tapleaves among tapleaves 3---38), and do so.
1023 | 
1024 |             var alices_preimage_2;
1025 |             // alices_preimage_2 = prompt( `Enter alice's second preimage` );
1026 |             if ( !alices_preimage_2 ) alices_preimage_2 = "ab";
1027 |             var is_double_turn = proveDoubleTurn( bob[ "alices_moves" ][ turn ], alices_preimage_2, alice, bob );
1028 |             if ( is_double_turn ) {
1029 |                 var txdata = tapscript.Tx.create({
1030 |                     vin: [{
1031 |                         txid: contract[ step ][ "txid" ],
1032 |                         vout: contract[ step ][ "vout" ],
1033 |                         prevout: {
1034 |                             value: contract[ step ][ "amt" ],
1035 |                             scriptPubKey: tapscript.Address.toScriptPubKey( contract[ step ][ "funding_address" ] )
1036 |                         },
1037 |                     }],
1038 |                     vout: [{
1039 |                         value: contract[ step ][ "amt" ] - 500,
1040 |                         scriptPubKey: tapscript.Address.toScriptPubKey( "tb1qd28npep0s8frcm3y7dxqajkcy2m40eysplyr9v" )
1041 |                     }]
1042 |                 });
1043 |                 var target = is_double_turn[ 0 ];
1044 |                 var script = is_double_turn[ 1 ];
1045 |                 var sig = tapscript.Signer.taproot.sign( bob[ "privkey" ], txdata, 0, { extension: target });
1046 |                 var pubkey = "ab".repeat( 32 );
1047 |                 var [ tpubkey, cblock ] = tapscript.Tap.getPubKey( pubkey, { tree: bob[ "trees" ][ turn ], target });
1048 |                 var alices_preimage_1 = bob[ "alices_moves" ][ turn ];
1049 |                 txdata.vin[ 0 ].witness = [ sig, alices_preimage_1, alices_preimage_2, script, cblock ];
1050 |                 var txhex = tapscript.Tx.encode( txdata ).hex;
1051 |                 console.log( "broadcast this to take alice's money:", txhex );
1052 |                 txdata.vin[ 0 ].witness = [ sig, alices_preimage_2, alices_preimage_1, script, cblock ];
1053 |                 var txhex = tapscript.Tx.encode( txdata ).hex;
1054 |                 console.log( "or this:", txhex );
1055 |             }
1056 | 
1057 |             //fraud case 2
1058 | 
1059 |             //Bob should also check which square alice's preimage belongs to and check if that square was already marked by Alice (i.e. if she already revealed preimage[ ( whatever % 9 )+9 ], preimage[ ( whatever % 9 )+9+9 ], or preimage[ ( whatever % 9 )+9+9 ]). If not, he should save Alice's preimage for Alice's square_1. Otherwise he should combine it with the existing square_1 preimage, find the appropriate tapleaf that lets him take Alice's money (knowing it will never be among tapleaves 0---38 but will be one of the 36 tapleaves among tapleaves 39---74), and do so.
1060 | 
1061 |             var hash_of_alices_preimage = rmd160( hexToBytes( bob[ "alices_moves" ][ turn ] ) );
1062 |             var index_of_alices_preimage = alice[ "hashes" ].indexOf( hash_of_alices_preimage );
1063 |             var square_alices_preimage_belongs_to = index_of_alices_preimage % 9;
1064 | 
1065 |             if ( !bob[ "alices_squares" ][ square_alices_preimage_belongs_to ] ) {
1066 |                 bob[ "alices_squares" ][ square_alices_preimage_belongs_to ] = bob[ "alices_moves" ][ turn ];
1067 |             } else {
1068 |                 var alices_preimage_1 = bob[ "alices_moves" ][ turn ];
1069 |                 var alices_preimage_2 = bob[ "alices_squares" ][ square_alices_preimage_belongs_to ];
1070 |                 var overwrites_self = proveOverwriteSelf( alices_preimage_1, alices_preimage_2, alice, bob );
1071 |                 if ( overwrites_self ) {
1072 |                     var txdata = tapscript.Tx.create({
1073 |                         vin: [{
1074 |                             txid: contract[ step ][ "txid" ],
1075 |                             vout: contract[ step ][ "vout" ],
1076 |                             prevout: {
1077 |                                 value: contract[ step ][ "amt" ],
1078 |                                 scriptPubKey: tapscript.Address.toScriptPubKey( contract[ step ][ "funding_address" ] )
1079 |                             },
1080 |                         }],
1081 |                         vout: [{
1082 |                             value: contract[ step ][ "amt" ] - 500,
1083 |                             scriptPubKey: tapscript.Address.toScriptPubKey( "tb1qd28npep0s8frcm3y7dxqajkcy2m40eysplyr9v" )
1084 |                         }]
1085 |                     });
1086 |                     var target = overwrites_self[ 0 ];
1087 |                     var script = overwrites_self[ 1 ];
1088 |                     var sig = tapscript.Signer.taproot.sign( bob[ "privkey" ], txdata, 0, { extension: target });
1089 |                     var pubkey = "ab".repeat( 32 );
1090 |                     var [ tpubkey, cblock ] = tapscript.Tap.getPubKey( pubkey, { tree: bob[ "trees" ][ turn ], target });
1091 |                     var alices_preimage_1 = bob[ "alices_moves" ][ turn ];
1092 |                     txdata.vin[ 0 ].witness = [ sig, alices_preimage_1, alices_preimage_2, script, cblock ];
1093 |                     var txhex = tapscript.Tx.encode( txdata ).hex;
1094 |                     console.log( "broadcast this to take alice's money:", txhex );
1095 |                     txdata.vin[ 0 ].witness = [ sig, alices_preimage_2, alices_preimage_1, script, cblock ];
1096 |                     var txhex = tapscript.Tx.encode( txdata ).hex;
1097 |                     console.log( "or this:", txhex );
1098 |                 }
1099 |             }
1100 | 
1101 |             //fraud case 3
1102 | 
1103 |             //Also, whenever Alice reveals an accept_preimage, Bob should take its number mod 9 and mark that accept_X as taken, where X is a number 1 through 9 corresponding to the number of the accept_preimage Alice revealed. That way, when Alice reveals alice[ "preimages" ][ 0 ] or any other reveal_preimage, Bob can take its number mod 9 and check if she already marked that spot in a previous move. If not, well and good. Otherwise, he should combine the two preimages, find the appropriate tapleaf that lets him take Alice's money (knowing it will never be among tapleaves 0---74 but will be one of the 36 tapleaves among tapleaves 75---110), and do so.
1104 | 
1105 |             var hash_of_alices_preimage = rmd160( hexToBytes( bob[ "alices_moves" ][ turn ] ) );
1106 |             var index_of_alices_preimage = alice[ "hashes" ].indexOf( hash_of_alices_preimage );
1107 |             var square_alices_preimage_belongs_to = index_of_alices_preimage % 9;
1108 | 
1109 |             if ( bob[ "alices_acks" ][ square_alices_preimage_belongs_to ] ) {
1110 |                 var alices_preimage_1 = bob[ "alices_moves" ][ turn ];
1111 |                 var alices_preimage_2 = bob[ "alices_acks" ][ square_alices_preimage_belongs_to ];
1112 |                 var overwrites_opponent = proveOverwriteOpponent( alices_preimage_1, alices_preimage_2, alice, bob );
1113 |                 if ( overwrites_opponent ) {
1114 |                     var txdata = tapscript.Tx.create({
1115 |                         vin: [{
1116 |                             txid: contract[ step ][ "txid" ],
1117 |                             vout: contract[ step ][ "vout" ],
1118 |                             prevout: {
1119 |                                 value: contract[ step ][ "amt" ],
1120 |                                 scriptPubKey: tapscript.Address.toScriptPubKey( contract[ step ][ "funding_address" ] )
1121 |                             },
1122 |                         }],
1123 |                         vout: [{
1124 |                             value: contract[ step ][ "amt" ] - 500,
1125 |                             scriptPubKey: tapscript.Address.toScriptPubKey( "tb1qd28npep0s8frcm3y7dxqajkcy2m40eysplyr9v" )
1126 |                         }]
1127 |                     });
1128 |                     var target = overwrites_opponent[ 0 ];
1129 |                     var script = overwrites_opponent[ 1 ];
1130 |                     var sig = tapscript.Signer.taproot.sign( bob[ "privkey" ], txdata, 0, { extension: target });
1131 |                     var pubkey = "ab".repeat( 32 );
1132 |                     var [ tpubkey, cblock ] = tapscript.Tap.getPubKey( pubkey, { tree: bob[ "trees" ][ turn ], target });
1133 |                     var alices_preimage_1 = bob[ "alices_moves" ][ turn ];
1134 |                     txdata.vin[ 0 ].witness = [ sig, alices_preimage_1, alices_preimage_2, script, cblock ];
1135 |                     var txhex = tapscript.Tx.encode( txdata ).hex;
1136 |                     console.log( "broadcast this to take alice's money:", txhex );
1137 |                     txdata.vin[ 0 ].witness = [ sig, alices_preimage_2, alices_preimage_1, script, cblock ];
1138 |                     var txhex = tapscript.Tx.encode( txdata ).hex;
1139 |                     console.log( "or this:", txhex );
1140 |                 }
1141 |             }
1142 |         }
1143 |     </script>
1144 |     <script>
1145 |         var aliceChecksVictory = ( step, turn, alices_move_preimage ) => {
1146 |             var victory;
1147 |             //check rows
1148 |             var i; for ( i=0; i<3; i++ ) {
1149 |                 if ( i==0 ) var row_nums = [0,1,2];
1150 |                 if ( i==1 ) var row_nums = [3,4,5];
1151 |                 if ( i==2 ) var row_nums = [6,7,8];
1152 |                 for ( var comb of G.combination( row_nums, 2 ) ) {
1153 |                     if ( victory ) continue;
1154 |                     var squares = Array.from( comb );
1155 |                     var bobs_ack_1 = alice[ "bobs_acks" ][ squares[ 0 ] ];
1156 |                     var bobs_ack_2 = alice[ "bobs_acks" ][ squares[ 1 ] ];
1157 |                     if ( !bobs_ack_1 || !bobs_ack_2 ) continue;
1158 |                     victory = proveVictory( bobs_ack_1, bobs_ack_2, alices_move_preimage, bob, alice );
1159 |                 }
1160 |             }
1161 |             if ( victory ) {
1162 |                 var txdata = tapscript.Tx.create({
1163 |                     vin: [{
1164 |                         txid: contract[ step ][ "txid" ],
1165 |                         vout: contract[ step ][ "vout" ],
1166 |                         prevout: {
1167 |                             value: contract[ step ][ "amt" ],
1168 |                             scriptPubKey: tapscript.Address.toScriptPubKey( contract[ step ][ "funding_address" ] )
1169 |                         },
1170 |                     }],
1171 |                     vout: [{
1172 |                         value: contract[ step ][ "amt" ] - 500,
1173 |                         scriptPubKey: tapscript.Address.toScriptPubKey( "tb1qd28npep0s8frcm3y7dxqajkcy2m40eysplyr9v" )
1174 |                     }]
1175 |                 });
1176 |                 var target = victory[ 0 ];
1177 |                 var script = victory[ 1 ];
1178 |                 var sig = tapscript.Signer.taproot.sign( alice[ "privkey" ], txdata, 0, { extension: target });
1179 |                 var pubkey = "ab".repeat( 32 );
1180 |                 var [ tpubkey, cblock ] = tapscript.Tap.getPubKey( pubkey, { tree: alice[ "trees" ][ turn ], target });
1181 |                 txdata.vin[ 0 ].witness = [ sig, bobs_ack_1, bobs_ack_2, alices_move_preimage, script, cblock ];
1182 |                 var txhex = tapscript.Tx.encode( txdata ).hex;
1183 |                 console.log( "broadcast this to take your winnings:", txhex );
1184 |                 txdata.vin[ 0 ].witness = [ sig, bobs_ack_2, bobs_ack_1, alices_move_preimage, script, cblock ];
1185 |                 var txhex = tapscript.Tx.encode( txdata ).hex;
1186 |                 console.log( "or this:", txhex );
1187 |             }
1188 |         }
1189 |         var bobChecksVictory = ( step, turn, bobs_move_preimage ) => {
1190 |             var victory;
1191 |             //check rows
1192 |             var i; for ( i=0; i<3; i++ ) {
1193 |                 if ( i==0 ) var row_nums = [0,1,2];
1194 |                 if ( i==1 ) var row_nums = [3,4,5];
1195 |                 if ( i==2 ) var row_nums = [6,7,8];
1196 |                 for ( var comb of G.combination( row_nums, 2 ) ) {
1197 |                     if ( victory ) continue;
1198 |                     var squares = Array.from( comb );
1199 |                     var alices_ack_1 = bob[ "alices_acks" ][ squares[ 0 ] ];
1200 |                     var alices_ack_2 = bob[ "alices_acks" ][ squares[ 1 ] ];
1201 |                     if ( !alices_ack_1 || !alices_ack_2 ) continue;
1202 |                     victory = proveVictory( alices_ack_1, alices_ack_2, bobs_move_preimage, alice, bob );
1203 |                 }
1204 |             }
1205 |             if ( victory ) {
1206 |                 var txdata = tapscript.Tx.create({
1207 |                     vin: [{
1208 |                         txid: contract[ step ][ "txid" ],
1209 |                         vout: contract[ step ][ "vout" ],
1210 |                         prevout: {
1211 |                             value: contract[ step ][ "amt" ],
1212 |                             scriptPubKey: tapscript.Address.toScriptPubKey( contract[ step ][ "funding_address" ] )
1213 |                         },
1214 |                     }],
1215 |                     vout: [{
1216 |                         value: contract[ step ][ "amt" ] - 500,
1217 |                         scriptPubKey: tapscript.Address.toScriptPubKey( "tb1qd28npep0s8frcm3y7dxqajkcy2m40eysplyr9v" )
1218 |                     }]
1219 |                 });
1220 |                 var target = victory[ 0 ];
1221 |                 var script = victory[ 1 ];
1222 |                 var sig = tapscript.Signer.taproot.sign( bob[ "privkey" ], txdata, 0, { extension: target });
1223 |                 var pubkey = "ab".repeat( 32 );
1224 |                 var [ tpubkey, cblock ] = tapscript.Tap.getPubKey( pubkey, { tree: bob[ "trees" ][ turn ], target });
1225 |                 txdata.vin[ 0 ].witness = [ sig, alices_ack_1, alices_ack_2, bobs_move_preimage, script, cblock ];
1226 |                 var txhex = tapscript.Tx.encode( txdata ).hex;
1227 |                 console.log( "broadcast this to take your winnings:", txhex );
1228 |                 txdata.vin[ 0 ].witness = [ sig, alices_ack_2, alices_ack_1, bobs_move_preimage, script, cblock ];
1229 |                 var txhex = tapscript.Tx.encode( txdata ).hex;
1230 |                 console.log( "or this:", txhex );
1231 |             }
1232 |         }
1233 |     </script>
1234 |     <script>
1235 |         var takeAlicesTurn = async ( step, turn, bobs_turn_address, bobs_preimage, bobs_move ) => {
1236 |             var txdata = tapscript.Tx.create({
1237 |                 vin: [{
1238 |                     txid: contract[ step ][ "txid" ],
1239 |                     vout: contract[ step ][ "vout" ],
1240 |                     prevout: {
1241 |                         value: contract[ step ][ "amt" ],
1242 |                         scriptPubKey: tapscript.Address.toScriptPubKey( contract[ step ][ "funding_address" ] )
1243 |                     },
1244 |                 }],
1245 |                 vout: [{
1246 |                     value: contract[ step ][ "amt" ] - 500,
1247 |                     scriptPubKey: tapscript.Address.toScriptPubKey( bobs_turn_address )
1248 |                 }]
1249 |             });
1250 |             alert( `Please place an X` );
1251 |             game_on = true;
1252 |             var move = await waitForMove();
1253 |             num = undefined;
1254 |             game_on = undefined;
1255 |             move = Number( move ) - 1;
1256 |             var move_preimage = alice[ "preimages" ][ Number( move ) + Number( turn * 9 ) ];
1257 |             aliceChecksVictory( step, turn, move_preimage );
1258 |             if ( victory_achieved ) return alert( `You won! Check your console to collect your winnings!` );
1259 |             if ( turn != 0 ) var accept_preimage = alice[ "accept_preimages" ][ bobs_move + Number( ( turn - 1 ) * 9 ) ];
1260 |             else accept_preimage = "";
1261 |             if ( turn == 0 ) var bobs_preimage = "";
1262 |             if ( turn == 0 ) var bobs_move = move;
1263 |             var target = tapscript.Tap.encodeScript( alice[ "scripts" ][ turn ][ bobs_move + 2 ] );
1264 |             var pubkey = "ab".repeat( 32 );
1265 |             var [ tpubkey, cblock ] = tapscript.Tap.getPubKey( pubkey, { tree: alice[ "trees" ][ turn ], target });
1266 |             var sig_1 = tapscript.Signer.taproot.sign( alice[ "privkey" ], txdata, 0, { extension: target });
1267 |             var sig_2 = tapscript.Signer.taproot.sign( bob[ "privkey" ], txdata, 0, { extension: target });
1268 |             txdata.vin[ 0 ].witness = [ sig_2, sig_1, move_preimage, accept_preimage, bobs_preimage, alice[ "scripts" ][ turn ][ bobs_move + 2 ], cblock ];
1269 |             var ftxhex = tapscript.Tx.encode( txdata ).hex;
1270 |             var vtxid = tapscript.Tx.util.getTxid( txdata );
1271 |             console.log( "Next step, broadcast this txhex to make it Bob's turn:", ftxhex );
1272 |             console.log( `Then, reveal this move_preimage to bob: ${move_preimage}` );
1273 |             if ( turn != 0 ) console.log( "And this accept_preimage:", accept_preimage );
1274 |             contract.push({ txid: vtxid, vout: 0, amt: contract[ step ][ "amt" ] - 500, funding_address: bobs_turn_address, funding_tx: ftxhex });                   
1275 |         }
1276 |         var takeBobsTurn = async ( step, turn, alices_turn_address, alices_preimage, alices_move ) => {
1277 |             var txdata = tapscript.Tx.create({
1278 |                 vin: [{
1279 |                     txid: contract[ step ][ "txid" ],
1280 |                     vout: contract[ step ][ "vout" ],
1281 |                     prevout: {
1282 |                         value: contract[ step ][ "amt" ],
1283 |                         scriptPubKey: tapscript.Address.toScriptPubKey( contract[ step ][ "funding_address" ] )
1284 |                     },
1285 |                 }],
1286 |                 vout: [{
1287 |                     value: contract[ step ][ "amt" ] - 500,
1288 |                     scriptPubKey: tapscript.Address.toScriptPubKey( alices_turn_address )
1289 |                 }]
1290 |             });
1291 |             alert( `Please place an O` );
1292 |             game_on = true;
1293 |             var move = await waitForMove();
1294 |             num = undefined;
1295 |             game_on = undefined;
1296 |             move = Number( move ) - 1;
1297 |             var move_preimage = bob[ "preimages" ][ Number( move ) + Number( turn * 9 ) ];
1298 |             bobChecksVictory( step, turn, move_preimage );
1299 |             if ( victory_achieved ) return alert( `You won! Check your console to collect your winnings!` );
1300 |             var accept_preimage = bob[ "accept_preimages" ][ alices_move + Number( turn * 9 ) ];
1301 |             var target = tapscript.Tap.encodeScript( bob[ "scripts" ][ turn ][ alices_move + 2 ] );
1302 |             var pubkey = "ab".repeat( 32 );
1303 |             var [ tpubkey, cblock ] = tapscript.Tap.getPubKey( pubkey, { tree: bob[ "trees" ][ turn ], target });
1304 |             var sig_1 = tapscript.Signer.taproot.sign( alice[ "privkey" ], txdata, 0, { extension: target });
1305 |             var sig_2 = tapscript.Signer.taproot.sign( bob[ "privkey" ], txdata, 0, { extension: target });
1306 |             txdata.vin[ 0 ].witness = [ sig_2, sig_1, move_preimage, accept_preimage, alices_preimage, bob[ "scripts" ][ turn ][ alices_move + 2 ], cblock ];
1307 |             var ftxhex = tapscript.Tx.encode( txdata ).hex;
1308 |             var vtxid = tapscript.Tx.util.getTxid( txdata );
1309 |             console.log( "Next step, broadcast this txhex to make it Alice's second turn:", ftxhex );
1310 |             console.log( "Then, reveal this move_preimage to alice:", move_preimage );
1311 |             console.log( "And this accept_preimage:", accept_preimage );
1312 |             contract.push({ txid: vtxid, vout: 0, amt: contract[ step ][ "amt" ] - 500, funding_address: alices_turn_address, funding_tx: ftxhex });
1313 |         }
1314 |     </script>
1315 |     <script>
1316 |         var waitForBobsAcceptance = async ( num1, num2, prev_accept_was_invalid ) => {
1317 |             //get bob's acceptance
1318 |             if ( prev_accept_was_invalid ) var msg = `The previous acceptance preimage was invalid. Enter bob's accept_preimage`;
1319 |             else var msg = `Enter bob's accept_preimage`;
1320 |             bobs_accept_preimage = prompt( msg );
1321 |             //check if the accept preimage is valid
1322 |             bobs_accept_hash = rmd160( hexToBytes( bobs_accept_preimage ) );
1323 |             hashes = [ ...bob[ "accept_hashes" ] ];
1324 |             hashes = hashes.splice( num1, num2 );
1325 |             var index = hashes.indexOf( bobs_accept_hash );
1326 |             if ( index < 0 ) return waitForBobsAcceptance( num1, num2, true );
1327 |             return alice[ "bobs_acks" ][ index ] = bobs_accept_preimage;
1328 |         }
1329 |         var waitForBobsMove = async ( num1, num2, prev_move_was_invalid ) => {
1330 |             //get bob's move
1331 |             if ( prev_move_was_invalid ) var msg = `The previous move was invalid. Enter bob's move_preimage`;
1332 |             else var msg = `Enter bob's move_preimage`;
1333 |             bobs_preimage = prompt( msg );
1334 |             //check if the move is valid
1335 |             bobs_hash = rmd160( hexToBytes( bobs_preimage ) );
1336 |             hashes = [ ...bob[ "hashes" ] ];
1337 |             hashes = hashes.splice( num1, num2 );
1338 |             if ( hashes.includes( bobs_hash ) ) return alice[ "bobs_moves" ].push( bobs_preimage );
1339 |             waitForBobsMove( num1, num2, true );
1340 |         }
1341 |         var waitForAlicesAcceptance = async ( num1, num2, prev_accept_was_invalid ) => {
1342 |             //get alice's acceptance
1343 |             if ( prev_accept_was_invalid ) var msg = `The previous acceptance preimage was invalid. Enter alice's accept_preimage`;
1344 |             else var msg = `Enter alice's accept_preimage`;
1345 |             alices_accept_preimage = prompt( msg );
1346 |             //check if the accept preimage is valid
1347 |             alices_accept_hash = rmd160( hexToBytes( alices_accept_preimage ) );
1348 |             hashes = [ ...alice[ "accept_hashes" ] ];
1349 |             hashes = hashes.splice( num1, num2 );
1350 |             var index = hashes.indexOf( alices_accept_hash );
1351 |             if ( index < 0 ) return waitForAlicesAcceptance( num1, num2, true );
1352 |             return bob[ "alices_acks" ][ index ] = alices_accept_preimage;
1353 |         }
1354 |         var waitForAlice = async ( num1, num2, prev_move_was_invalid ) => {
1355 |             //get alice's move
1356 |             if ( prev_move_was_invalid ) var msg = `The previous move was invalid. Enter alice's move_preimage`;
1357 |             else var msg = `Enter alice's move_preimage`;
1358 |             alices_preimage = prompt( msg );
1359 |             //check if the move is valid
1360 |             alices_hash = rmd160( hexToBytes( alices_preimage ) );
1361 |             hashes = [ ...alice[ "hashes" ] ];
1362 |             hashes = hashes.splice( num1, num2 );
1363 |             if ( hashes.includes( alices_hash ) ) return bob[ "alices_moves" ].push( alices_preimage );
1364 |             waitForAlice( num1, num2, true );
1365 |         }
1366 |     </script>
1367 |     <script>
1368 |         var showAlicesMove = () => {
1369 |             alices_move = hashes.indexOf( alices_hash );
1370 |             sessionStorage[ `cell_${alices_move}` ] = "_X_|";
1371 |             if ( alices_move % 3 == 2 ) sessionStorage[ `cell_${alices_move}` ] = "_X_";
1372 |             var cell_0 = sessionStorage[ "cell_0" ];
1373 |             var cell_1 = sessionStorage[ "cell_1" ];
1374 |             var cell_2 = sessionStorage[ "cell_2" ];
1375 |             var cell_3 = sessionStorage[ "cell_3" ];
1376 |             var cell_4 = sessionStorage[ "cell_4" ];
1377 |             var cell_5 = sessionStorage[ "cell_5" ];
1378 |             var cell_6 = sessionStorage[ "cell_6" ];
1379 |             var cell_7 = sessionStorage[ "cell_7" ];
1380 |             var cell_8 = sessionStorage[ "cell_8" ];
1381 |             console.log( cell_0 + cell_1 + cell_2 );
1382 |             console.log( cell_3 + cell_4 + cell_5 );
1383 |             console.log( cell_6 + cell_7 + cell_8 );
1384 |         }
1385 |         var showBobsMove = () => {
1386 |             bobs_move = hashes.indexOf( bobs_hash );
1387 |             sessionStorage[ `cell_${bobs_move}` ] = "_O_|";
1388 |             if ( bobs_move % 3 == 2 ) sessionStorage[ `cell_${bobs_move}` ] = "_O_";
1389 |             var cell_0 = sessionStorage[ "cell_0" ];
1390 |             var cell_1 = sessionStorage[ "cell_1" ];
1391 |             var cell_2 = sessionStorage[ "cell_2" ];
1392 |             var cell_3 = sessionStorage[ "cell_3" ];
1393 |             var cell_4 = sessionStorage[ "cell_4" ];
1394 |             var cell_5 = sessionStorage[ "cell_5" ];
1395 |             var cell_6 = sessionStorage[ "cell_6" ];
1396 |             var cell_7 = sessionStorage[ "cell_7" ];
1397 |             var cell_8 = sessionStorage[ "cell_8" ];
1398 |             console.log( cell_0 + cell_1 + cell_2 );
1399 |             console.log( cell_3 + cell_4 + cell_5 );
1400 |             console.log( cell_6 + cell_7 + cell_8 );
1401 |         }
1402 |     </script>
1403 |     <script>
1404 |         var init = async () => {
1405 |             var alices_first_turn_address = alicesTurn( 0 );
1406 |             var bobs_first_turn_address = bobsTurn( 0 );
1407 |             var alices_second_turn_address = alicesTurn( 1 );
1408 |             var bobs_second_turn_address = bobsTurn( 1 );
1409 |             var alices_third_turn_address = alicesTurn( 2 );
1410 |             var bobs_third_turn_address = bobsTurn( 2 );
1411 |             var alices_fourth_turn_address = alicesTurn( 3 );
1412 |             var bobs_fourth_turn_address = bobsTurn( 3 );
1413 |             var alices_fifth_turn_address = alicesTurn( 4 );
1414 |             console.log( "Step 1, send money to this funding address:", funding_address );
1415 |             var funding_txid = prompt( `please send money to this address: ${funding_address} and enter the txid` );
1416 |             var funding_vout = prompt( `and the vout` );
1417 |             funding_vout = Number( funding_vout );
1418 |             var funding_amt = prompt( `and the amount` );
1419 |             funding_amt = Number( funding_amt );
1420 |             var txdata = tapscript.Tx.create({
1421 |                 vin: [{
1422 |                     txid: funding_txid,
1423 |                     vout: funding_vout,
1424 |                     prevout: {
1425 |                         value: funding_amt,
1426 |                         scriptPubKey: tapscript.Address.toScriptPubKey( funding_address )
1427 |                     },
1428 |                 }],
1429 |                 vout: [{
1430 |                     value: funding_amt - 500,
1431 |                     scriptPubKey: tapscript.Address.toScriptPubKey( alices_first_turn_address )
1432 |                 }]
1433 |             });
1434 |             var sig = tapscript.Signer.taproot.sign( alice[ "privkey" ], txdata, 0 );
1435 |             txdata.vin[ 0 ].witness = [ sig ];
1436 |             var ftxhex = tapscript.Tx.encode( txdata ).hex;
1437 |             var vtxid = tapscript.Tx.util.getTxid( txdata );
1438 |             console.log( "Step 2, broadcast this txhex to start Alice's turn:", ftxhex );
1439 |             var utxo = [ funding_txid, funding_vout, funding_amt ];
1440 |             contract.push({ txid: vtxid, vout: 0, amt: funding_amt - 500, funding_address: alices_first_turn_address, funding_tx: ftxhex });
1441 |             //alice takes her first turn
1442 |             await takeAlicesTurn( 0, 0, bobs_first_turn_address );
1443 |             if ( victory_achieved ) return;
1444 |             //bob waits for alice's info
1445 |             waitForAlice( 0, 9 );
1446 |             showAlicesMove();
1447 |             //bob checks for fraud
1448 |             bobChecksFraud( 1, 0 );
1449 |             if ( fraud_occurred ) return alert( `Oh no, your opponent committed fraud! Check your console to penalize them and take their money` );
1450 |             //bob takes his first turn
1451 |             await takeBobsTurn( 1, 0, alices_second_turn_address, alices_preimage, alices_move );
1452 |             if ( victory_achieved ) return;
1453 |             //alice waits for bob's info
1454 |             waitForBobsAcceptance( 0, 9 );
1455 |             waitForBobsMove( 0, 9 );
1456 |             showBobsMove();
1457 |             //alice checks for fraud
1458 |             aliceChecksFraud( 2, 1 );
1459 |             if ( fraud_occurred ) return alert( `Oh no, your opponent committed fraud! Check your console to penalize them and take their money` );
1460 |             //alice takes her second turn
1461 |             await takeAlicesTurn( 2, 1, bobs_second_turn_address, bobs_preimage, bobs_move );
1462 |             if ( victory_achieved ) return;
1463 |             //bob waits for alice's info
1464 |             waitForAlicesAcceptance( 0, 9 );
1465 |             waitForAlice( 9, 18 );
1466 |             showAlicesMove();
1467 |             //bob checks for fraud
1468 |             bobChecksFraud( 3, 1 );
1469 |             if ( fraud_occurred ) return alert( `Oh no, your opponent committed fraud! Check your console to penalize them and take their money` );
1470 |             //bob takes his second turn
1471 |             await takeBobsTurn( 3, 1, alices_third_turn_address, alices_preimage, alices_move );
1472 |             if ( victory_achieved ) return;
1473 |             //alice waits for bob's info
1474 |             waitForBobsAcceptance( 9, 18 );
1475 |             waitForBobsMove( 9, 18 );
1476 |             showBobsMove();
1477 |             //alice checks for fraud
1478 |             aliceChecksFraud( 4, 2 );
1479 |             if ( fraud_occurred ) return alert( `Oh no, your opponent committed fraud! Check your console to penalize them and take their money` );
1480 |             //alice takes her third turn
1481 |             await takeAlicesTurn( 4, 2, bobs_third_turn_address, bobs_preimage, bobs_move );
1482 |             if ( victory_achieved ) return;
1483 |             //bob waits for alice's info
1484 |             waitForAlicesAcceptance( 9, 18 );
1485 |             waitForAlice( 18, 27 );
1486 |             showAlicesMove();
1487 |             //bob checks for fraud
1488 |             bobChecksFraud( 5, 2 );
1489 |             if ( fraud_occurred ) return alert( `Oh no, your opponent committed fraud! Check your console to penalize them and take their money` );
1490 |             //bob takes his third turn
1491 |             await takeBobsTurn( 5, 2, alices_fourth_turn_address, alices_preimage, alices_move );
1492 |             if ( victory_achieved ) return;
1493 |             //alice waits for bob's info
1494 |             waitForBobsAcceptance( 18, 27 );
1495 |             waitForBobsMove( 18, 27 );
1496 |             showBobsMove();
1497 |             //alice checks for fraud
1498 |             aliceChecksFraud( 6, 3 );
1499 |             if ( fraud_occurred ) return alert( `Oh no, your opponent committed fraud! Check your console to penalize them and take their money` );
1500 |             //alice takes her fourth turn
1501 |             await takeAlicesTurn( 6, 3, bobs_fourth_turn_address, bobs_preimage, bobs_move );
1502 |             if ( victory_achieved ) return;
1503 |             //bob waits for alice's info
1504 |             waitForAlicesAcceptance( 18, 27 );
1505 |             waitForAlice( 27, 36 );
1506 |             showAlicesMove();
1507 |             //bob checks for fraud
1508 |             bobChecksFraud( 7, 3 );
1509 |             if ( fraud_occurred ) return alert( `Oh no, your opponent committed fraud! Check your console to penalize them and take their money` );
1510 |             //bob takes his last turn
1511 |             await takeBobsTurn( 7, 3, alices_fifth_turn_address, alices_preimage, alices_move );
1512 |             if ( victory_achieved ) return;
1513 |             //alice waits for bob's info
1514 |             waitForBobsAcceptance( 27, 36 );
1515 |             waitForBobsMove( 27, 36 );
1516 |             showBobsMove();
1517 |             //alice checks for fraud
1518 |             aliceChecksFraud( 8, 4 );
1519 |             if ( fraud_occurred ) return alert( `Oh no, your opponent committed fraud! Check your console to penalize them and take their money` );
1520 |             //alice takes her last turn
1521 |             await takeAlicesTurn( 8, 4, "tb1qd28npep0s8frcm3y7dxqajkcy2m40eysplyr9v", bobs_preimage, bobs_move );
1522 |             if ( victory_achieved ) return;
1523 |             Object.keys( sessionStorage ).forEach( item => { if ( sessionStorage[ item ].includes( "___|" ) ) sessionStorage[ item ] = "_X_|";if ( sessionStorage[ item ].includes( "___" ) ) sessionStorage[ item ] = "_X_"; });
1524 |             var cell_0 = sessionStorage[ "cell_0" ];
1525 |             var cell_1 = sessionStorage[ "cell_1" ];
1526 |             var cell_2 = sessionStorage[ "cell_2" ];
1527 |             var cell_3 = sessionStorage[ "cell_3" ];
1528 |             var cell_4 = sessionStorage[ "cell_4" ];
1529 |             var cell_5 = sessionStorage[ "cell_5" ];
1530 |             var cell_6 = sessionStorage[ "cell_6" ];
1531 |             var cell_7 = sessionStorage[ "cell_7" ];
1532 |             var cell_8 = sessionStorage[ "cell_8" ];
1533 |             console.log( cell_0 + cell_1 + cell_2 );
1534 |             console.log( cell_3 + cell_4 + cell_5 );
1535 |             console.log( cell_6 + cell_7 + cell_8 );
1536 |         }
1537 |     </script>
1538 | </body>
1539 | </html>
1540 | 


--------------------------------------------------------------------------------
/old-index.html:
--------------------------------------------------------------------------------
   1 | <!DOCTYPE html>
   2 | <html>
   3 |     <head>
   4 |         <meta charset="UTF-8">
   5 |         <meta name="viewport" content="width=device-width, user-scalable=no">
   6 |         <script src="https://unpkg.com/@cmdcode/tapscript@1.4.0"></script>
   7 |         <script src="https://bundle.run/noble-secp256k1@1.2.14"></script>
   8 |         <script src="https://unpkg.com/@dashincubator/ripemd160/ripemd160.js"></script>
   9 |         <script src="https://supertestnet.github.io/bitvm-workshop/combinations.js"></script>
  10 |         <style>
  11 |             * {
  12 |                 box-sizing: border-box;
  13 |                 font-size: 1.15rem;
  14 |                 font-family: Arial, sans-serif;
  15 |             }
  16 |             html {
  17 |                 max-width: 800px;
  18 |                 padding: 3rem 1rem;
  19 |                 margin: auto;
  20 |                 line-height: 1.25;
  21 |                 padding: 0;
  22 |             }
  23 |             body {
  24 |                 margin: 3rem 1rem;
  25 |             }
  26 |             h1 {
  27 |                 font-size: 2rem;
  28 |             }
  29 |             h2 {
  30 |                 font-size: 1.5rem;
  31 |             }
  32 |             input {
  33 |                 line-height: 1.25;
  34 |                 width: 100%;
  35 |                 height: 1.8rem;
  36 |                 font-size: 1.15rem;
  37 |                 border: 1px solid grey;
  38 |             }
  39 |             .tictacbox {
  40 |                 display: flex;
  41 |                 width: 100%;
  42 |                 justify-content: center;
  43 |             }
  44 |             .tictacinner {
  45 |                 display: flex;
  46 |                 width: 15rem;
  47 |             }
  48 |             .square {
  49 |                 height: 5rem;
  50 |                 width: 5rem;
  51 |                 cursor: pointer;
  52 |                 display: flex;
  53 |                 justify-content: center;
  54 |                 align-items: center;
  55 |             }
  56 |             .col2 div {
  57 |                 border-right: 1px solid black;
  58 |                 border-left: 1px solid black;
  59 |             }
  60 |             .square4, .square5, .square6 {
  61 |                 border-top: 1px solid black;
  62 |                 border-bottom: 1px solid black;
  63 |             }
  64 |             @media screen and (max-width: 600px) {
  65 |             }
  66 |         </style>
  67 |         <script>
  68 |             var $ = document.querySelector.bind( document );
  69 |             var $$ = document.querySelectorAll.bind( document );
  70 |             var url_params = new URLSearchParams( window.location.search );
  71 |             var url_keys = url_params.keys();
  72 |             var $_GET = {}
  73 |             for ( var key of url_keys ) $_GET[ key ] = url_params.get( key );
  74 |         </script>
  75 |         <script>
  76 |             var hexToBytes = hex => Uint8Array.from( hex.match( /.{1,2}/g ).map( byte => parseInt( byte, 16 ) ) );
  77 |             var bytesToHex = bytes => bytes.reduce( ( str, byte ) => str + byte.toString( 16 ).padStart( 2, "0" ), "" );
  78 |             var rmd160 = s => {
  79 |                 if ( typeof s == "string" ) s = new TextEncoder().encode( s );
  80 |                 var hash = RIPEMD160.create();
  81 |                 hash.update( new Uint8Array( s ) );
  82 |                 return bytesToHex( hash.digest() );
  83 |             }
  84 |             var waitASec=num=>new Promise(res=>setTimeout(res,num*1000));
  85 |             var waitForMove = async () => {
  86 |                 if ( !num ) await waitASec( 1 );
  87 |                 return num || waitForMove();
  88 |             }
  89 |         </script>
  90 |         <script>
  91 |             var contract = [];
  92 |             var hashes = [];
  93 |             var fraud_occurred = false;
  94 |             var victory_achieved = false;
  95 |             var alice = {
  96 |                 privkey: "ab".repeat( 32 ),
  97 |                 scripts: [],
  98 |                 trees: [],
  99 |                 preimages: [],
 100 |                 hashes: [],
 101 |                 accept_preimages: [],
 102 |                 accept_hashes: [],
 103 |                 bobs_moves: [],
 104 |                 bobs_squares: [],
 105 |                 bobs_acks: [],
 106 |             }
 107 |             alice[ "pubkey" ] = nobleSecp256k1.getPublicKey( alice[ "privkey" ], true ).substring( 2 );
 108 |             var funding_address = tapscript.Address.p2tr.fromPubKey( alice[ "pubkey" ], 'testnet' );
 109 |             var alices_preimage;
 110 |             var alices_hash;
 111 |             var alices_move;
 112 |             var bob = {
 113 |                 privkey: "ba".repeat( 32 ),
 114 |                 scripts: [],
 115 |                 trees: [],
 116 |                 preimages: [],
 117 |                 hashes: [],
 118 |                 accept_preimages: [],
 119 |                 accept_hashes: [],
 120 |                 alices_moves: [],
 121 |                 alices_squares: [],
 122 |                 alices_acks: [],
 123 |             }
 124 |             bob[ "pubkey" ] = nobleSecp256k1.getPublicKey( bob[ "privkey" ], true ).substring( 2 );
 125 |             var bobs_preimage;
 126 |             var bobs_hash;
 127 |             var bobs_move;
 128 |             var i; for ( i=0; i<45; i++ ) {
 129 |                 var preimage = nobleSecp256k1.utils.randomPrivateKey();
 130 |                 preimage = Array.from( preimage );
 131 |                 preimage.splice( 0, 12 );
 132 |                 preimage = new Uint8Array( preimage );
 133 |                 var hash = rmd160( preimage );
 134 |                 preimage = bytesToHex( preimage );
 135 |                 alice[ "preimages" ].push( preimage );
 136 |                 alice[ "hashes" ].push( hash );
 137 |             }
 138 |             var i; for ( i=0; i<36; i++ ) {
 139 |                 var preimage = nobleSecp256k1.utils.randomPrivateKey();
 140 |                 preimage = Array.from( preimage );
 141 |                 preimage.splice( 0, 12 );
 142 |                 preimage = new Uint8Array( preimage );
 143 |                 var hash = rmd160( preimage );
 144 |                 preimage = bytesToHex( preimage );
 145 |                 alice[ "accept_preimages" ].push( preimage );
 146 |                 alice[ "accept_hashes" ].push( hash );
 147 |             }
 148 |             var i; for ( i=0; i<36; i++ ) {
 149 |                 var preimage = nobleSecp256k1.utils.randomPrivateKey();
 150 |                 preimage = Array.from( preimage );
 151 |                 preimage.splice( 0, 12 );
 152 |                 preimage = new Uint8Array( preimage );
 153 |                 var hash = rmd160( preimage );
 154 |                 preimage = bytesToHex( preimage );
 155 |                 bob[ "preimages" ].push( preimage );
 156 |                 bob[ "hashes" ].push( hash );
 157 |             }
 158 |             var i; for ( i=0; i<45; i++ ) {
 159 |                 var preimage = nobleSecp256k1.utils.randomPrivateKey();
 160 |                 preimage = Array.from( preimage );
 161 |                 preimage.splice( 0, 12 );
 162 |                 preimage = new Uint8Array( preimage );
 163 |                 var hash = rmd160( preimage );
 164 |                 preimage = bytesToHex( preimage );
 165 |                 bob[ "accept_preimages" ].push( preimage );
 166 |                 bob[ "accept_hashes" ].push( hash );
 167 |             }
 168 |             var proveDoubleTurn = ( p1, p2, opponent, self ) => {
 169 |                 var h1 = rmd160( hexToBytes( p1 ) );
 170 |                 var h2 = rmd160( hexToBytes( p2 ) );
 171 |                 var combinations = [];
 172 |                 var i; for ( i=1; i<5; i++ ) {
 173 |                     var hashes = [ ...opponent[ "hashes" ] ];
 174 |                     hashes = hashes.splice( ( 9 * i ) - 9, 9 );
 175 |                     for ( var comb of G.combination( hashes, 2 ) ) combinations.push( Array.from( comb ) );
 176 |                 }
 177 |                 var possibles = [];
 178 |                 combinations.forEach( item => {
 179 |                     if ( item.includes( h1 ) ) possibles.push( item );
 180 |                 });
 181 |                 var actual;
 182 |                 possibles.forEach( item => {
 183 |                     if ( item.includes( h2 ) ) actual = item;
 184 |                 });
 185 |                 if ( !actual ) return;
 186 |                 fraud_occurred = true;
 187 |                 var script = [
 188 |                     "OP_RIPEMD160",
 189 |                     "OP_SWAP",
 190 |                     "OP_RIPEMD160",
 191 |                     actual[ 0 ],
 192 |                     "OP_EQUALVERIFY",
 193 |                     actual[ 1 ],
 194 |                     "OP_EQUALVERIFY",
 195 |                     self[ "pubkey" ],
 196 |                     "OP_CHECKSIG"
 197 |                 ];
 198 |                 var target = tapscript.Tap.encodeScript( script );
 199 |                 return [ target, script ];
 200 |             }
 201 |             var proveOverwriteSelf = ( p1, p2, opponent, self ) => {
 202 |                 var h1 = rmd160( hexToBytes( p1 ) );
 203 |                 var h2 = rmd160( hexToBytes( p2 ) );
 204 |                 var actual;
 205 |                 var i; for ( i=0; i<9; i++ ) {
 206 |                     var combinations = [];
 207 |                     var hashes = [];
 208 |                     //Bob's hashes for square 1 are 0, 0+9, 0+9+9, and 0+9+9+9
 209 |                     //For square 2 they are 1, 1+9, 1+9+9, and 1+9+9+9. Etc.
 210 |                     hashes.push( opponent[ "hashes" ][ i ], opponent[ "hashes" ][ i + 9 ], opponent[ "hashes" ][ i + 18 ], opponent[ "hashes" ][ i + 27 ] );
 211 |                     for ( var comb of G.combination( hashes, 2 ) ) combinations.push( Array.from( comb ) );
 212 |                     var possibles = [];
 213 |                     combinations.forEach( item => {
 214 |                         if ( item.includes( h1 ) ) possibles.push( item );
 215 |                     });
 216 |                     possibles.forEach( item => {
 217 |                         if ( item.includes( h2 ) ) actual = item;
 218 |                     });
 219 |                 }
 220 |                 if ( !actual ) return;
 221 |                 fraud_occurred = true;
 222 |                 var script = [
 223 |                     "OP_RIPEMD160",
 224 |                     "OP_SWAP",
 225 |                     "OP_RIPEMD160",
 226 |                     actual[ 0 ],
 227 |                     "OP_EQUALVERIFY",
 228 |                     actual[ 1 ],
 229 |                     "OP_EQUALVERIFY",
 230 |                     self[ "pubkey" ],
 231 |                     "OP_CHECKSIG"
 232 |                 ];
 233 |                 var target = tapscript.Tap.encodeScript( script );
 234 |                 return [ target, script ];
 235 |             }
 236 |             var proveOverwriteOpponent = ( p1, p2, opponent, self ) => {
 237 |                 var h1 = rmd160( hexToBytes( p1 ) );
 238 |                 var h2 = rmd160( hexToBytes( p2 ) );
 239 |                 var actual;
 240 |                 var accept_hashes = [ ...opponent[ "accept_hashes" ] ];
 241 |                 var reveal_hashes = [ ...opponent[ "hashes" ] ];
 242 |                 accept_hashes.forEach( ( item, index ) => {
 243 |                     if (
 244 |                         ( item == h1 || item == h2 ) && 
 245 |                         ( reveal_hashes[ index % 9 ] == h1 || reveal_hashes[ index % 9 ] == h2 )
 246 |                     ) actual = [ item, reveal_hashes[ index % 9 ] ];
 247 |                     if (
 248 |                         ( item == h1 || item == h2 ) && 
 249 |                         ( reveal_hashes[ ( index % 9 ) + 9 ] == h1 || reveal_hashes[ ( index % 9 ) + 9 ] == h2 )
 250 |                     ) actual = [ item, reveal_hashes[ ( index % 9 ) + 9 ] ];
 251 |                     if (
 252 |                         ( item == h1 || item == h2 ) && 
 253 |                         ( reveal_hashes[ ( index % 9 ) + 9 + 9 ] == h1 || reveal_hashes[ ( index % 9 ) + 9 + 9 ] == h2 )
 254 |                     ) actual = [ item, reveal_hashes[ ( index % 9 ) + 9 + 9 ] ];
 255 |                     if (
 256 |                         ( item == h1 || item == h2 ) && 
 257 |                         ( reveal_hashes[ ( index % 9 ) + 9 + 9 + 9 ] == h1 || reveal_hashes[ ( index % 9 ) + 9 + 9 + 9 ] == h2 )
 258 |                     ) actual = [ item, reveal_hashes[ ( index % 9 ) + 9 + 9 + 9 ] ];
 259 |                 });
 260 |                 if ( !actual ) return;
 261 |                 fraud_occurred = true;
 262 |                 var script = [
 263 |                     "OP_RIPEMD160",
 264 |                     "OP_SWAP",
 265 |                     "OP_RIPEMD160",
 266 |                     actual[ 0 ],
 267 |                     "OP_EQUALVERIFY",
 268 |                     actual[ 1 ],
 269 |                     "OP_EQUALVERIFY",
 270 |                     self[ "pubkey" ],
 271 |                     "OP_CHECKSIG"
 272 |                 ];
 273 |                 var target = tapscript.Tap.encodeScript( script );
 274 |                 return [ target, script ];
 275 |             }
 276 |             var proveVictory = ( p1, p2, p3, opponent, self ) => {
 277 |                 var h1 = rmd160( hexToBytes( p1 ) );
 278 |                 var h2 = rmd160( hexToBytes( p2 ) );
 279 |                 var h3 = rmd160( hexToBytes( p3 ) );
 280 |                 var actual;
 281 |                 var combinations = [];
 282 |                 var i; for ( i=0; i<9; i++ ) {
 283 |                     //row 1
 284 |                     if ( i == 0 ) var hashes = [0, 9, 18, 27, 1, 10, 19, 28];
 285 |                     if ( i == 1 ) var hashes = [0, 9, 18, 27, 2, 11, 20, 29];
 286 |                     if ( i == 2 ) var hashes = [1, 10, 19, 28, 2, 11, 20, 29];
 287 |                     //row 2
 288 |                     if ( i == 3 ) var hashes = [3, 12, 21, 30, 4, 13, 22, 31];
 289 |                     if ( i == 4 ) var hashes = [3, 12, 21, 30, 5, 14, 23, 32];
 290 |                     if ( i == 5 ) var hashes = [4, 13, 22, 31, 5, 14, 23, 32];
 291 |                     //row 3
 292 |                     if ( i == 6 ) var hashes = [6, 15, 24, 33, 7, 16, 25, 34];
 293 |                     if ( i == 7 ) var hashes = [6, 15, 24, 33, 8, 17, 26, 35];
 294 |                     if ( i == 8 ) var hashes = [7, 16, 25, 34, 8, 17, 26, 35];
 295 |                     for ( var comb of G.combination( hashes, 2 ) ) {var comb2 = JSON.parse( JSON.stringify( comb ) ); comb2.sort((a,b)=>a-b).reverse(); if ( ( comb2[ 0 ] - comb2[ 1 ] ) % 9 && comb2[ 0 ] - comb2[ 1 ] >= 3 ) combinations.push( Array.from( comb ) );}
 296 |                 }
 297 |                 combinations.forEach( ( item, index ) => {
 298 |                     combinations.splice( index * 5, 1, ...JSON.parse( JSON.stringify( [combinations[ index * 5 ]].flatMap(i => Array(5).fill(i))) ) );
 299 |                 });
 300 |                 combinations.forEach( ( item, index ) => {
 301 |                     if ( item.length > 2 ) return;
 302 |                     //row 1
 303 |                     if ( index < 180 ) {
 304 |                         if ( item[ 0 ] % 3 == 0 && item[ 1 ] % 3 == 1 || item[ 1 ] % 3 == 0 && item[ 0 ] % 3 == 1 ) {
 305 |                             if ( index % 5 == 0 ) item.push( 2 );
 306 |                             if ( index % 5 == 1 ) item.push( 11 );
 307 |                             if ( index % 5 == 2 ) item.push( 20 );
 308 |                             if ( index % 5 == 3 ) item.push( 29 );
 309 |                             if ( index % 5 == 4 ) item.push( 38 );
 310 |                         }
 311 |                         if ( item[ 0 ] % 3 == 0 && item[ 1 ] % 3 == 2 || item[ 1 ] % 3 == 0 && item[ 0 ] % 3 == 2 ) {
 312 |                             if ( index % 5 == 0 ) item.push( 1 );
 313 |                             if ( index % 5 == 1 ) item.push( 10 );
 314 |                             if ( index % 5 == 2 ) item.push( 19 );
 315 |                             if ( index % 5 == 3 ) item.push( 28 );
 316 |                             if ( index % 5 == 4 ) item.push( 37 );
 317 |                         }
 318 |                         if ( item[ 0 ] % 3 == 1 && item[ 1 ] % 3 == 2 || item[ 1 ] % 3 == 1 && item[ 0 ] % 3 == 2 ) {
 319 |                             if ( index % 5 == 0 ) item.push( 0 );
 320 |                             if ( index % 5 == 1 ) item.push( 9 );
 321 |                             if ( index % 5 == 2 ) item.push( 18 );
 322 |                             if ( index % 5 == 3 ) item.push( 27 );
 323 |                             if ( index % 5 == 4 ) item.push( 36 );
 324 |                         }
 325 |                     }
 326 |                     //row 2
 327 |                     if ( index >= 180 && index < 360 ) {
 328 |                         if ( item[ 0 ] % 3 == 0 && item[ 1 ] % 3 == 1 || item[ 1 ] % 3 == 0 && item[ 0 ] % 3 == 1 ) {
 329 |                             if ( index % 5 == 0 ) item.push( 5 );
 330 |                             if ( index % 5 == 1 ) item.push( 14 );
 331 |                             if ( index % 5 == 2 ) item.push( 23 );
 332 |                             if ( index % 5 == 3 ) item.push( 32 );
 333 |                             if ( index % 5 == 4 ) item.push( 41 );
 334 |                         }
 335 |                         if ( item[ 0 ] % 3 == 0 && item[ 1 ] % 3 == 2 || item[ 1 ] % 3 == 0 && item[ 0 ] % 3 == 2 ) {
 336 |                             if ( index % 5 == 0 ) item.push( 4 );
 337 |                             if ( index % 5 == 1 ) item.push( 13 );
 338 |                             if ( index % 5 == 2 ) item.push( 22 );
 339 |                             if ( index % 5 == 3 ) item.push( 31 );
 340 |                             if ( index % 5 == 4 ) item.push( 40 );
 341 |                         }
 342 |                         if ( item[ 0 ] % 3 == 1 && item[ 1 ] % 3 == 2 || item[ 1 ] % 3 == 1 && item[ 0 ] % 3 == 2 ) {
 343 |                             if ( index % 5 == 0 ) item.push( 3 );
 344 |                             if ( index % 5 == 1 ) item.push( 12 );
 345 |                             if ( index % 5 == 2 ) item.push( 21 );
 346 |                             if ( index % 5 == 3 ) item.push( 30 );
 347 |                             if ( index % 5 == 4 ) item.push( 39 );
 348 |                         }
 349 |                     }
 350 |                     //row 3
 351 |                     if ( index >= 360 && index < 540 ) {
 352 |                         if ( item[ 0 ] % 3 == 0 && item[ 1 ] % 3 == 1 || item[ 1 ] % 3 == 0 && item[ 0 ] % 3 == 1 ) {
 353 |                             if ( index % 5 == 0 ) item.push( 8 );
 354 |                             if ( index % 5 == 1 ) item.push( 17 );
 355 |                             if ( index % 5 == 2 ) item.push( 26 );
 356 |                             if ( index % 5 == 3 ) item.push( 35 );
 357 |                             if ( index % 5 == 4 ) item.push( 44 );
 358 |                         }
 359 |                         if ( item[ 0 ] % 3 == 0 && item[ 1 ] % 3 == 2 || item[ 1 ] % 3 == 0 && item[ 0 ] % 3 == 2 ) {
 360 |                             if ( index % 5 == 0 ) item.push( 7 );
 361 |                             if ( index % 5 == 1 ) item.push( 16 );
 362 |                             if ( index % 5 == 2 ) item.push( 25 );
 363 |                             if ( index % 5 == 3 ) item.push( 34 );
 364 |                             if ( index % 5 == 4 ) item.push( 43 );
 365 |                         }
 366 |                         if ( item[ 0 ] % 3 == 1 && item[ 1 ] % 3 == 2 || item[ 1 ] % 3 == 1 && item[ 0 ] % 3 == 2 ) {
 367 |                             if ( index % 5 == 0 ) item.push( 6 );
 368 |                             if ( index % 5 == 1 ) item.push( 15 );
 369 |                             if ( index % 5 == 2 ) item.push( 24 );
 370 |                             if ( index % 5 == 3 ) item.push( 33 );
 371 |                             if ( index % 5 == 4 ) item.push( 42 );
 372 |                         }
 373 |                     }
 374 |                 });
 375 |                 combinations.forEach( ( item, index ) => {
 376 |                     combinations[ index ][ 0 ] = opponent[ "accept_hashes" ][ item[ 0 ] ];
 377 |                     combinations[ index ][ 1 ] = opponent[ "accept_hashes" ][ item[ 1 ] ];
 378 |                     combinations[ index ][ 2 ] = self[ "hashes" ][ item[ 2 ] ];
 379 |                 });
 380 |                 var possibles = [];
 381 |                 combinations.forEach( item => {
 382 |                     if ( item.includes( h1 ) && item.includes( h2 ) ) possibles.push( item );
 383 |                 });
 384 |                 possibles.forEach( item => {
 385 |                     if ( item.includes( h3 ) ) actual = item;
 386 |                 });
 387 |                 if ( !actual ) return;
 388 |                 actual.reverse();
 389 |                 victory_achieved = true;
 390 |                 var script = [
 391 |                     "OP_RIPEMD160",
 392 |                     "OP_SWAP",
 393 |                     "OP_RIPEMD160",
 394 |                     2,
 395 |                     "OP_ROLL",
 396 |                     "OP_RIPEMD160",
 397 |                     "OP_SWAP",
 398 |                     2,
 399 |                     "OP_ROLL",
 400 |                     actual[ 0 ],
 401 |                     "OP_EQUALVERIFY",
 402 |                     actual[ 1 ],
 403 |                     "OP_EQUALVERIFY",
 404 |                     actual[ 2 ],
 405 |                     "OP_EQUALVERIFY",
 406 |                     //todo: ensure this is a multisig path that
 407 |                     //sends the money to an address where Bob
 408 |                     //has an opportunity to prove alice cheated
 409 |                     self[ "pubkey" ],
 410 |                     "OP_CHECKSIG"
 411 |                 ];
 412 |                 var target = tapscript.Tap.encodeScript( script );
 413 |                 return [ target, script ];
 414 |             }
 415 |         </script>
 416 |     </head>
 417 |     <body>
 418 |         <h1>Welcome to bit tac toe</h1>
 419 |         <p><button onclick="init()">Play</button></p>
 420 |         <div class="tictacbox">
 421 |             <div class="tictacinner">
 422 |                 <div class="col1">
 423 |                     <div class="square square1"></div>
 424 |                     <div class="square square4"></div>
 425 |                     <div class="square square7"></div>
 426 |                 </div>
 427 |                 <div class="col2">
 428 |                     <div class="square square2"></div>
 429 |                     <div class="square square5"></div>
 430 |                     <div class="square square8"></div>
 431 |                 </div>
 432 |                 <div class="col3">
 433 |                     <div class="square square3"></div>
 434 |                     <div class="square square6"></div>
 435 |                     <div class="square square9"></div>
 436 |                 </div>
 437 |             </div>
 438 |         </div>
 439 |         <script>
 440 |             var type = 1;
 441 |             var num;
 442 |             var game_on;
 443 |             $$( '.square' ).forEach( item => {
 444 |                 item.onclick = () => {
 445 |                     if ( !game_on ) return;
 446 |                     var conf = true;
 447 |                     if ( item.innerHTML ) conf = confirm( `This is an illegal move! Your opponent will be able to take your money. Click ok to do it anyway` );
 448 |                     if ( !conf ) return;
 449 |                     var symbol = `<span style="font-size: 200%;">&times;</span>`
 450 |                     if ( !type ) symbol = `&#9711`;
 451 |                     item.innerHTML = symbol;
 452 |                     type = !type;
 453 |                     var a = item.classList[ 1 ];
 454 |                     num = Number( a.substring( a.length - 1, a.length ) );
 455 |                 }
 456 |             });
 457 |         </script>
 458 |         <script>
 459 |             sessionStorage[ "cell_0" ] = `___|`;
 460 |             sessionStorage[ "cell_1" ] = `___|`;
 461 |             sessionStorage[ "cell_2" ] = `___`;
 462 |             sessionStorage[ "cell_3" ] = `___|`;
 463 |             sessionStorage[ "cell_4" ] = `___|`;
 464 |             sessionStorage[ "cell_5" ] = `___`;
 465 |             sessionStorage[ "cell_6" ] = `___|`;
 466 |             sessionStorage[ "cell_7" ] = `___|`;
 467 |             sessionStorage[ "cell_8" ] = `___`;
 468 |             var alicesTurn = turn => {
 469 |                 var original_turn = turn;
 470 |                 turn = turn * 9;
 471 |                 // The first two scripts are simple -- one is the 'happy path' whereby Alice and Bob cooperate,
 472 |                 // the other lets Bob takes Alice's money if Alice stops playing
 473 |                 var alices_turn_scripts = [
 474 |                     [ 0, alice[ "pubkey" ], "OP_CHECKSIGADD", bob[ "pubkey" ], "OP_CHECKSIGADD", 2, "OP_EQUAL" ],
 475 |                     [ 10, "OP_CHECKSEQUENCEVERIFY", bob[ "pubkey" ], "OP_CHECKSIG" ],
 476 |                 ];
 477 | 
 478 |                 // this third script is more complex -- it forces Alice to reveal one of 9 preimages to represent
 479 |                 // marking an X in one of 9 squares of a tic tac toe board
 480 |                 var i; for ( i=turn; i<turn + 9; i++ ) {
 481 |                     if ( turn === 0 ) {
 482 |                         var initial_tapleaf_preimage = "";
 483 |                         var initial_tapleaf_guard = "9c1185a5c5e9fc54612808977ee8f548b2258d31";
 484 |                         var tapleaf_guard = initial_tapleaf_guard;
 485 |                         var initial_accept_preimage = "";
 486 |                         var initial_accept_guard = "9c1185a5c5e9fc54612808977ee8f548b2258d31";
 487 |                         var accept_guard = initial_accept_guard;
 488 |                     } else {
 489 |                         var tapleaf_guard = bob[ "hashes" ][ i - 9 ];
 490 |                         var accept_guard = alice[ "accept_hashes" ][ i - 9 ];
 491 |                     }
 492 |                     var alices_turn_third_script = [
 493 |                         "OP_RIPEMD160",
 494 |                         tapleaf_guard,
 495 |                         "OP_EQUALVERIFY",
 496 |                         "OP_RIPEMD160",
 497 |                         accept_guard,
 498 |                         "OP_EQUALVERIFY",
 499 |                         "OP_RIPEMD160",
 500 |                         "OP_DUP",
 501 |                         alice[ "hashes" ][ turn ],
 502 |                         "OP_EQUAL",
 503 |                         "OP_SWAP",
 504 |                     ];
 505 |                     var j; for ( j=turn + 1; j<turn + 9; j++ ) {
 506 |                         alices_turn_third_script.push( ...[
 507 |                             "OP_DUP",
 508 |                             alice[ "hashes"][ j ],
 509 |                             "OP_EQUAL",
 510 |                             "OP_ROT",
 511 |                             "OP_ADD",
 512 |                             "OP_SWAP",
 513 |                         ]);
 514 |                     }
 515 |                     alices_turn_third_script.push( ...[
 516 |                         "OP_DROP",
 517 |                         "OP_VERIFY",
 518 |                         0,
 519 |                         alice[ "pubkey" ],
 520 |                         "OP_CHECKSIGADD",
 521 |                         bob[ "pubkey" ],
 522 |                         "OP_CHECKSIGADD",
 523 |                         2,
 524 |                         "OP_EQUAL",
 525 |                     ]);
 526 |                     alices_turn_scripts.push( alices_turn_third_script );
 527 |                 }
 528 | 
 529 |                 //allow Alice to prove fraud if Bob reveals two preimages for any of his turns
 530 |                 var i; for ( i=1; i<5; i++ ) {
 531 |                     var combinations = [];
 532 |                     var hashes = [ ...bob[ "hashes" ] ];
 533 |                     hashes = hashes.splice( ( 9 * i ) - 9, 9 );
 534 |                     for ( var comb of G.combination( hashes, 2 ) ) combinations.push( Array.from( comb ) );
 535 |                     combinations.forEach( combination => {
 536 |                         alices_turn_scripts.push([
 537 |                             "OP_RIPEMD160",
 538 |                             "OP_SWAP",
 539 |                             "OP_RIPEMD160",
 540 |                             combination[ 0 ],
 541 |                             "OP_EQUALVERIFY",
 542 |                             combination[ 1 ],
 543 |                             "OP_EQUALVERIFY",
 544 |                             alice[ "pubkey" ],
 545 |                             "OP_CHECKSIG"
 546 |                         ]);
 547 |                     });
 548 |                 }
 549 | 
 550 |                 //allow Alice to prove fraud if Bob reveals two different preimage pairs for the
 551 |                 //same square (thus overwriting one of his own squares)
 552 |                 var i; for ( i=0; i<9; i++ ) {
 553 |                     var combinations = [];
 554 |                     var hashes = [];
 555 |                     //Bob's hashes for square 1 are 0, 0+9, 0+9+9, and 0+9+9+9
 556 |                     //For square 2 they are 1, 1+9, 1+9+9, and 1+9+9+9. Etc.
 557 |                     hashes.push( bob[ "hashes" ][ i ], bob[ "hashes" ][ i + 9 ], bob[ "hashes" ][ i + 18 ], bob[ "hashes" ][ i + 27 ] );
 558 |                     for ( var comb of G.combination( hashes, 2 ) ) combinations.push( Array.from( comb ) );
 559 |                     combinations.forEach( combination => {
 560 |                         alices_turn_scripts.push([
 561 |                             "OP_RIPEMD160",
 562 |                             "OP_SWAP",
 563 |                             "OP_RIPEMD160",
 564 |                             combination[ 0 ],
 565 |                             "OP_EQUALVERIFY",
 566 |                             combination[ 1 ],
 567 |                             "OP_EQUALVERIFY",
 568 |                             alice[ "pubkey" ],
 569 |                             "OP_CHECKSIG"
 570 |                         ]);
 571 |                     });
 572 |                 }
 573 | 
 574 |                 //allow Alice to prove fraud if Bob reveals an accept preimage and a reveal preimage
 575 |                 //for any square (thus proving Bob tried to overwrite one of Alice’s squares)
 576 |                 //Bob commits fraud if he reveals accept[ 0 ] and reveal[ 0 ], reveal[ 0 + 9 ], reveal[ 0 + 9 + 9 ], or reveal[ 0 + 9 + 9 + 9 ]. He also commits fraud if he reveals accept[ 35 ] and reveal[ 35 % 9 ], reveal[ ( 35 % 9 ) + 9 ], reveal[ ( 35 % 9 ) + 9 + 9 ], or reveal[ ( 35 % 9 ) + 9 + 9 + 9 ]
 577 |                 var accept_hashes = [ ...bob[ "accept_hashes" ] ];
 578 |                 var reveal_hashes = [ ...bob[ "hashes" ] ];
 579 |                 accept_hashes.forEach( ( item, index ) => {
 580 |                     alices_turn_scripts.push([
 581 |                         "OP_RIPEMD160",
 582 |                         "OP_SWAP",
 583 |                         "OP_RIPEMD160",
 584 |                         item,
 585 |                         "OP_EQUALVERIFY",
 586 |                         reveal_hashes[ index % 9 ],
 587 |                         "OP_EQUALVERIFY",
 588 |                         alice[ "pubkey" ],
 589 |                         "OP_CHECKSIG"
 590 |                     ]);
 591 |                     alices_turn_scripts.push([
 592 |                         "OP_RIPEMD160",
 593 |                         "OP_SWAP",
 594 |                         "OP_RIPEMD160",
 595 |                         item,
 596 |                         "OP_EQUALVERIFY",
 597 |                         reveal_hashes[ ( index % 9 ) + 9 ],
 598 |                         "OP_EQUALVERIFY",
 599 |                         alice[ "pubkey" ],
 600 |                         "OP_CHECKSIG"
 601 |                     ]);
 602 |                     alices_turn_scripts.push([
 603 |                         "OP_RIPEMD160",
 604 |                         "OP_SWAP",
 605 |                         "OP_RIPEMD160",
 606 |                         item,
 607 |                         "OP_EQUALVERIFY",
 608 |                         reveal_hashes[ ( index % 9 ) + 9 + 9 ],
 609 |                         "OP_EQUALVERIFY",
 610 |                         alice[ "pubkey" ],
 611 |                         "OP_CHECKSIG"
 612 |                     ]);
 613 |                     alices_turn_scripts.push([
 614 |                         "OP_RIPEMD160",
 615 |                         "OP_SWAP",
 616 |                         "OP_RIPEMD160",
 617 |                         item,
 618 |                         "OP_EQUALVERIFY",
 619 |                         reveal_hashes[ ( index % 9 ) + 9 + 9 + 9 ],
 620 |                         "OP_EQUALVERIFY",
 621 |                         alice[ "pubkey" ],
 622 |                         "OP_CHECKSIG"
 623 |                     ]);
 624 |                 });
 625 | 
 626 |                 //allow Alice to claim victory if she reveals two acks and a preimage of
 627 |                 //her own for any row
 628 | 
 629 |                 //Bob's ack_hashes for square 1 are 0, 0+9, 0+9+9, and 0+9+9+9
 630 |                 //For square 2 they are 1, 1+9, 1+9+9, and 1+9+9+9. For square
 631 |                 //3 they are 2, 2+9, 2+9+9, and 2+9+9+9. Alice needs any pair
 632 |                 //of those where they have a different "base" (0, 1, or 2) plus
 633 |                 //she needs to reveal the "remaining" square in the row.
 634 |                 //So, in terms of the "ack" preimages, she needs one of these
 635 |                 //combinations:
 636 |                 //0, 1+9 | 0, 1+9+9 | 0, 1+9+9+9
 637 |                 //0+9, 1 | 0+9, 1+9+9 | 0+9, 1+9+9+9
 638 |                 //0+9+9, 1 | 0+9+9, 1+9 | 0+9+9, 1+9+9+9
 639 |                 //0+9+9+9, 1 | 0+9+9+9, 1+9 | 0+9+9+9, 1+9+9
 640 |                 //0, 2+9 | 0, 2+9+9 | 0, 2+9+9+9
 641 |                 //0+9, 2 | 0+9, 2+9+9 | 0+9, 2+9+9+9
 642 |                 //0+9+9, 2 | 0+9+9, 2+9 | 0+9+9, 2+9+9+9
 643 |                 //0+9+9+9, 2 | 0+9+9+9, 2+9 | 0+9+9+9, 2+9+9
 644 |                 //1, 2+9 | 1, 2+9+9 | 1, 2+9+9+9
 645 |                 //1+9, 2 | 1+9, 2+9+9 | 1+9, 2+9+9+9
 646 |                 //1+9+9, 2 | 1+9+9, 2+9 | 1+9+9, 2+9+9+9
 647 |                 //1+9+9+9, 2 | 1+9+9+9, 2+9 | 1+9+9+9, 2+9+9
 648 |                 //Every 4 lines above contain every pair from these sets:
 649 |                 //0, 9, 18, 27, 1, 10, 19, 28 <-- all 4 square 1s and all 4 square 2s
 650 |                 //0, 9, 18, 27, 2, 11, 20, 29 <-- all 4 square 1s and all 4 square 3s
 651 |                 //1, 10, 19, 28, 2, 11, 20, 29 <-- all 4 square 2s and all 4 square 3s
 652 |                 //but only the ones from different sets (i.e. 0 and 1 should not
 653 |                 //be together because they are in the same set)
 654 |                 // var combinations = [];
 655 |                 // var hashes = [0, 9, 18, 27, 1, 10, 19, 28];
 656 |                 // for ( var comb of G.combination( hashes, 2 ) ) {var comb2 = JSON.parse( JSON.stringify( comb ) ); comb2.sort((a,b)=>a-b).reverse(); console.log( comb2, !!( ( comb2[ 0 ] - comb2[ 1 ] ) % 3 ), comb2[ 0 ] - comb2[ 1 ] >= 8 ); if ( ( comb2[ 0 ] - comb2[ 1 ] ) % 9 && comb2[ 0 ] - comb2[ 1 ] >= 3 ) combinations.push( Array.from( comb ) );}
 657 |                 // console.log( combinations );
 658 |                 //Running the above code 3 times with the different sets should get me every
 659 |                 //combination of 2 "X"s that can win the row. Each duo *also* needs the third square
 660 |                 //-- for the first example ( 0, 10 ) I can figure out which one is needed by taking
 661 |                 //the two numbers mod 3 and seeing what is missing. 0 % 3 = 0 and 10 % 3 = 1, so I am
 662 |                 //missing 2. There are five different 2s I can supply as the missing 2 so I need to
 663 |                 //multiply my copy of ( 0, 10 ) by 5 and fill each one in with one of the following
 664 |                 //numbers: 2, 11, 20, 29, 38
 665 |                 //the code below should get me every possible "winning" combination of the row
 666 |                 //-- and apparently there are 180 ways to win in any row. I should be able to
 667 |                 //repeat this procedure for each row and diagonal to get most of the ways to
 668 |                 //win, and for winning by columns, it is mostly the same procedure, except
 669 |                 //the `var hashes=` parts will be different, and the parts that say
 670 |                 //`item[ 0 ] % 3 == 0 && item[ 1 ] % 3 == 1` will require the squares to both
 671 |                 //have 0s in them or 1s in them or 2s in them, and the parts that say
 672 |                 //`item.push( 0 );` will each have a different last number
 673 | 
 674 |                 var combinations = [];
 675 |                 var i; for ( i=0; i<9; i++ ) {
 676 |                     //row 1
 677 |                     if ( i == 0 ) var hashes = [0, 9, 18, 27, 1, 10, 19, 28];
 678 |                     if ( i == 1 ) var hashes = [0, 9, 18, 27, 2, 11, 20, 29];
 679 |                     if ( i == 2 ) var hashes = [1, 10, 19, 28, 2, 11, 20, 29];
 680 |                     //row 2
 681 |                     if ( i == 3 ) var hashes = [3, 12, 21, 30, 4, 13, 22, 31];
 682 |                     if ( i == 4 ) var hashes = [3, 12, 21, 30, 5, 14, 23, 32];
 683 |                     if ( i == 5 ) var hashes = [4, 13, 22, 31, 5, 14, 23, 32];
 684 |                     //row 3
 685 |                     if ( i == 6 ) var hashes = [6, 15, 24, 33, 7, 16, 25, 34];
 686 |                     if ( i == 7 ) var hashes = [6, 15, 24, 33, 8, 17, 26, 35];
 687 |                     if ( i == 8 ) var hashes = [7, 16, 25, 34, 8, 17, 26, 35];
 688 |                     for ( var comb of G.combination( hashes, 2 ) ) {var comb2 = JSON.parse( JSON.stringify( comb ) ); comb2.sort((a,b)=>a-b).reverse(); if ( ( comb2[ 0 ] - comb2[ 1 ] ) % 9 && comb2[ 0 ] - comb2[ 1 ] >= 3 ) combinations.push( Array.from( comb ) );}
 689 |                 }
 690 |                 combinations.forEach( ( item, index ) => {
 691 |                     combinations.splice( index * 5, 1, ...JSON.parse( JSON.stringify( [combinations[ index * 5 ]].flatMap(i => Array(5).fill(i))) ) );
 692 |                 });
 693 |                 combinations.forEach( ( item, index ) => {
 694 |                     if ( item.length > 2 ) return;
 695 |                     //row 1
 696 |                     if ( index < 180 ) {
 697 |                         if ( item[ 0 ] % 3 == 0 && item[ 1 ] % 3 == 1 || item[ 1 ] % 3 == 0 && item[ 0 ] % 3 == 1 ) {
 698 |                             if ( index % 5 == 0 ) item.push( 2 );
 699 |                             if ( index % 5 == 1 ) item.push( 11 );
 700 |                             if ( index % 5 == 2 ) item.push( 20 );
 701 |                             if ( index % 5 == 3 ) item.push( 29 );
 702 |                             if ( index % 5 == 4 ) item.push( 38 );
 703 |                         }
 704 |                         if ( item[ 0 ] % 3 == 0 && item[ 1 ] % 3 == 2 || item[ 1 ] % 3 == 0 && item[ 0 ] % 3 == 2 ) {
 705 |                             if ( index % 5 == 0 ) item.push( 1 );
 706 |                             if ( index % 5 == 1 ) item.push( 10 );
 707 |                             if ( index % 5 == 2 ) item.push( 19 );
 708 |                             if ( index % 5 == 3 ) item.push( 28 );
 709 |                             if ( index % 5 == 4 ) item.push( 37 );
 710 |                         }
 711 |                         if ( item[ 0 ] % 3 == 1 && item[ 1 ] % 3 == 2 || item[ 1 ] % 3 == 1 && item[ 0 ] % 3 == 2 ) {
 712 |                             if ( index % 5 == 0 ) item.push( 0 );
 713 |                             if ( index % 5 == 1 ) item.push( 9 );
 714 |                             if ( index % 5 == 2 ) item.push( 18 );
 715 |                             if ( index % 5 == 3 ) item.push( 27 );
 716 |                             if ( index % 5 == 4 ) item.push( 36 );
 717 |                         }
 718 |                     }
 719 |                     //row 2
 720 |                     if ( index >= 180 && index < 360 ) {
 721 |                         if ( item[ 0 ] % 3 == 0 && item[ 1 ] % 3 == 1 || item[ 1 ] % 3 == 0 && item[ 0 ] % 3 == 1 ) {
 722 |                             if ( index % 5 == 0 ) item.push( 5 );
 723 |                             if ( index % 5 == 1 ) item.push( 14 );
 724 |                             if ( index % 5 == 2 ) item.push( 23 );
 725 |                             if ( index % 5 == 3 ) item.push( 32 );
 726 |                             if ( index % 5 == 4 ) item.push( 41 );
 727 |                         }
 728 |                         if ( item[ 0 ] % 3 == 0 && item[ 1 ] % 3 == 2 || item[ 1 ] % 3 == 0 && item[ 0 ] % 3 == 2 ) {
 729 |                             if ( index % 5 == 0 ) item.push( 4 );
 730 |                             if ( index % 5 == 1 ) item.push( 13 );
 731 |                             if ( index % 5 == 2 ) item.push( 22 );
 732 |                             if ( index % 5 == 3 ) item.push( 31 );
 733 |                             if ( index % 5 == 4 ) item.push( 40 );
 734 |                         }
 735 |                         if ( item[ 0 ] % 3 == 1 && item[ 1 ] % 3 == 2 || item[ 1 ] % 3 == 1 && item[ 0 ] % 3 == 2 ) {
 736 |                             if ( index % 5 == 0 ) item.push( 3 );
 737 |                             if ( index % 5 == 1 ) item.push( 12 );
 738 |                             if ( index % 5 == 2 ) item.push( 21 );
 739 |                             if ( index % 5 == 3 ) item.push( 30 );
 740 |                             if ( index % 5 == 4 ) item.push( 39 );
 741 |                         }
 742 |                     }
 743 |                     //row 3
 744 |                     if ( index >= 360 && index < 540 ) {
 745 |                         if ( item[ 0 ] % 3 == 0 && item[ 1 ] % 3 == 1 || item[ 1 ] % 3 == 0 && item[ 0 ] % 3 == 1 ) {
 746 |                             if ( index % 5 == 0 ) item.push( 8 );
 747 |                             if ( index % 5 == 1 ) item.push( 17 );
 748 |                             if ( index % 5 == 2 ) item.push( 26 );
 749 |                             if ( index % 5 == 3 ) item.push( 35 );
 750 |                             if ( index % 5 == 4 ) item.push( 44 );
 751 |                         }
 752 |                         if ( item[ 0 ] % 3 == 0 && item[ 1 ] % 3 == 2 || item[ 1 ] % 3 == 0 && item[ 0 ] % 3 == 2 ) {
 753 |                             if ( index % 5 == 0 ) item.push( 7 );
 754 |                             if ( index % 5 == 1 ) item.push( 16 );
 755 |                             if ( index % 5 == 2 ) item.push( 25 );
 756 |                             if ( index % 5 == 3 ) item.push( 34 );
 757 |                             if ( index % 5 == 4 ) item.push( 43 );
 758 |                         }
 759 |                         if ( item[ 0 ] % 3 == 1 && item[ 1 ] % 3 == 2 || item[ 1 ] % 3 == 1 && item[ 0 ] % 3 == 2 ) {
 760 |                             if ( index % 5 == 0 ) item.push( 6 );
 761 |                             if ( index % 5 == 1 ) item.push( 15 );
 762 |                             if ( index % 5 == 2 ) item.push( 24 );
 763 |                             if ( index % 5 == 3 ) item.push( 33 );
 764 |                             if ( index % 5 == 4 ) item.push( 42 );
 765 |                         }
 766 |                     }
 767 |                 });
 768 |                 combinations.forEach( combination => {
 769 |                     //the witness stack here must have Bob's
 770 |                     //first ack_preimage on the bottom,
 771 |                     //then Bob's second ack_preimage, then
 772 |                     //Alice's last square on top
 773 |                     alices_turn_scripts.push([
 774 |                         "OP_RIPEMD160",
 775 |                         "OP_SWAP",
 776 |                         "OP_RIPEMD160",
 777 |                         2,
 778 |                         "OP_ROLL",
 779 |                         "OP_RIPEMD160",
 780 |                         "OP_SWAP",
 781 |                         2,
 782 |                         "OP_ROLL",
 783 |                         alice[ "hashes" ][ combination[ 2 ] ],
 784 |                         "OP_EQUALVERIFY",
 785 |                         bob[ "accept_hashes" ][ combination[ 1 ] ],
 786 |                         "OP_EQUALVERIFY",
 787 |                         bob[ "accept_hashes" ][ combination[ 0 ] ],
 788 |                         "OP_EQUALVERIFY",
 789 |                         //todo: ensure this is a multisig path that
 790 |                         //sends the money to an address where Bob
 791 |                         //has an opportunity to prove alice cheated
 792 |                         alice[ "pubkey" ],
 793 |                         "OP_CHECKSIG"
 794 |                     ]);
 795 |                 });
 796 | 
 797 |                 alice[ "trees" ].push( alices_turn_scripts.map( s => tapscript.Tap.encodeScript( s ) ) );
 798 |                 alice[ "scripts" ].push( alices_turn_scripts );
 799 |                 var pubkey = "ab".repeat( 32 );
 800 |                 var [ tpubkey ] = tapscript.Tap.getPubKey( pubkey, { tree: alice[ "trees" ][ original_turn ] });
 801 |                 var alices_turn_address = tapscript.Address.p2tr.fromPubKey( tpubkey, 'testnet' );
 802 |                 return alices_turn_address;
 803 |             }
 804 |             var bobsTurn = turn => {
 805 |                 var original_turn = turn;
 806 |                 turn = turn * 9;
 807 |                 // The first two scripts are simple -- one is the 'happy path' whereby Alice and Bob cooperate,
 808 |                 // the other lets Alice takes Bob's money if Bob stops playing
 809 |                 var bobs_turn_scripts = [
 810 |                     [ 0, alice[ "pubkey" ], "OP_CHECKSIGADD", bob[ "pubkey" ], "OP_CHECKSIGADD", 2, "OP_EQUAL" ],
 811 |                     [ 10, "OP_CHECKSEQUENCEVERIFY", alice[ "pubkey" ], "OP_CHECKSIG" ],
 812 |                 ];
 813 | 
 814 |                 // this third script is more complex -- it forces Bob to "accept" Alice's previous move and
 815 |                 // reveal one of 9 preimages to represent marking an O in the tic tac toe board
 816 |                 var i; for ( i=turn; i<turn + 9; i++ ) {
 817 |                     var tapleaf_guard = alice[ "hashes" ][ i ];
 818 |                     var accept_guard = bob[ "accept_hashes" ][ i ];
 819 |                     var bobs_turn_third_script = [
 820 |                         "OP_RIPEMD160",
 821 |                         tapleaf_guard,
 822 |                         "OP_EQUALVERIFY",
 823 |                         "OP_RIPEMD160",
 824 |                         accept_guard,
 825 |                         "OP_EQUALVERIFY",
 826 |                         "OP_RIPEMD160",
 827 |                         "OP_DUP",
 828 |                         bob[ "hashes" ][ turn ],
 829 |                         "OP_EQUAL",
 830 |                         "OP_SWAP",
 831 |                     ];
 832 |                     var j; for ( j=turn + 1; j<turn + 9; j++ ) {
 833 |                         bobs_turn_third_script.push( ...[
 834 |                             "OP_DUP",
 835 |                             bob[ "hashes"][ j ],
 836 |                             "OP_EQUAL",
 837 |                             "OP_ROT",
 838 |                             "OP_ADD",
 839 |                             "OP_SWAP",
 840 |                         ]);
 841 |                     }
 842 |                     bobs_turn_third_script.push( ...[
 843 |                         "OP_DROP",
 844 |                         "OP_VERIFY",
 845 |                         0,
 846 |                         alice[ "pubkey" ],
 847 |                         "OP_CHECKSIGADD",
 848 |                         bob[ "pubkey" ],
 849 |                         "OP_CHECKSIGADD",
 850 |                         2,
 851 |                         "OP_EQUAL",
 852 |                     ]);
 853 |                     bobs_turn_scripts.push( bobs_turn_third_script );
 854 |                 }
 855 |                 bob[ "scripts" ].push( bobs_turn_scripts );
 856 | 
 857 |                 //allow Bob to prove fraud if Alice reveals two preimages for any of her turns
 858 |                 var i; for ( i=1; i<6; i++ ) {
 859 |                     var combinations = [];
 860 |                     var hashes = [ ...alice[ "hashes" ] ];
 861 |                     hashes = hashes.splice( ( 9 * i ) - 9, 9 );
 862 |                     for ( var comb of G.combination( hashes, 2 ) ) combinations.push( Array.from( comb ) );
 863 |                     combinations.forEach( combination => {
 864 |                         bobs_turn_scripts.push([
 865 |                             "OP_RIPEMD160",
 866 |                             "OP_SWAP",
 867 |                             "OP_RIPEMD160",
 868 |                             combination[ 0 ],
 869 |                             "OP_EQUALVERIFY",
 870 |                             combination[ 1 ],
 871 |                             "OP_EQUALVERIFY",
 872 |                             bob[ "pubkey" ],
 873 |                             "OP_CHECKSIG"
 874 |                         ]);
 875 |                     });
 876 |                 }
 877 | 
 878 |                 //allow Bob to prove fraud if Alice reveals two different preimage pairs for the
 879 |                 //same square (thus overwriting one of her own squares)
 880 |                 var i; for ( i=0; i<9; i++ ) {
 881 |                     var combinations = [];
 882 |                     var hashes = [];
 883 |                     //Alice's hashes for square 1 are 0, 0+9, 0+9+9, and 0+9+9+9
 884 |                     //For square 2 they are 1, 1+9, 1+9+9, and 1+9+9+9. Etc.
 885 |                     hashes.push( alice[ "hashes" ][ i ], alice[ "hashes" ][ i + 9 ], alice[ "hashes" ][ i + 18 ], alice[ "hashes" ][ i + 27 ], alice[ "hashes" ][ i + 36 ] );
 886 |                     for ( var comb of G.combination( hashes, 2 ) ) combinations.push( Array.from( comb ) );
 887 |                     combinations.forEach( combination => {
 888 |                         bobs_turn_scripts.push([
 889 |                             "OP_RIPEMD160",
 890 |                             "OP_SWAP",
 891 |                             "OP_RIPEMD160",
 892 |                             combination[ 0 ],
 893 |                             "OP_EQUALVERIFY",
 894 |                             combination[ 1 ],
 895 |                             "OP_EQUALVERIFY",
 896 |                             bob[ "pubkey" ],
 897 |                             "OP_CHECKSIG"
 898 |                         ]);
 899 |                     });
 900 |                 }
 901 | 
 902 |                 //allow Bob to prove fraud if Alice reveals an accept preimage and a reveal preimage
 903 |                 //for any square (thus proving Alice tried to overwrite one of Bob’s squares)
 904 |                 //Alice commits fraud if she reveals accept[ 0 ] and reveal[ 0 ], reveal[ 0 + 9 ], reveal[ 0 + 9 + 9 ], or reveal[ 0 + 9 + 9 + 9 ]. She also commits fraud if she reveals accept[ 35 ] and reveal[ 35 % 9 ], reveal[ ( 35 % 9 ) + 9 ], reveal[ ( 35 % 9 ) + 9 + 9 ], or reveal[ ( 35 % 9 ) + 9 + 9 + 9 ]
 905 |                 var accept_hashes = [ ...alice[ "accept_hashes" ] ];
 906 |                 var reveal_hashes = [ ...alice[ "hashes" ] ];
 907 |                 accept_hashes.forEach( ( item, index ) => {
 908 |                     bobs_turn_scripts.push([
 909 |                         "OP_RIPEMD160",
 910 |                         "OP_SWAP",
 911 |                         "OP_RIPEMD160",
 912 |                         item,
 913 |                         "OP_EQUALVERIFY",
 914 |                         reveal_hashes[ index % 9 ],
 915 |                         "OP_EQUALVERIFY",
 916 |                         bob[ "pubkey" ],
 917 |                         "OP_CHECKSIG"
 918 |                     ]);
 919 |                     bobs_turn_scripts.push([
 920 |                         "OP_RIPEMD160",
 921 |                         "OP_SWAP",
 922 |                         "OP_RIPEMD160",
 923 |                         item,
 924 |                         "OP_EQUALVERIFY",
 925 |                         reveal_hashes[ ( index % 9 ) + 9 ],
 926 |                         "OP_EQUALVERIFY",
 927 |                         bob[ "pubkey" ],
 928 |                         "OP_CHECKSIG"
 929 |                     ]);
 930 |                     bobs_turn_scripts.push([
 931 |                         "OP_RIPEMD160",
 932 |                         "OP_SWAP",
 933 |                         "OP_RIPEMD160",
 934 |                         item,
 935 |                         "OP_EQUALVERIFY",
 936 |                         reveal_hashes[ ( index % 9 ) + 9 + 9 ],
 937 |                         "OP_EQUALVERIFY",
 938 |                         bob[ "pubkey" ],
 939 |                         "OP_CHECKSIG"
 940 |                     ]);
 941 |                     bobs_turn_scripts.push([
 942 |                         "OP_RIPEMD160",
 943 |                         "OP_SWAP",
 944 |                         "OP_RIPEMD160",
 945 |                         item,
 946 |                         "OP_EQUALVERIFY",
 947 |                         reveal_hashes[ ( index % 9 ) + 9 + 9 + 9 ],
 948 |                         "OP_EQUALVERIFY",
 949 |                         bob[ "pubkey" ],
 950 |                         "OP_CHECKSIG"
 951 |                     ]);
 952 |                     bobs_turn_scripts.push([
 953 |                         "OP_RIPEMD160",
 954 |                         "OP_SWAP",
 955 |                         "OP_RIPEMD160",
 956 |                         item,
 957 |                         "OP_EQUALVERIFY",
 958 |                         reveal_hashes[ ( index % 9 ) + 9 + 9 + 9 + 9 ],
 959 |                         "OP_EQUALVERIFY",
 960 |                         bob[ "pubkey" ],
 961 |                         "OP_CHECKSIG"
 962 |                     ]);
 963 |                 });
 964 | 
 965 |                 var combinations = [];
 966 |                 var i; for ( i=0; i<9; i++ ) {
 967 |                     //row 1
 968 |                     if ( i == 0 ) var hashes = [0, 9, 18, 27, 1, 10, 19, 28];
 969 |                     if ( i == 1 ) var hashes = [0, 9, 18, 27, 2, 11, 20, 29];
 970 |                     if ( i == 2 ) var hashes = [1, 10, 19, 28, 2, 11, 20, 29];
 971 |                     //row 2
 972 |                     if ( i == 3 ) var hashes = [3, 12, 21, 30, 4, 13, 22, 31];
 973 |                     if ( i == 4 ) var hashes = [3, 12, 21, 30, 5, 14, 23, 32];
 974 |                     if ( i == 5 ) var hashes = [4, 13, 22, 31, 5, 14, 23, 32];
 975 |                     //row 3
 976 |                     if ( i == 6 ) var hashes = [6, 15, 24, 33, 7, 16, 25, 34];
 977 |                     if ( i == 7 ) var hashes = [6, 15, 24, 33, 8, 17, 26, 35];
 978 |                     if ( i == 8 ) var hashes = [7, 16, 25, 34, 8, 17, 26, 35];
 979 |                     for ( var comb of G.combination( hashes, 2 ) ) {var comb2 = JSON.parse( JSON.stringify( comb ) ); comb2.sort((a,b)=>a-b).reverse(); if ( ( comb2[ 0 ] - comb2[ 1 ] ) % 9 && comb2[ 0 ] - comb2[ 1 ] >= 3 ) combinations.push( Array.from( comb ) );}
 980 |                 }
 981 |                 combinations.forEach( ( item, index ) => {
 982 |                     combinations.splice( index * 4, 1, ...JSON.parse( JSON.stringify( [combinations[ index * 4 ]].flatMap(i => Array(4).fill(i))) ) );
 983 |                 });
 984 |                 combinations.forEach( ( item, index ) => {
 985 |                     if ( item.length > 2 ) return;
 986 |                     //row 1
 987 |                     //Alice had 180 here because there were originally 108 combinations and I multiplied them by 5 for each of her 5 turns. Then I divided the result, 540, by 3 to work on rows 1, 2, and 3. But Bob only has 4 turns so he only gets 108*4 = 432 combinations, meaning 180 for him should be 432/3 = 144
 988 |                     if ( index < 144 ) {
 989 |                         if ( item[ 0 ] % 3 == 0 && item[ 1 ] % 3 == 1 || item[ 1 ] % 3 == 0 && item[ 0 ] % 3 == 1 ) {
 990 |                             if ( index % 4 == 0 ) item.push( 2 );
 991 |                             if ( index % 4 == 1 ) item.push( 11 );
 992 |                             if ( index % 4 == 2 ) item.push( 20 );
 993 |                             if ( index % 4 == 3 ) item.push( 29 );
 994 |                         }
 995 |                         if ( item[ 0 ] % 3 == 0 && item[ 1 ] % 3 == 2 || item[ 1 ] % 3 == 0 && item[ 0 ] % 3 == 2 ) {
 996 |                             if ( index % 4 == 0 ) item.push( 1 );
 997 |                             if ( index % 4 == 1 ) item.push( 10 );
 998 |                             if ( index % 4 == 2 ) item.push( 19 );
 999 |                             if ( index % 4 == 3 ) item.push( 28 );
1000 |                         }
1001 |                         if ( item[ 0 ] % 3 == 1 && item[ 1 ] % 3 == 2 || item[ 1 ] % 3 == 1 && item[ 0 ] % 3 == 2 ) {
1002 |                             if ( index % 4 == 0 ) item.push( 0 );
1003 |                             if ( index % 4 == 1 ) item.push( 9 );
1004 |                             if ( index % 4 == 2 ) item.push( 18 );
1005 |                             if ( index % 4 == 3 ) item.push( 27 );
1006 |                         }
1007 |                     }
1008 |                     //row 2
1009 |                     if ( index >= 144 && index < 288 ) {
1010 |                         if ( item[ 0 ] % 3 == 0 && item[ 1 ] % 3 == 1 || item[ 1 ] % 3 == 0 && item[ 0 ] % 3 == 1 ) {
1011 |                             if ( index % 4 == 0 ) item.push( 5 );
1012 |                             if ( index % 4 == 1 ) item.push( 14 );
1013 |                             if ( index % 4 == 2 ) item.push( 23 );
1014 |                             if ( index % 4 == 3 ) item.push( 32 );
1015 |                         }
1016 |                         if ( item[ 0 ] % 3 == 0 && item[ 1 ] % 3 == 2 || item[ 1 ] % 3 == 0 && item[ 0 ] % 3 == 2 ) {
1017 |                             if ( index % 4 == 0 ) item.push( 4 );
1018 |                             if ( index % 4 == 1 ) item.push( 13 );
1019 |                             if ( index % 4 == 2 ) item.push( 22 );
1020 |                             if ( index % 4 == 3 ) item.push( 31 );
1021 |                         }
1022 |                         if ( item[ 0 ] % 3 == 1 && item[ 1 ] % 3 == 2 || item[ 1 ] % 3 == 1 && item[ 0 ] % 3 == 2 ) {
1023 |                             if ( index % 4 == 0 ) item.push( 3 );
1024 |                             if ( index % 4 == 1 ) item.push( 12 );
1025 |                             if ( index % 4 == 2 ) item.push( 21 );
1026 |                             if ( index % 4 == 3 ) item.push( 30 );
1027 |                         }
1028 |                     }
1029 |                     //row 3
1030 |                     if ( index >= 288 && index < 432 ) {
1031 |                         if ( item[ 0 ] % 3 == 0 && item[ 1 ] % 3 == 1 || item[ 1 ] % 3 == 0 && item[ 0 ] % 3 == 1 ) {
1032 |                             if ( index % 4 == 0 ) item.push( 8 );
1033 |                             if ( index % 4 == 1 ) item.push( 17 );
1034 |                             if ( index % 4 == 2 ) item.push( 26 );
1035 |                             if ( index % 4 == 3 ) item.push( 35 );
1036 |                         }
1037 |                         if ( item[ 0 ] % 3 == 0 && item[ 1 ] % 3 == 2 || item[ 1 ] % 3 == 0 && item[ 0 ] % 3 == 2 ) {
1038 |                             if ( index % 4 == 0 ) item.push( 7 );
1039 |                             if ( index % 4 == 1 ) item.push( 16 );
1040 |                             if ( index % 4 == 2 ) item.push( 25 );
1041 |                             if ( index % 4 == 3 ) item.push( 34 );
1042 |                         }
1043 |                         if ( item[ 0 ] % 3 == 1 && item[ 1 ] % 3 == 2 || item[ 1 ] % 3 == 1 && item[ 0 ] % 3 == 2 ) {
1044 |                             if ( index % 4 == 0 ) item.push( 6 );
1045 |                             if ( index % 4 == 1 ) item.push( 15 );
1046 |                             if ( index % 4 == 2 ) item.push( 24 );
1047 |                             if ( index % 4 == 3 ) item.push( 33 );
1048 |                         }
1049 |                     }
1050 |                 });
1051 |                 combinations.forEach( combination => {
1052 |                     bobs_turn_scripts.push([
1053 |                         "OP_RIPEMD160",
1054 |                         "OP_SWAP",
1055 |                         "OP_RIPEMD160",
1056 |                         2,
1057 |                         "OP_ROLL",
1058 |                         "OP_RIPEMD160",
1059 |                         "OP_SWAP",
1060 |                         2,
1061 |                         "OP_ROLL",
1062 |                         bob[ "hashes" ][ combination[ 2 ] ],
1063 |                         "OP_EQUALVERIFY",
1064 |                         alice[ "accept_hashes" ][ combination[ 1 ] ],
1065 |                         "OP_EQUALVERIFY",
1066 |                         alice[ "accept_hashes" ][ combination[ 0 ] ],
1067 |                         "OP_EQUALVERIFY",
1068 |                         //todo: ensure this is a multisig path that
1069 |                         //sends the money to an address where Bob
1070 |                         //has an opportunity to prove alice cheated
1071 |                         bob[ "pubkey" ],
1072 |                         "OP_CHECKSIG"
1073 |                     ]);
1074 |                 });
1075 | 
1076 |                 bob[ "trees" ].push( bobs_turn_scripts.map( s => tapscript.Tap.encodeScript( s ) ) );
1077 |                 var pubkey = "ab".repeat( 32 );
1078 |                 var [ tpubkey ] = tapscript.Tap.getPubKey( pubkey, { tree: bob[ "trees" ][ original_turn ] });
1079 |                 var bobs_turn_address = tapscript.Address.p2tr.fromPubKey( tpubkey, 'testnet' );
1080 |                 return bobs_turn_address;
1081 |             }
1082 |             var aliceChecksFraud = ( step, turn ) => {
1083 |                 //fraud case 1
1084 | 
1085 |                 //Suppose Bob reveals bob[ "preimages" ][ 0 ]. Alice should check if a move is already saved for bob_1. If not, she should save preimage 0 for bob_1. Otherwise she should combine it with the existing bob_1 preimage, find the appropriate tapleaf that lets her take Bob's money (knowing it will never be among tapleaves 0---2 but will be one of the 36 tapleaves among tapleaves 3---38), and do so.
1086 | 
1087 |                 var bobs_preimage_2;
1088 |                 // bobs_preimage_2 = prompt( `Enter bob's second preimage` );
1089 |                 if ( !bobs_preimage_2 ) bobs_preimage_2 = "ab";
1090 |                 var is_double_turn = proveDoubleTurn( alice[ "bobs_moves" ][ turn - 1 ], bobs_preimage_2, bob, alice );
1091 |                 if ( is_double_turn ) {
1092 |                     var txdata = tapscript.Tx.create({
1093 |                         vin: [{
1094 |                             txid: contract[ step ][ "txid" ],
1095 |                             vout: contract[ step ][ "vout" ],
1096 |                             prevout: {
1097 |                                 value: contract[ step ][ "amt" ],
1098 |                                 scriptPubKey: tapscript.Address.toScriptPubKey( contract[ step ][ "funding_address" ] )
1099 |                             },
1100 |                         }],
1101 |                         vout: [{
1102 |                             value: contract[ step ][ "amt" ] - 500,
1103 |                             scriptPubKey: tapscript.Address.toScriptPubKey( "tb1qd28npep0s8frcm3y7dxqajkcy2m40eysplyr9v" )
1104 |                         }]
1105 |                     });
1106 |                     var target = is_double_turn[ 0 ];
1107 |                     var script = is_double_turn[ 1 ];
1108 |                     var sig = tapscript.Signer.taproot.sign( alice[ "privkey" ], txdata, 0, { extension: target });
1109 |                     var pubkey = "ab".repeat( 32 );
1110 |                     var [ tpubkey, cblock ] = tapscript.Tap.getPubKey( pubkey, { tree: alice[ "trees" ][ turn ], target });
1111 |                     var bobs_preimage_1 = alice[ "bobs_moves" ][ turn - 1 ];
1112 |                     txdata.vin[ 0 ].witness = [ sig, bobs_preimage_1, bobs_preimage_2, script, cblock ];
1113 |                     var txhex = tapscript.Tx.encode( txdata ).hex;
1114 |                     console.log( "broadcast this to take bob's money:", txhex );
1115 |                     txdata.vin[ 0 ].witness = [ sig, bobs_preimage_2, bobs_preimage_1, script, cblock ];
1116 |                     var txhex = tapscript.Tx.encode( txdata ).hex;
1117 |                     console.log( "or this:", txhex );
1118 |                 }
1119 | 
1120 |                 //fraud case 2
1121 | 
1122 |                 //Alice should also check which square bob[ "preimages" ][ 0 ] belongs to and check if that square was already marked by Bob (i.e. if he already revealed preimage[ ( 0 % 9 )+9 ], preimage[ ( 0 % 9 )+9+9 ], or preimage[ ( 0 % 9 )+9+9 ]). If not, she should save preimage 0 for Bob's square_1. Otherwise she should combine it with the existing square_1 preimage, find the appropriate tapleaf that lets her take Bob's money (knowing it will never be among tapleaves 0---38 but will be one of the 36 tapleaves among tapleaves 39---74), and do so.
1123 | 
1124 |                 // var overwrite = prompt( `Enter Bob's attempted overwrite move` );
1125 |                 // var hash_of_bobs_preimage = rmd160( hexToBytes( overwrite ) );
1126 |                 // var index_of_bobs_preimage = bob[ "hashes" ].indexOf( hash_of_bobs_preimage );
1127 |                 // var square_bobs_preimage_belongs_to = index_of_bobs_preimage % 9;
1128 |                 // alice[ "bobs_squares" ][ square_bobs_preimage_belongs_to ] = overwrite;
1129 | 
1130 |                 var hash_of_bobs_preimage = rmd160( hexToBytes( alice[ "bobs_moves" ][ turn - 1 ] ) );
1131 |                 var index_of_bobs_preimage = bob[ "hashes" ].indexOf( hash_of_bobs_preimage );
1132 |                 var square_bobs_preimage_belongs_to = index_of_bobs_preimage % 9;
1133 | 
1134 |                 if ( !alice[ "bobs_squares" ][ square_bobs_preimage_belongs_to ] ) {
1135 |                     alice[ "bobs_squares" ][ square_bobs_preimage_belongs_to ] = alice[ "bobs_moves" ][ turn - 1 ];
1136 |                 } else {
1137 |                     var bobs_preimage_1 = alice[ "bobs_moves" ][ turn - 1 ];
1138 |                     var bobs_preimage_2 = alice[ "bobs_squares" ][ square_bobs_preimage_belongs_to ];
1139 |                     var overwrites_self = proveOverwriteSelf( bobs_preimage_1, bobs_preimage_2, bob, alice );
1140 |                     if ( overwrites_self ) {
1141 |                         var txdata = tapscript.Tx.create({
1142 |                             vin: [{
1143 |                                 txid: contract[ step ][ "txid" ],
1144 |                                 vout: contract[ step ][ "vout" ],
1145 |                                 prevout: {
1146 |                                     value: contract[ step ][ "amt" ],
1147 |                                     scriptPubKey: tapscript.Address.toScriptPubKey( contract[ step ][ "funding_address" ] )
1148 |                                 },
1149 |                             }],
1150 |                             vout: [{
1151 |                                 value: contract[ step ][ "amt" ] - 500,
1152 |                                 scriptPubKey: tapscript.Address.toScriptPubKey( "tb1qd28npep0s8frcm3y7dxqajkcy2m40eysplyr9v" )
1153 |                             }]
1154 |                         });
1155 |                         var target = overwrites_self[ 0 ];
1156 |                         var script = overwrites_self[ 1 ];
1157 |                         var sig = tapscript.Signer.taproot.sign( alice[ "privkey" ], txdata, 0, { extension: target });
1158 |                         var pubkey = "ab".repeat( 32 );
1159 |                         var [ tpubkey, cblock ] = tapscript.Tap.getPubKey( pubkey, { tree: alice[ "trees" ][ turn ], target });
1160 |                         var bobs_preimage_1 = alice[ "bobs_moves" ][ turn - 1 ];
1161 |                         txdata.vin[ 0 ].witness = [ sig, bobs_preimage_1, bobs_preimage_2, script, cblock ];
1162 |                         var txhex = tapscript.Tx.encode( txdata ).hex;
1163 |                         console.log( "broadcast this to take bob's money:", txhex );
1164 |                         txdata.vin[ 0 ].witness = [ sig, bobs_preimage_2, bobs_preimage_1, script, cblock ];
1165 |                         var txhex = tapscript.Tx.encode( txdata ).hex;
1166 |                         console.log( "or this:", txhex );
1167 |                     }
1168 |                 }
1169 | 
1170 |                 //fraud case 3
1171 | 
1172 |                 //Also, whenever Bob reveals an accept_preimage, Alice should take its number mod 9 and mark that accept_X as taken, where X is a number 1 through 9 corresponding to the number of the accept_preimage Bob revealed. That way, when Bob reveals bob[ "preimages" ][ 0 ] or any other reveal_preimage, Alice can take its number mod 9 and check if he already marked that spot in a previous move. If not, well and good. Otherwise, she should combine the two preimages, find the appropriate tapleaf that lets her take Bob's money (knowing it will never be among tapleaves 0---74 but will be one of the 36 tapleaves among tapleaves 75---110), and do so.
1173 | 
1174 |                 var hash_of_bobs_preimage = rmd160( hexToBytes( alice[ "bobs_moves" ][ turn - 1 ] ) );
1175 |                 var index_of_bobs_preimage = bob[ "hashes" ].indexOf( hash_of_bobs_preimage );
1176 |                 var square_bobs_preimage_belongs_to = index_of_bobs_preimage % 9;
1177 | 
1178 |                 if ( alice[ "bobs_acks" ][ square_bobs_preimage_belongs_to ] ) {
1179 |                     var bobs_preimage_1 = alice[ "bobs_moves" ][ turn - 1 ];
1180 |                     var bobs_preimage_2 = alice[ "bobs_acks" ][ square_bobs_preimage_belongs_to ];
1181 |                     var overwrites_opponent = proveOverwriteOpponent( bobs_preimage_1, bobs_preimage_2, bob, alice );
1182 |                     if ( overwrites_opponent ) {
1183 |                         var txdata = tapscript.Tx.create({
1184 |                             vin: [{
1185 |                                 txid: contract[ step ][ "txid" ],
1186 |                                 vout: contract[ step ][ "vout" ],
1187 |                                 prevout: {
1188 |                                     value: contract[ step ][ "amt" ],
1189 |                                     scriptPubKey: tapscript.Address.toScriptPubKey( contract[ step ][ "funding_address" ] )
1190 |                                 },
1191 |                             }],
1192 |                             vout: [{
1193 |                                 value: contract[ step ][ "amt" ] - 500,
1194 |                                 scriptPubKey: tapscript.Address.toScriptPubKey( "tb1qd28npep0s8frcm3y7dxqajkcy2m40eysplyr9v" )
1195 |                             }]
1196 |                         });
1197 |                         var target = overwrites_opponent[ 0 ];
1198 |                         var script = overwrites_opponent[ 1 ];
1199 |                         var sig = tapscript.Signer.taproot.sign( alice[ "privkey" ], txdata, 0, { extension: target });
1200 |                         var pubkey = "ab".repeat( 32 );
1201 |                         var [ tpubkey, cblock ] = tapscript.Tap.getPubKey( pubkey, { tree: alice[ "trees" ][ turn ], target });
1202 |                         var bobs_preimage_1 = alice[ "bobs_moves" ][ turn - 1 ];
1203 |                         txdata.vin[ 0 ].witness = [ sig, bobs_preimage_1, bobs_preimage_2, script, cblock ];
1204 |                         var txhex = tapscript.Tx.encode( txdata ).hex;
1205 |                         console.log( "broadcast this to take bob's money:", txhex );
1206 |                         txdata.vin[ 0 ].witness = [ sig, bobs_preimage_2, bobs_preimage_1, script, cblock ];
1207 |                         var txhex = tapscript.Tx.encode( txdata ).hex;
1208 |                         console.log( "or this:", txhex );
1209 |                     }
1210 |                 }
1211 |             }
1212 |             var bobChecksFraud = ( step, turn ) => {
1213 |                 //fraud case 1
1214 | 
1215 |                 // Suppose Alice reveals alice[ "preimages" ][ 0 ]. Bob should check if a move is already saved for alice_1. If not, he should save preimage 0 for alice_1. Otherwise he should combine it with the existing alice_1 preimage, find the appropriate tapleaf that lets him take Alice's money (knowing it will never be among tapleaves 0---2 but will be one of the 36 tapleaves among tapleaves 3---38), and do so.
1216 | 
1217 |                 var alices_preimage_2;
1218 |                 // alices_preimage_2 = prompt( `Enter alice's second preimage` );
1219 |                 if ( !alices_preimage_2 ) alices_preimage_2 = "ab";
1220 |                 var is_double_turn = proveDoubleTurn( bob[ "alices_moves" ][ turn ], alices_preimage_2, alice, bob );
1221 |                 if ( is_double_turn ) {
1222 |                     var txdata = tapscript.Tx.create({
1223 |                         vin: [{
1224 |                             txid: contract[ step ][ "txid" ],
1225 |                             vout: contract[ step ][ "vout" ],
1226 |                             prevout: {
1227 |                                 value: contract[ step ][ "amt" ],
1228 |                                 scriptPubKey: tapscript.Address.toScriptPubKey( contract[ step ][ "funding_address" ] )
1229 |                             },
1230 |                         }],
1231 |                         vout: [{
1232 |                             value: contract[ step ][ "amt" ] - 500,
1233 |                             scriptPubKey: tapscript.Address.toScriptPubKey( "tb1qd28npep0s8frcm3y7dxqajkcy2m40eysplyr9v" )
1234 |                         }]
1235 |                     });
1236 |                     var target = is_double_turn[ 0 ];
1237 |                     var script = is_double_turn[ 1 ];
1238 |                     var sig = tapscript.Signer.taproot.sign( bob[ "privkey" ], txdata, 0, { extension: target });
1239 |                     var pubkey = "ab".repeat( 32 );
1240 |                     var [ tpubkey, cblock ] = tapscript.Tap.getPubKey( pubkey, { tree: bob[ "trees" ][ turn ], target });
1241 |                     var alices_preimage_1 = bob[ "alices_moves" ][ turn ];
1242 |                     txdata.vin[ 0 ].witness = [ sig, alices_preimage_1, alices_preimage_2, script, cblock ];
1243 |                     var txhex = tapscript.Tx.encode( txdata ).hex;
1244 |                     console.log( "broadcast this to take alice's money:", txhex );
1245 |                     txdata.vin[ 0 ].witness = [ sig, alices_preimage_2, alices_preimage_1, script, cblock ];
1246 |                     var txhex = tapscript.Tx.encode( txdata ).hex;
1247 |                     console.log( "or this:", txhex );
1248 |                 }
1249 | 
1250 |                 //fraud case 2
1251 | 
1252 |                 //Bob should also check which square alice's preimage belongs to and check if that square was already marked by Alice (i.e. if she already revealed preimage[ ( whatever % 9 )+9 ], preimage[ ( whatever % 9 )+9+9 ], or preimage[ ( whatever % 9 )+9+9 ]). If not, he should save Alice's preimage for Alice's square_1. Otherwise he should combine it with the existing square_1 preimage, find the appropriate tapleaf that lets him take Alice's money (knowing it will never be among tapleaves 0---38 but will be one of the 36 tapleaves among tapleaves 39---74), and do so.
1253 | 
1254 |                 var hash_of_alices_preimage = rmd160( hexToBytes( bob[ "alices_moves" ][ turn ] ) );
1255 |                 var index_of_alices_preimage = alice[ "hashes" ].indexOf( hash_of_alices_preimage );
1256 |                 var square_alices_preimage_belongs_to = index_of_alices_preimage % 9;
1257 | 
1258 |                 if ( !bob[ "alices_squares" ][ square_alices_preimage_belongs_to ] ) {
1259 |                     bob[ "alices_squares" ][ square_alices_preimage_belongs_to ] = bob[ "alices_moves" ][ turn ];
1260 |                 } else {
1261 |                     var alices_preimage_1 = bob[ "alices_moves" ][ turn ];
1262 |                     var alices_preimage_2 = bob[ "alices_squares" ][ square_alices_preimage_belongs_to ];
1263 |                     var overwrites_self = proveOverwriteSelf( alices_preimage_1, alices_preimage_2, alice, bob );
1264 |                     if ( overwrites_self ) {
1265 |                         var txdata = tapscript.Tx.create({
1266 |                             vin: [{
1267 |                                 txid: contract[ step ][ "txid" ],
1268 |                                 vout: contract[ step ][ "vout" ],
1269 |                                 prevout: {
1270 |                                     value: contract[ step ][ "amt" ],
1271 |                                     scriptPubKey: tapscript.Address.toScriptPubKey( contract[ step ][ "funding_address" ] )
1272 |                                 },
1273 |                             }],
1274 |                             vout: [{
1275 |                                 value: contract[ step ][ "amt" ] - 500,
1276 |                                 scriptPubKey: tapscript.Address.toScriptPubKey( "tb1qd28npep0s8frcm3y7dxqajkcy2m40eysplyr9v" )
1277 |                             }]
1278 |                         });
1279 |                         var target = overwrites_self[ 0 ];
1280 |                         var script = overwrites_self[ 1 ];
1281 |                         var sig = tapscript.Signer.taproot.sign( bob[ "privkey" ], txdata, 0, { extension: target });
1282 |                         var pubkey = "ab".repeat( 32 );
1283 |                         var [ tpubkey, cblock ] = tapscript.Tap.getPubKey( pubkey, { tree: bob[ "trees" ][ turn ], target });
1284 |                         var alices_preimage_1 = bob[ "alices_moves" ][ turn ];
1285 |                         txdata.vin[ 0 ].witness = [ sig, alices_preimage_1, alices_preimage_2, script, cblock ];
1286 |                         var txhex = tapscript.Tx.encode( txdata ).hex;
1287 |                         console.log( "broadcast this to take alice's money:", txhex );
1288 |                         txdata.vin[ 0 ].witness = [ sig, alices_preimage_2, alices_preimage_1, script, cblock ];
1289 |                         var txhex = tapscript.Tx.encode( txdata ).hex;
1290 |                         console.log( "or this:", txhex );
1291 |                     }
1292 |                 }
1293 | 
1294 |                 //fraud case 3
1295 | 
1296 |                 //Also, whenever Alice reveals an accept_preimage, Bob should take its number mod 9 and mark that accept_X as taken, where X is a number 1 through 9 corresponding to the number of the accept_preimage Alice revealed. That way, when Alice reveals alice[ "preimages" ][ 0 ] or any other reveal_preimage, Bob can take its number mod 9 and check if she already marked that spot in a previous move. If not, well and good. Otherwise, he should combine the two preimages, find the appropriate tapleaf that lets him take Alice's money (knowing it will never be among tapleaves 0---74 but will be one of the 36 tapleaves among tapleaves 75---110), and do so.
1297 | 
1298 |                 var hash_of_alices_preimage = rmd160( hexToBytes( bob[ "alices_moves" ][ turn ] ) );
1299 |                 var index_of_alices_preimage = alice[ "hashes" ].indexOf( hash_of_alices_preimage );
1300 |                 var square_alices_preimage_belongs_to = index_of_alices_preimage % 9;
1301 | 
1302 |                 if ( bob[ "alices_acks" ][ square_alices_preimage_belongs_to ] ) {
1303 |                     var alices_preimage_1 = bob[ "alices_moves" ][ turn ];
1304 |                     var alices_preimage_2 = bob[ "alices_acks" ][ square_alices_preimage_belongs_to ];
1305 |                     var overwrites_opponent = proveOverwriteOpponent( alices_preimage_1, alices_preimage_2, alice, bob );
1306 |                     if ( overwrites_opponent ) {
1307 |                         var txdata = tapscript.Tx.create({
1308 |                             vin: [{
1309 |                                 txid: contract[ step ][ "txid" ],
1310 |                                 vout: contract[ step ][ "vout" ],
1311 |                                 prevout: {
1312 |                                     value: contract[ step ][ "amt" ],
1313 |                                     scriptPubKey: tapscript.Address.toScriptPubKey( contract[ step ][ "funding_address" ] )
1314 |                                 },
1315 |                             }],
1316 |                             vout: [{
1317 |                                 value: contract[ step ][ "amt" ] - 500,
1318 |                                 scriptPubKey: tapscript.Address.toScriptPubKey( "tb1qd28npep0s8frcm3y7dxqajkcy2m40eysplyr9v" )
1319 |                             }]
1320 |                         });
1321 |                         var target = overwrites_opponent[ 0 ];
1322 |                         var script = overwrites_opponent[ 1 ];
1323 |                         var sig = tapscript.Signer.taproot.sign( bob[ "privkey" ], txdata, 0, { extension: target });
1324 |                         var pubkey = "ab".repeat( 32 );
1325 |                         var [ tpubkey, cblock ] = tapscript.Tap.getPubKey( pubkey, { tree: bob[ "trees" ][ turn ], target });
1326 |                         var alices_preimage_1 = bob[ "alices_moves" ][ turn ];
1327 |                         txdata.vin[ 0 ].witness = [ sig, alices_preimage_1, alices_preimage_2, script, cblock ];
1328 |                         var txhex = tapscript.Tx.encode( txdata ).hex;
1329 |                         console.log( "broadcast this to take alice's money:", txhex );
1330 |                         txdata.vin[ 0 ].witness = [ sig, alices_preimage_2, alices_preimage_1, script, cblock ];
1331 |                         var txhex = tapscript.Tx.encode( txdata ).hex;
1332 |                         console.log( "or this:", txhex );
1333 |                     }
1334 |                 }
1335 |             }
1336 |             var takeAlicesTurn = async ( step, turn, bobs_turn_address, bobs_preimage, bobs_move ) => {
1337 |                 var txdata = tapscript.Tx.create({
1338 |                     vin: [{
1339 |                         txid: contract[ step ][ "txid" ],
1340 |                         vout: contract[ step ][ "vout" ],
1341 |                         prevout: {
1342 |                             value: contract[ step ][ "amt" ],
1343 |                             scriptPubKey: tapscript.Address.toScriptPubKey( contract[ step ][ "funding_address" ] )
1344 |                         },
1345 |                     }],
1346 |                     vout: [{
1347 |                         value: contract[ step ][ "amt" ] - 500,
1348 |                         scriptPubKey: tapscript.Address.toScriptPubKey( bobs_turn_address )
1349 |                     }]
1350 |                 });
1351 |                 alert( `Please place an X` );
1352 |                 game_on = true;
1353 |                 // var move = prompt( `Please enter a number 1-9` );
1354 |                 var move = await waitForMove();
1355 |                 num = undefined;
1356 |                 game_on = undefined;
1357 |                 move = Number( move ) - 1;
1358 |                 var move_preimage = alice[ "preimages" ][ Number( move ) + Number( turn * 9 ) ];
1359 |                 aliceChecksVictory( step, turn, move_preimage );
1360 |                 if ( victory_achieved ) return alert( `You won! Check your console to collect your winnings!` );
1361 |                 if ( turn != 0 ) var accept_preimage = alice[ "accept_preimages" ][ bobs_move + Number( ( turn - 1 ) * 9 ) ];
1362 |                 else accept_preimage = "";
1363 |                 if ( turn == 0 ) var bobs_preimage = "";
1364 |                 if ( turn == 0 ) var bobs_move = move;
1365 |                 var target = tapscript.Tap.encodeScript( alice[ "scripts" ][ turn ][ bobs_move + 2 ] );
1366 |                 var pubkey = "ab".repeat( 32 );
1367 |                 var [ tpubkey, cblock ] = tapscript.Tap.getPubKey( pubkey, { tree: alice[ "trees" ][ turn ], target });
1368 |                 var sig_1 = tapscript.Signer.taproot.sign( alice[ "privkey" ], txdata, 0, { extension: target });
1369 |                 var sig_2 = tapscript.Signer.taproot.sign( bob[ "privkey" ], txdata, 0, { extension: target });
1370 |                 //for Alice to make her move and pass the turn to Bob, we need both signatures (to ensure 
1371 |                 //the money goes to the right place) plus her move (the preimage) plus the tapleaf guard's
1372 |                 //preimage -- which, in this case, is an empty string
1373 |                 txdata.vin[ 0 ].witness = [ sig_2, sig_1, move_preimage, accept_preimage, bobs_preimage, alice[ "scripts" ][ turn ][ bobs_move + 2 ], cblock ];
1374 |                 var ftxhex = tapscript.Tx.encode( txdata ).hex;
1375 |                 var vtxid = tapscript.Tx.util.getTxid( txdata );
1376 |                 console.log( "Next step, broadcast this txhex to make it Bob's turn:", ftxhex );
1377 |                 console.log( `Then, reveal this move_preimage to bob: ${move_preimage}` );
1378 |                 if ( turn != 0 ) console.log( "And this accept_preimage:", accept_preimage );
1379 |                 contract.push({ txid: vtxid, vout: 0, amt: contract[ step ][ "amt" ] - 500, funding_address: bobs_turn_address, funding_tx: ftxhex });                    
1380 |             }
1381 |             var takeBobsTurn = async ( step, turn, alices_turn_address, alices_preimage, alices_move ) => {
1382 |                 var txdata = tapscript.Tx.create({
1383 |                     vin: [{
1384 |                         txid: contract[ step ][ "txid" ],
1385 |                         vout: contract[ step ][ "vout" ],
1386 |                         prevout: {
1387 |                             value: contract[ step ][ "amt" ],
1388 |                             scriptPubKey: tapscript.Address.toScriptPubKey( contract[ step ][ "funding_address" ] )
1389 |                         },
1390 |                     }],
1391 |                     vout: [{
1392 |                         value: contract[ step ][ "amt" ] - 500,
1393 |                         scriptPubKey: tapscript.Address.toScriptPubKey( alices_turn_address )
1394 |                     }]
1395 |                 });
1396 |                 alert( `Please place an O` );
1397 |                 game_on = true;
1398 |                 // var move = prompt( `Please enter a number 1-9` );
1399 |                 var move = await waitForMove();
1400 |                 num = undefined;
1401 |                 game_on = undefined;
1402 |                 move = Number( move ) - 1;
1403 |                 var move_preimage = bob[ "preimages" ][ Number( move ) + Number( turn * 9 ) ];
1404 |                 bobChecksVictory( step, turn, move_preimage );
1405 |                 if ( victory_achieved ) return alert( `You won! Check your console to collect your winnings!` );
1406 |                 var accept_preimage = bob[ "accept_preimages" ][ alices_move + Number( turn * 9 ) ];
1407 |                 var target = tapscript.Tap.encodeScript( bob[ "scripts" ][ turn ][ alices_move + 2 ] );
1408 |                 var pubkey = "ab".repeat( 32 );
1409 |                 var [ tpubkey, cblock ] = tapscript.Tap.getPubKey( pubkey, { tree: bob[ "trees" ][ turn ], target });
1410 |                 var sig_1 = tapscript.Signer.taproot.sign( alice[ "privkey" ], txdata, 0, { extension: target });
1411 |                 var sig_2 = tapscript.Signer.taproot.sign( bob[ "privkey" ], txdata, 0, { extension: target });
1412 |                 txdata.vin[ 0 ].witness = [ sig_2, sig_1, move_preimage, accept_preimage, alices_preimage, bob[ "scripts" ][ turn ][ alices_move + 2 ], cblock ];
1413 |                 var ftxhex = tapscript.Tx.encode( txdata ).hex;
1414 |                 var vtxid = tapscript.Tx.util.getTxid( txdata );
1415 |                 console.log( "Next step, broadcast this txhex to make it Alice's second turn:", ftxhex );
1416 |                 console.log( "Then, reveal this move_preimage to alice:", move_preimage );
1417 |                 console.log( "And this accept_preimage:", accept_preimage );
1418 |                 contract.push({ txid: vtxid, vout: 0, amt: contract[ step ][ "amt" ] - 500, funding_address: alices_turn_address, funding_tx: ftxhex });
1419 |             }
1420 |             var waitForBobsAcceptance = async ( num1, num2, prev_accept_was_invalid ) => {
1421 |                 //get bob's acceptance
1422 |                 if ( prev_accept_was_invalid ) var msg = `The previous acceptance preimage was invalid. Enter bob's accept_preimage`;
1423 |                 else var msg = `Enter bob's accept_preimage`;
1424 |                 bobs_accept_preimage = prompt( msg );
1425 |                 //check if the accept preimage is valid
1426 |                 bobs_accept_hash = rmd160( hexToBytes( bobs_accept_preimage ) );
1427 |                 hashes = [ ...bob[ "accept_hashes" ] ];
1428 |                 hashes = hashes.splice( num1, num2 );
1429 |                 var index = hashes.indexOf( bobs_accept_hash );
1430 |                 if ( index < 0 ) return waitForBobsAcceptance( num1, num2, true );
1431 |                 return alice[ "bobs_acks" ][ index ] = bobs_accept_preimage;
1432 |             }
1433 |             var waitForBobsMove = async ( num1, num2, prev_move_was_invalid ) => {
1434 |                 //get bob's move
1435 |                 if ( prev_move_was_invalid ) var msg = `The previous move was invalid. Enter bob's move_preimage`;
1436 |                 else var msg = `Enter bob's move_preimage`;
1437 |                 bobs_preimage = prompt( msg );
1438 |                 //check if the move is valid
1439 |                 bobs_hash = rmd160( hexToBytes( bobs_preimage ) );
1440 |                 hashes = [ ...bob[ "hashes" ] ];
1441 |                 hashes = hashes.splice( num1, num2 );
1442 |                 if ( hashes.includes( bobs_hash ) ) return alice[ "bobs_moves" ].push( bobs_preimage );
1443 |                 waitForBobsMove( num1, num2, true );
1444 |             }
1445 |             var waitForAlicesAcceptance = async ( num1, num2, prev_accept_was_invalid ) => {
1446 |                 //get alice's acceptance
1447 |                 if ( prev_accept_was_invalid ) var msg = `The previous acceptance preimage was invalid. Enter alice's accept_preimage`;
1448 |                 else var msg = `Enter alice's accept_preimage`;
1449 |                 alices_accept_preimage = prompt( msg );
1450 |                 //check if the accept preimage is valid
1451 |                 alices_accept_hash = rmd160( hexToBytes( alices_accept_preimage ) );
1452 |                 hashes = [ ...alice[ "accept_hashes" ] ];
1453 |                 hashes = hashes.splice( num1, num2 );
1454 |                 var index = hashes.indexOf( alices_accept_hash );
1455 |                 if ( index < 0 ) return waitForAlicesAcceptance( num1, num2, true );
1456 |                 return bob[ "alices_acks" ][ index ] = alices_accept_preimage;
1457 |             }
1458 |             var waitForAlice = async ( num1, num2, prev_move_was_invalid ) => {
1459 |                 //get alice's move
1460 |                 if ( prev_move_was_invalid ) var msg = `The previous move was invalid. Enter alice's move_preimage`;
1461 |                 else var msg = `Enter alice's move_preimage`;
1462 |                 alices_preimage = prompt( msg );
1463 |                 //check if the move is valid
1464 |                 alices_hash = rmd160( hexToBytes( alices_preimage ) );
1465 |                 hashes = [ ...alice[ "hashes" ] ];
1466 |                 hashes = hashes.splice( num1, num2 );
1467 |                 if ( hashes.includes( alices_hash ) ) return bob[ "alices_moves" ].push( alices_preimage );
1468 |                 waitForAlice( num1, num2, true );
1469 |             }
1470 |             var showAlicesMove = () => {
1471 |                 alices_move = hashes.indexOf( alices_hash );
1472 |                 sessionStorage[ `cell_${alices_move}` ] = "_X_|";
1473 |                 if ( alices_move % 3 == 2 ) sessionStorage[ `cell_${alices_move}` ] = "_X_";
1474 |                 var cell_0 = sessionStorage[ "cell_0" ];
1475 |                 var cell_1 = sessionStorage[ "cell_1" ];
1476 |                 var cell_2 = sessionStorage[ "cell_2" ];
1477 |                 var cell_3 = sessionStorage[ "cell_3" ];
1478 |                 var cell_4 = sessionStorage[ "cell_4" ];
1479 |                 var cell_5 = sessionStorage[ "cell_5" ];
1480 |                 var cell_6 = sessionStorage[ "cell_6" ];
1481 |                 var cell_7 = sessionStorage[ "cell_7" ];
1482 |                 var cell_8 = sessionStorage[ "cell_8" ];
1483 |                 console.log( cell_0 + cell_1 + cell_2 );
1484 |                 console.log( cell_3 + cell_4 + cell_5 );
1485 |                 console.log( cell_6 + cell_7 + cell_8 );
1486 |             }
1487 |             var showBobsMove = () => {
1488 |                 bobs_move = hashes.indexOf( bobs_hash );
1489 |                 sessionStorage[ `cell_${bobs_move}` ] = "_O_|";
1490 |                 if ( bobs_move % 3 == 2 ) sessionStorage[ `cell_${bobs_move}` ] = "_O_";
1491 |                 var cell_0 = sessionStorage[ "cell_0" ];
1492 |                 var cell_1 = sessionStorage[ "cell_1" ];
1493 |                 var cell_2 = sessionStorage[ "cell_2" ];
1494 |                 var cell_3 = sessionStorage[ "cell_3" ];
1495 |                 var cell_4 = sessionStorage[ "cell_4" ];
1496 |                 var cell_5 = sessionStorage[ "cell_5" ];
1497 |                 var cell_6 = sessionStorage[ "cell_6" ];
1498 |                 var cell_7 = sessionStorage[ "cell_7" ];
1499 |                 var cell_8 = sessionStorage[ "cell_8" ];
1500 |                 console.log( cell_0 + cell_1 + cell_2 );
1501 |                 console.log( cell_3 + cell_4 + cell_5 );
1502 |                 console.log( cell_6 + cell_7 + cell_8 );
1503 |             }
1504 |             var aliceChecksVictory = ( step, turn, alices_move_preimage ) => {
1505 |                 var victory;
1506 |                 //check rows
1507 |                 var i; for ( i=0; i<3; i++ ) {
1508 |                     if ( i==0 ) var row_nums = [0,1,2];
1509 |                     if ( i==1 ) var row_nums = [3,4,5];
1510 |                     if ( i==2 ) var row_nums = [6,7,8];
1511 |                     for ( var comb of G.combination( row_nums, 2 ) ) {
1512 |                         if ( victory ) continue;
1513 |                         var squares = Array.from( comb );
1514 |                         var bobs_ack_1 = alice[ "bobs_acks" ][ squares[ 0 ] ];
1515 |                         var bobs_ack_2 = alice[ "bobs_acks" ][ squares[ 1 ] ];
1516 |                         if ( !bobs_ack_1 || !bobs_ack_2 ) continue;
1517 |                         victory = proveVictory( bobs_ack_1, bobs_ack_2, alices_move_preimage, bob, alice );
1518 |                     }
1519 |                 }
1520 |                 if ( victory ) {
1521 |                     var txdata = tapscript.Tx.create({
1522 |                         vin: [{
1523 |                             txid: contract[ step ][ "txid" ],
1524 |                             vout: contract[ step ][ "vout" ],
1525 |                             prevout: {
1526 |                                 value: contract[ step ][ "amt" ],
1527 |                                 scriptPubKey: tapscript.Address.toScriptPubKey( contract[ step ][ "funding_address" ] )
1528 |                             },
1529 |                         }],
1530 |                         vout: [{
1531 |                             value: contract[ step ][ "amt" ] - 500,
1532 |                             scriptPubKey: tapscript.Address.toScriptPubKey( "tb1qd28npep0s8frcm3y7dxqajkcy2m40eysplyr9v" )
1533 |                         }]
1534 |                     });
1535 |                     var target = victory[ 0 ];
1536 |                     var script = victory[ 1 ];
1537 |                     var sig = tapscript.Signer.taproot.sign( alice[ "privkey" ], txdata, 0, { extension: target });
1538 |                     var pubkey = "ab".repeat( 32 );
1539 |                     var [ tpubkey, cblock ] = tapscript.Tap.getPubKey( pubkey, { tree: alice[ "trees" ][ turn ], target });
1540 |                     txdata.vin[ 0 ].witness = [ sig, bobs_ack_1, bobs_ack_2, alices_move_preimage, script, cblock ];
1541 |                     var txhex = tapscript.Tx.encode( txdata ).hex;
1542 |                     console.log( "broadcast this to take your winnings:", txhex );
1543 |                     txdata.vin[ 0 ].witness = [ sig, bobs_ack_2, bobs_ack_1, alices_move_preimage, script, cblock ];
1544 |                     var txhex = tapscript.Tx.encode( txdata ).hex;
1545 |                     console.log( "or this:", txhex );
1546 |                 }
1547 |             }
1548 |             var bobChecksVictory = ( step, turn, bobs_move_preimage ) => {
1549 |                 var victory;
1550 |                 //check rows
1551 |                 var i; for ( i=0; i<3; i++ ) {
1552 |                     if ( i==0 ) var row_nums = [0,1,2];
1553 |                     if ( i==1 ) var row_nums = [3,4,5];
1554 |                     if ( i==2 ) var row_nums = [6,7,8];
1555 |                     for ( var comb of G.combination( row_nums, 2 ) ) {
1556 |                         if ( victory ) continue;
1557 |                         var squares = Array.from( comb );
1558 |                         var alices_ack_1 = bob[ "alices_acks" ][ squares[ 0 ] ];
1559 |                         var alices_ack_2 = bob[ "alices_acks" ][ squares[ 1 ] ];
1560 |                         if ( !alices_ack_1 || !alices_ack_2 ) continue;
1561 |                         victory = proveVictory( alices_ack_1, alices_ack_2, bobs_move_preimage, alice, bob );
1562 |                     }
1563 |                 }
1564 |                 if ( victory ) {
1565 |                     var txdata = tapscript.Tx.create({
1566 |                         vin: [{
1567 |                             txid: contract[ step ][ "txid" ],
1568 |                             vout: contract[ step ][ "vout" ],
1569 |                             prevout: {
1570 |                                 value: contract[ step ][ "amt" ],
1571 |                                 scriptPubKey: tapscript.Address.toScriptPubKey( contract[ step ][ "funding_address" ] )
1572 |                             },
1573 |                         }],
1574 |                         vout: [{
1575 |                             value: contract[ step ][ "amt" ] - 500,
1576 |                             scriptPubKey: tapscript.Address.toScriptPubKey( "tb1qd28npep0s8frcm3y7dxqajkcy2m40eysplyr9v" )
1577 |                         }]
1578 |                     });
1579 |                     var target = victory[ 0 ];
1580 |                     var script = victory[ 1 ];
1581 |                     var sig = tapscript.Signer.taproot.sign( bob[ "privkey" ], txdata, 0, { extension: target });
1582 |                     var pubkey = "ab".repeat( 32 );
1583 |                     var [ tpubkey, cblock ] = tapscript.Tap.getPubKey( pubkey, { tree: bob[ "trees" ][ turn ], target });
1584 |                     txdata.vin[ 0 ].witness = [ sig, alices_ack_1, alices_ack_2, bobs_move_preimage, script, cblock ];
1585 |                     var txhex = tapscript.Tx.encode( txdata ).hex;
1586 |                     console.log( "broadcast this to take your winnings:", txhex );
1587 |                     txdata.vin[ 0 ].witness = [ sig, alices_ack_2, alices_ack_1, bobs_move_preimage, script, cblock ];
1588 |                     var txhex = tapscript.Tx.encode( txdata ).hex;
1589 |                     console.log( "or this:", txhex );
1590 |                 }
1591 |             }
1592 |             var init = async () => {
1593 |                 //alice's first turn
1594 |                 var alices_first_turn_address = alicesTurn( 0 );
1595 |                 //bob's first turn
1596 |                 var bobs_first_turn_address = bobsTurn( 0 );
1597 |                 // alice's second turn
1598 |                 var alices_second_turn_address = alicesTurn( 1 );
1599 |                 //bob's second turn
1600 |                 var bobs_second_turn_address = bobsTurn( 1 );
1601 |                 // alice's third turn
1602 |                 var alices_third_turn_address = alicesTurn( 2 );
1603 |                 //bob's third turn
1604 |                 var bobs_third_turn_address = bobsTurn( 2 );
1605 |                 // alice's fourth turn
1606 |                 var alices_fourth_turn_address = alicesTurn( 3 );
1607 |                 //bob's fourth turn
1608 |                 var bobs_fourth_turn_address = bobsTurn( 3 );
1609 |                 // alice's fifth turn
1610 |                 var alices_fifth_turn_address = alicesTurn( 4 );
1611 | 
1612 |                 //alice funds the contract
1613 | 
1614 |                 console.log( "Step 1, send money to this funding address:", funding_address );
1615 |                 // var funding_txid = "ab".repeat( 32 );
1616 |                 // var funding_vout = 0;
1617 |                 // var funding_amt = 100_000;
1618 |                 var funding_txid = prompt( `please send money to this address: ${funding_address} and enter the txid` );
1619 |                 var funding_vout = prompt( `and the vout` );
1620 |                 funding_vout = Number( funding_vout );
1621 |                 var funding_amt = prompt( `and the amount` );
1622 |                 funding_amt = Number( funding_amt );
1623 |                 var txdata = tapscript.Tx.create({
1624 |                     vin: [{
1625 |                         txid: funding_txid,
1626 |                         vout: funding_vout,
1627 |                         prevout: {
1628 |                             value: funding_amt,
1629 |                             scriptPubKey: tapscript.Address.toScriptPubKey( funding_address )
1630 |                         },
1631 |                     }],
1632 |                     vout: [{
1633 |                         value: funding_amt - 500,
1634 |                         scriptPubKey: tapscript.Address.toScriptPubKey( alices_first_turn_address )
1635 |                     }]
1636 |                 });
1637 |                 var sig = tapscript.Signer.taproot.sign( alice[ "privkey" ], txdata, 0 );
1638 |                 txdata.vin[ 0 ].witness = [ sig ];
1639 |                 var ftxhex = tapscript.Tx.encode( txdata ).hex;
1640 |                 var vtxid = tapscript.Tx.util.getTxid( txdata );
1641 |                 console.log( "Step 2, broadcast this txhex to start Alice's turn:", ftxhex );
1642 |                 var utxo = [ funding_txid, funding_vout, funding_amt ];
1643 |                 contract.push({ txid: vtxid, vout: 0, amt: funding_amt - 500, funding_address: alices_first_turn_address, funding_tx: ftxhex });
1644 | 
1645 |                 //alice takes her first turn
1646 | 
1647 |                 await takeAlicesTurn( 0, 0, bobs_first_turn_address );
1648 |                 if ( victory_achieved ) return;
1649 | 
1650 |                 //bob waits for alice's info
1651 | 
1652 |                 waitForAlice( 0, 9 );
1653 |                 showAlicesMove();
1654 | 
1655 |                 //bob checks for fraud
1656 | 
1657 |                 bobChecksFraud( 1, 0 );
1658 |                 if ( fraud_occurred ) return alert( `Oh no, your opponent committed fraud! Check your console to penalize them and take their money` );
1659 | 
1660 |                 //bob takes his first turn
1661 | 
1662 |                 await takeBobsTurn( 1, 0, alices_second_turn_address, alices_preimage, alices_move );
1663 |                 if ( victory_achieved ) return;
1664 | 
1665 |                 //alice waits for bob's info
1666 | 
1667 |                 waitForBobsAcceptance( 0, 9 );
1668 |                 waitForBobsMove( 0, 9 );
1669 |                 showBobsMove();
1670 | 
1671 |                 //alice checks for fraud
1672 | 
1673 |                 aliceChecksFraud( 2, 1 );
1674 |                 if ( fraud_occurred ) return alert( `Oh no, your opponent committed fraud! Check your console to penalize them and take their money` );
1675 | 
1676 |                 //alice takes her second turn
1677 | 
1678 |                 await takeAlicesTurn( 2, 1, bobs_second_turn_address, bobs_preimage, bobs_move );
1679 |                 if ( victory_achieved ) return;
1680 | 
1681 |                 //bob waits for alice's info
1682 | 
1683 |                 waitForAlicesAcceptance( 0, 9 );
1684 |                 waitForAlice( 9, 18 );
1685 |                 showAlicesMove();
1686 | 
1687 |                 //bob checks for fraud
1688 | 
1689 |                 bobChecksFraud( 3, 1 );
1690 |                 if ( fraud_occurred ) return alert( `Oh no, your opponent committed fraud! Check your console to penalize them and take their money` );
1691 | 
1692 |                 //bob takes his second turn
1693 | 
1694 |                 await takeBobsTurn( 3, 1, alices_third_turn_address, alices_preimage, alices_move );
1695 |                 if ( victory_achieved ) return;
1696 | 
1697 |                 //alice waits for bob's info
1698 | 
1699 |                 waitForBobsAcceptance( 9, 18 );
1700 |                 waitForBobsMove( 9, 18 );
1701 |                 showBobsMove();
1702 | 
1703 |                 //alice checks for fraud
1704 | 
1705 |                 aliceChecksFraud( 4, 2 );
1706 |                 if ( fraud_occurred ) return alert( `Oh no, your opponent committed fraud! Check your console to penalize them and take their money` );
1707 | 
1708 |                 //alice takes her third turn
1709 | 
1710 |                 await takeAlicesTurn( 4, 2, bobs_third_turn_address, bobs_preimage, bobs_move );
1711 |                 if ( victory_achieved ) return;
1712 | 
1713 |                 //bob waits for alice's info
1714 | 
1715 |                 waitForAlicesAcceptance( 9, 18 );
1716 |                 waitForAlice( 18, 27 );
1717 |                 showAlicesMove();
1718 | 
1719 |                 //bob checks for fraud
1720 | 
1721 |                 bobChecksFraud( 5, 2 );
1722 |                 if ( fraud_occurred ) return alert( `Oh no, your opponent committed fraud! Check your console to penalize them and take their money` );
1723 | 
1724 |                 //bob takes his third turn
1725 | 
1726 |                 await takeBobsTurn( 5, 2, alices_fourth_turn_address, alices_preimage, alices_move );
1727 |                 if ( victory_achieved ) return;
1728 | 
1729 |                 //alice waits for bob's info
1730 | 
1731 |                 waitForBobsAcceptance( 18, 27 );
1732 |                 waitForBobsMove( 18, 27 );
1733 |                 showBobsMove();
1734 | 
1735 |                 //alice checks for fraud
1736 | 
1737 |                 aliceChecksFraud( 6, 3 );
1738 |                 if ( fraud_occurred ) return alert( `Oh no, your opponent committed fraud! Check your console to penalize them and take their money` );
1739 | 
1740 |                 //alice takes her fourth turn
1741 | 
1742 |                 await takeAlicesTurn( 6, 3, bobs_fourth_turn_address, bobs_preimage, bobs_move );
1743 |                 if ( victory_achieved ) return;
1744 | 
1745 |                 //bob waits for alice's info
1746 | 
1747 |                 waitForAlicesAcceptance( 18, 27 );
1748 |                 waitForAlice( 27, 36 );
1749 |                 showAlicesMove();
1750 | 
1751 |                 //bob checks for fraud
1752 | 
1753 |                 bobChecksFraud( 7, 3 );
1754 |                 if ( fraud_occurred ) return alert( `Oh no, your opponent committed fraud! Check your console to penalize them and take their money` );
1755 | 
1756 |                 //bob takes his last turn
1757 | 
1758 |                 await takeBobsTurn( 7, 3, alices_fifth_turn_address, alices_preimage, alices_move );
1759 |                 if ( victory_achieved ) return;
1760 | 
1761 |                 //alice waits for bob's info
1762 | 
1763 |                 waitForBobsAcceptance( 27, 36 );
1764 |                 waitForBobsMove( 27, 36 );
1765 |                 showBobsMove();
1766 | 
1767 |                 //alice checks for fraud
1768 | 
1769 |                 aliceChecksFraud( 8, 4 );
1770 |                 if ( fraud_occurred ) return alert( `Oh no, your opponent committed fraud! Check your console to penalize them and take their money` );
1771 | 
1772 |                 //alice takes her last turn
1773 | 
1774 |                 await takeAlicesTurn( 8, 4, "tb1qd28npep0s8frcm3y7dxqajkcy2m40eysplyr9v", bobs_preimage, bobs_move );
1775 |                 if ( victory_achieved ) return;
1776 | 
1777 |                 Object.keys( sessionStorage ).forEach( item => { if ( sessionStorage[ item ].includes( "___|" ) ) sessionStorage[ item ] = "_X_|";if ( sessionStorage[ item ].includes( "___" ) ) sessionStorage[ item ] = "_X_"; });
1778 |                 var cell_0 = sessionStorage[ "cell_0" ];
1779 |                 var cell_1 = sessionStorage[ "cell_1" ];
1780 |                 var cell_2 = sessionStorage[ "cell_2" ];
1781 |                 var cell_3 = sessionStorage[ "cell_3" ];
1782 |                 var cell_4 = sessionStorage[ "cell_4" ];
1783 |                 var cell_5 = sessionStorage[ "cell_5" ];
1784 |                 var cell_6 = sessionStorage[ "cell_6" ];
1785 |                 var cell_7 = sessionStorage[ "cell_7" ];
1786 |                 var cell_8 = sessionStorage[ "cell_8" ];
1787 |                 console.log( cell_0 + cell_1 + cell_2 );
1788 |                 console.log( cell_3 + cell_4 + cell_5 );
1789 |                 console.log( cell_6 + cell_7 + cell_8 );
1790 |             }
1791 |             // window.onload = setTimeout( init, 100 );
1792 |         </script>
1793 |     </body>
1794 | </html>
1795 | 


--------------------------------------------------------------------------------