JeremyRubin/powswap.py

## powswap.py
#!/usr/bin/python3
# Originally shared ~ 7/1/19 with Dan Elitzer
# Copyright 2019 Jeremy Rubin

# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
#

import bitcointx
import hashlib
import os

from bitcointx.wallet import CBitcoinSecret
from bitcointx.core.script import CScript, OP_CHECKMULTISIG, CScriptOp, OP_2, OP_CHECKSIGVERIFY, OP_1, OP_CHECKMULTISIGVERIFY, OP_CHECKSIG
import time
CHAIN_SIZE = 100
# SecretChain is a hash chain H(H(H(...H(x))))
# Each H(...) also has an associated pk = H(...)xG
class SecretChain:
    def __init__(self, seed = None):
        self.seed = os.urandom(32) if seed is None else seed
        self.secrets = [0]*int(CHAIN_SIZE)
        self.secrets[0] = hashlib.sha256(self.seed).digest()
        for i in range(1,int(CHAIN_SIZE)):
            self.secrets[i] = hashlib.sha256(self.secrets[i-1]).digest()
        self.pks = list(map(lambda x: CBitcoinSecret.from_secret_bytes(x).pub, self.secrets))
    def pop(self):
        return self.secrets.pop() if len(self.secrets) else None
# SecretTraversal lets us receive new preimages from Secret Chain
# It is initialized with all the Pks from the entire chain
# Step by step, we check that the latest secret reveals
# the next PK, and that the hash of the latest secret is the prior secret.
class SecretTraversal:
    def __init__(self, pks):
        self.last = None
        self.pks = pks
        self.next = pks.pop()
        self.count = 0
    def update(self, secret):
        if secret is None:
            return False
        pk = CBitcoinSecret.from_secret_bytes(secret).pub
        secret_hash = hashlib.sha256(secret).digest()

        if self.last is None:
            if self.next != pk:
                print('nope1')
                return False
        else:
            if self.last != secret_hash:
                print('no')
                return False
            if self.next != pk:
                print('nope')
                return False
        print("Learned Secret SHA256(%s) == %s:"%(secret, secret_hash))
        print("%s x G == %s"%(secret, self.next))
        self.last = secret
        self.next = self.pks.pop() if self.pks else None
        print("Next Secret: ", self.next, "\n")

        self.count += 1
        return True
    def get_next(self):
        return self.pks[-1]
    def seek(self, pk):
        sec = self.last
        for _ in range(self.count):
            if CBitcoinSecret.from_secret_bytes(sec).pub == pk:
                return sec
            sec = hashlib.sha256(sec).digest()
        return None


class Player:
    def __init__(self):
        self.sec = CBitcoinSecret.from_secret_bytes(os.urandom(32))
        self.my_revoke_chain = SecretChain()
        self.counterparty_revokes = None
    def scriptKey(self):
        return CScript(CScriptOp.encode_op_pushdata(self.sec.pub))
    def get_my_public_revokes(self):
        return self.my_revoke_chain.pks.copy()
    def set_counterparty_revokes(self, pks):
        self.counterparty_revokes = SecretTraversal(pks)
    def set_channel_state(self, cs):
        self.cs = cs

    def get_my_address(self):
        return self.scriptKey()
    def get_my_key(self):
        return self.sec.pub
    def get_counterparty_address(self):
        return b"DUMMY ADDRESS"
    def get_counterparty_revoke(self):
        return self.counterparty_revokes.get_next()
    def get_counterparty_key(self):
        return b"DUMMY KEY"
    def revoke(self):
        return self.my_revoke_chain.pop()
    def receive_revoke(self, secret):
        return self.counterparty_revokes.update(secret)
    def set_latest_resolution(self, latest_resolution):
        self.latest_resolution = latest_resolution

import copy
class OpenChannel:
    def __init__(self, player_one, player_two, amt):
        self.player_one = player_one
        self.player_two = player_two
        self.input = self.agree_on_input()
        self.channel_is_open = False
        # mirror channel states
        cs1 = ChannelState(self.input, amt, amt)
        cs2 = ChannelState(self.input, amt, amt)
        # load each players revoke chains
        player_one.set_counterparty_revokes(player_two.get_my_public_revokes())
        player_two.set_counterparty_revokes(player_one.get_my_public_revokes())
        # load channel states
        player_one.set_channel_state(cs1)
        player_two.set_channel_state(cs2)
    def agree_on_input(self):
        # We don't have an actual input...
        return COutPoint(b"0"*32, 0)
    def sign_and_broadcast_open_channel(self):
        self.channel_is_open = True

    def run_channel(self):
        # First two states are a null update
        next_state = [(0,0), (0, 0), (-1*COIN, -2*COIN), (1*COIN, 2*COIN)]
        count = 0
        while True:
            # generate the next state
            cs1 = self.player_one.cs.update(next_state.pop(0))
            cs2 = self.player_two.cs.update(next_state.pop(0))
            # Flip between these two payment types
            next_state += next_state[::-1]

            # create the transactions for the next state
            txns_for_p2 = cs1.get_txns(
                    self.player_one.get_my_address(),
                    self.player_one.get_my_key(),
                    self.player_one.get_counterparty_address(),
                    self.player_one.get_counterparty_key(),
                    self.player_one.get_counterparty_revoke()
                    )
            txns_for_p1 = cs2.get_txns(
                    self.player_two.get_my_address(),
                    self.player_two.get_my_key(),
                    self.player_two.get_counterparty_address(),
                    self.player_two.get_counterparty_key(),
                    self.player_two.get_counterparty_revoke()
                    )

            # TODO: Sign the TXNs
            # We should half-sign the start transaction
            # fully sign resolutin transactions
            # not sign the revoke transaction

            # exchange the transactions & set them as latest resolution
            self.player_one.set_latest_resolution(txns_for_p1)
            self.player_two.set_latest_resolution(txns_for_p2)

            # Once exchanged, ratchet up to eliminate the prior state
            # Order doesn't matter
            assert(self.player_two.receive_revoke(self.player_one.revoke()) and
            self.player_one.receive_revoke(self.player_two.revoke()))

            # set the state to the update
            self.player_one.set_channel_state(cs1)
            self.player_two.set_channel_state(cs2)

            # If this is our first pass, we still have yet to open the channel, so do that sub-protocol
            if self.channel_is_open:
                self.sign_and_broadcast_open_channel()
            print("Player One Estimated Value", self.player_one.cs.estimate_my_value())
            print("Player Two Estimated Value", self.player_two.cs.estimate_my_value())
            count += 1

    def get_output_script(self):
        return CScript([self.player_one.get_my_key(), OP_CHECKSIGVERIFY, self.player_two.get_my_key(), OP_CHECKSIG])


def revokable_script(signer_one, signer_two, revoke_key):
    # Either signer_one + revoke_key; OR
    # signer_one + signer_two; BUT NOT
    # signer_two + revoke_key
    return CScript( [ OP_1, signer_two, revoke_key, OP_2, OP_CHECKMULTISIGVERIFY, signer_one, OP_CHECKSIG])
def segwit(script):
    return script

class ChannelState:
    def __init__(self, _input, my_coins, ur_coins, revoke_timeout = 24, contract_duration = 365*24, block_offset = 100):
        self.input = _input
        self.my_payout_nblocks_first = my_coins
        self.ur_payout_nblocks_first = ur_coins
        self.my_payout_timeout_first = my_coins
        self.ur_payout_timeout_first = ur_coins
        self.revoke_timeout = revoke_timeout
        self.contract_duration = contract_duration
        self.block_offset = block_offset
    def update(self, delta, contract_delta=None):
        (a, b) = delta
        c = copy.copy(self)
        c.my_payout_nblocks_first += a
        c.ur_payout_nblocks_first -= a
        c.my_payout_timeout_first += b
        c.ur_payout_timeout_first -= b
        return c
    def get_txns(self, my_address, my_key, ur_address, ur_key, ur_revoke_key):
        return DiffChanUpdate.update_from_me_to_you(
                self.input,
                self.my_payout_nblocks_first,
                self.my_payout_timeout_first,
                my_address, my_key,
                self.ur_payout_nblocks_first,
                self.ur_payout_timeout_first,
                ur_address, ur_key, ur_revoke_key,
                self.revoke_timeout, self.contract_duration, self.block_offset)
    def estimate_my_value(self):
        p = self.estimate_p_nblocks_first()
        q = 1.0 - p
        return p*self.my_payout_nblocks_first + q * self.my_payout_timeout_first
    def estimate_p_nblocks_first(self):
        return 0.99
class DiffChanUpdate:
    # returns three sets of transactions:
    # 1 start txn
    # 1 revoke
    # 1 set of contested resolutions
    @staticmethod
    def update_from_me_to_you(input_,
            my_payout_nblocks_first, my_payout_timeout_first, my_address, my_key,
            ur_payout_nblocks_first, ur_payout_timeout_first, ur_address, ur_key, ur_revoke_key,
            revoke_timeout = 24, contract_duration = 365*24, block_offset = 100
            ):
        until_block = expected_blocks_hours_from_now(contract_duration) + block_offset
        rth = relative_timelock_hours(revoke_timeout)
        revokable_address = segwit(revokable_script(my_key, ur_key, ur_revoke_key))
        if my_payout_nblocks_first == my_payout_timeout_first:
            my_payout = my_payout_nblocks_first
            assert(ur_payout_nblocks_first == ur_payout_timeout_first)
            ur_payout = ur_payout_nblocks_first
            start =  TxnBuilder()\
                    .input(input_)\
                    .output(my_payout, my_address)\
                    .output(ur_payout, revokable_address)\
                    .finish()
            finish = TxnBuilder()\
                        .input(start.outpoint(1), rth)\
                        .output(ur_payout, ur_address)

            revoked = TxnBuilder()\
                        .input(start.outpoint(1))\
                        .output(ur_payout, my_address)
            return [start, [finish], revoked]

        elif my_payout_nblocks_first > my_payout_timeout_first:
            my_payout = my_payout_nblocks_first - my_payout_timeout_first
            my_immediate_payout = my_payout_timeout_first
            start = TxnBuilder()\
                        .input(input_)\
                        .output(my_immediate_payout, my_address)\
                        .output(ur_payout_timeout_first, revokable_address)\
                        .finish()
            finish_timeout =  TxnBuilder()\
                                        .absolute_timelock_time(contract_duration)\
                                        .input(start.outpoint(1), rth)\
                                        .output(ur_payout_timeout_first, ur_address)
            finish_nblocks = TxnBuilder()\
                                        .absolute_timelock_blocks(until_block)\
                                        .input(start.outpoint(1), rth)\
                                        .output(my_payout, my_address)\
                                        .output(ur_payout_nblocks_first, ur_address)

            revoked = TxnBuilder()\
                        .input(start.outpoint(1))\
                        .output(ur_payout, my_address)
            return [start, [finish_timeout, finish_nblocks], revoked]
        elif my_payout_timeout_first > my_payout_nblocks_first:
            my_payout = my_payout_timeout_first - my_payout_nblocks_first
            my_immediate_payout = my_payout_nblocks_first
            start =  TxnBuilder()\
                        .input(input_)\
                        .output(my_immediate_payout, my_address)\
                        .output(ur_payout_nblocks_first, revokable_address)\
                        .finish()
            finish_timeout = TxnBuilder()\
                                    .absolute_timelock_time(contract_duration)\
                                    .input(start.outpoint(1))\
                                    .output(my_payout, my_address)\
                                    .output(ur_payout_timeout_first, ur_address)
            finish_nblocks = TxnBuilder()\
                                    .absolute_timelock_blocks(until_block)\
                                    .input(start.outpoint(1))\
                                    .output(ur_payout_nblocks_first, ur_address)
            revoked = TxnBuilder()\
                        .input(start.outpoint(1))\
                        .output(ur_payout, my_address)
            return [start, [finish_timeout, finish_nblocks], revoked]


SEQUENCE_DISABLED = 0x80000000
def relative_timelock_hours(h):
    b = SEQUENCE_DISABLED
    b ^= 1<<31
    b |= 1<<31
    b |= (h * 60) >> 9
    return b
def abs_hours_from_now(h):
    return h
def expected_blocks_hours_from_now(h):
    return (h/6.0)

from bitcointx.core import b2x, lx, COIN, COutPoint, CMutableTxOut, CMutableTxIn, CMutableTransaction, Hash160
class TxnBuilder:
    def __init__(self):
        self.outputs = []
        self.inputs = []
        self.locktime = 0
        self.finalized = None
        pass
    def input(self, input_, seq = SEQUENCE_DISABLED):
        self.inputs.append(CMutableTxIn(input_, nSequence=seq))
        return self
    def output(self, amount, to):
        self.outputs.append(CMutableTxOut(amount, to))
        return self
    def absolute_timelock_time(self, l):
        self.nLockTime = l
        return self
    def absolute_timelock_blocks(self, l):
        self.nLockTime = l
        return self
    def finish(self):
        self.finalized = CMutableTransaction(self.inputs, self.outputs, self.locktime, 2)
        return self
    def outpoint(self, n):
        assert(n < len(self.outputs))
        return COutPoint(self.finalized.GetTxid(), n)


Alice = Player()
Bob = Player()
oc = OpenChannel(Alice, Bob, 100*COIN)
oc.run_channel()
print(CScript(list(oc.get_output_script())))
	#!/usr/bin/python3
	# Originally shared ~ 7/1/19 with Dan Elitzer
	# Copyright 2019 Jeremy Rubin

	# Permission is hereby granted, free of charge, to any person obtaining a copy
	# of this software and associated documentation files (the "Software"), to deal
	# in the Software without restriction, including without limitation the rights
	# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	# copies of the Software, and to permit persons to whom the Software is
	# furnished to do so, subject to the following conditions:
	#
	# The above copyright notice and this permission notice shall be included in
	# all copies or substantial portions of the Software.
	#
	# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
	# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
	# SOFTWARE.
	#

	import bitcointx
	import hashlib
	import os

	from bitcointx.wallet import CBitcoinSecret
	from bitcointx.core.script import CScript, OP_CHECKMULTISIG, CScriptOp, OP_2, OP_CHECKSIGVERIFY, OP_1, OP_CHECKMULTISIGVERIFY, OP_CHECKSIG
	import time
	CHAIN_SIZE = 100
	# SecretChain is a hash chain H(H(H(...H(x))))
	# Each H(...) also has an associated pk = H(...)xG
	class SecretChain:
	def __init__(self, seed = None):
	self.seed = os.urandom(32) if seed is None else seed
	self.secrets = [0]*int(CHAIN_SIZE)
	self.secrets[0] = hashlib.sha256(self.seed).digest()
	for i in range(1,int(CHAIN_SIZE)):
	self.secrets[i] = hashlib.sha256(self.secrets[i-1]).digest()
	self.pks = list(map(lambda x: CBitcoinSecret.from_secret_bytes(x).pub, self.secrets))
	def pop(self):
	return self.secrets.pop() if len(self.secrets) else None
	# SecretTraversal lets us receive new preimages from Secret Chain
	# It is initialized with all the Pks from the entire chain
	# Step by step, we check that the latest secret reveals
	# the next PK, and that the hash of the latest secret is the prior secret.
	class SecretTraversal:
	def __init__(self, pks):
	self.last = None
	self.pks = pks
	self.next = pks.pop()
	self.count = 0
	def update(self, secret):
	if secret is None:
	return False
	pk = CBitcoinSecret.from_secret_bytes(secret).pub
	secret_hash = hashlib.sha256(secret).digest()

	if self.last is None:
	if self.next != pk:
	print('nope1')
	return False
	else:
	if self.last != secret_hash:
	print('no')
	return False
	if self.next != pk:
	print('nope')
	return False
	print("Learned Secret SHA256(%s) == %s:"%(secret, secret_hash))
	print("%s x G == %s"%(secret, self.next))
	self.last = secret
	self.next = self.pks.pop() if self.pks else None
	print("Next Secret: ", self.next, "\n")

	self.count += 1
	return True
	def get_next(self):
	return self.pks[-1]
	def seek(self, pk):
	sec = self.last
	for _ in range(self.count):
	if CBitcoinSecret.from_secret_bytes(sec).pub == pk:
	return sec
	sec = hashlib.sha256(sec).digest()
	return None


	class Player:
	def __init__(self):
	self.sec = CBitcoinSecret.from_secret_bytes(os.urandom(32))
	self.my_revoke_chain = SecretChain()
	self.counterparty_revokes = None
	def scriptKey(self):
	return CScript(CScriptOp.encode_op_pushdata(self.sec.pub))
	def get_my_public_revokes(self):
	return self.my_revoke_chain.pks.copy()
	def set_counterparty_revokes(self, pks):
	self.counterparty_revokes = SecretTraversal(pks)
	def set_channel_state(self, cs):
	self.cs = cs

	def get_my_address(self):
	return self.scriptKey()
	def get_my_key(self):
	return self.sec.pub
	def get_counterparty_address(self):
	return b"DUMMY ADDRESS"
	def get_counterparty_revoke(self):
	return self.counterparty_revokes.get_next()
	def get_counterparty_key(self):
	return b"DUMMY KEY"
	def revoke(self):
	return self.my_revoke_chain.pop()
	def receive_revoke(self, secret):
	return self.counterparty_revokes.update(secret)
	def set_latest_resolution(self, latest_resolution):
	self.latest_resolution = latest_resolution

	import copy
	class OpenChannel:
	def __init__(self, player_one, player_two, amt):
	self.player_one = player_one
	self.player_two = player_two
	self.input = self.agree_on_input()
	self.channel_is_open = False
	# mirror channel states
	cs1 = ChannelState(self.input, amt, amt)
	cs2 = ChannelState(self.input, amt, amt)
	# load each players revoke chains
	player_one.set_counterparty_revokes(player_two.get_my_public_revokes())
	player_two.set_counterparty_revokes(player_one.get_my_public_revokes())
	# load channel states
	player_one.set_channel_state(cs1)
	player_two.set_channel_state(cs2)
	def agree_on_input(self):
	# We don't have an actual input...
	return COutPoint(b"0"*32, 0)
	def sign_and_broadcast_open_channel(self):
	self.channel_is_open = True

	def run_channel(self):
	# First two states are a null update
	next_state = [(0,0), (0, 0), (-1COIN, -2COIN), (1COIN, 2COIN)]
	count = 0
	while True:
	# generate the next state
	cs1 = self.player_one.cs.update(next_state.pop(0))
	cs2 = self.player_two.cs.update(next_state.pop(0))
	# Flip between these two payment types
	next_state += next_state[::-1]

	# create the transactions for the next state
	txns_for_p2 = cs1.get_txns(
	self.player_one.get_my_address(),
	self.player_one.get_my_key(),
	self.player_one.get_counterparty_address(),
	self.player_one.get_counterparty_key(),
	self.player_one.get_counterparty_revoke()
	)
	txns_for_p1 = cs2.get_txns(
	self.player_two.get_my_address(),
	self.player_two.get_my_key(),
	self.player_two.get_counterparty_address(),
	self.player_two.get_counterparty_key(),
	self.player_two.get_counterparty_revoke()
	)

	# TODO: Sign the TXNs
	# We should half-sign the start transaction
	# fully sign resolutin transactions
	# not sign the revoke transaction

	# exchange the transactions & set them as latest resolution
	self.player_one.set_latest_resolution(txns_for_p1)
	self.player_two.set_latest_resolution(txns_for_p2)

	# Once exchanged, ratchet up to eliminate the prior state
	# Order doesn't matter
	assert(self.player_two.receive_revoke(self.player_one.revoke()) and
	self.player_one.receive_revoke(self.player_two.revoke()))

	# set the state to the update
	self.player_one.set_channel_state(cs1)
	self.player_two.set_channel_state(cs2)

	# If this is our first pass, we still have yet to open the channel, so do that sub-protocol
	if self.channel_is_open:
	self.sign_and_broadcast_open_channel()
	print("Player One Estimated Value", self.player_one.cs.estimate_my_value())
	print("Player Two Estimated Value", self.player_two.cs.estimate_my_value())
	count += 1

	def get_output_script(self):
	return CScript([self.player_one.get_my_key(), OP_CHECKSIGVERIFY, self.player_two.get_my_key(), OP_CHECKSIG])


	def revokable_script(signer_one, signer_two, revoke_key):
	# Either signer_one + revoke_key; OR
	# signer_one + signer_two; BUT NOT
	# signer_two + revoke_key
	return CScript( [ OP_1, signer_two, revoke_key, OP_2, OP_CHECKMULTISIGVERIFY, signer_one, OP_CHECKSIG])
	def segwit(script):
	return script

	class ChannelState:
	def __init__(self, _input, my_coins, ur_coins, revoke_timeout = 24, contract_duration = 365*24, block_offset = 100):
	self.input = _input
	self.my_payout_nblocks_first = my_coins
	self.ur_payout_nblocks_first = ur_coins
	self.my_payout_timeout_first = my_coins
	self.ur_payout_timeout_first = ur_coins
	self.revoke_timeout = revoke_timeout
	self.contract_duration = contract_duration
	self.block_offset = block_offset
	def update(self, delta, contract_delta=None):
	(a, b) = delta
	c = copy.copy(self)
	c.my_payout_nblocks_first += a
	c.ur_payout_nblocks_first -= a
	c.my_payout_timeout_first += b
	c.ur_payout_timeout_first -= b
	return c
	def get_txns(self, my_address, my_key, ur_address, ur_key, ur_revoke_key):
	return DiffChanUpdate.update_from_me_to_you(
	self.input,
	self.my_payout_nblocks_first,
	self.my_payout_timeout_first,
	my_address, my_key,
	self.ur_payout_nblocks_first,
	self.ur_payout_timeout_first,
	ur_address, ur_key, ur_revoke_key,
	self.revoke_timeout, self.contract_duration, self.block_offset)
	def estimate_my_value(self):
	p = self.estimate_p_nblocks_first()
	q = 1.0 - p
	return pself.my_payout_nblocks_first + q self.my_payout_timeout_first
	def estimate_p_nblocks_first(self):
	return 0.99
	class DiffChanUpdate:
	# returns three sets of transactions:
	# 1 start txn
	# 1 revoke
	# 1 set of contested resolutions
	@staticmethod
	def update_from_me_to_you(input_,
	my_payout_nblocks_first, my_payout_timeout_first, my_address, my_key,
	ur_payout_nblocks_first, ur_payout_timeout_first, ur_address, ur_key, ur_revoke_key,
	revoke_timeout = 24, contract_duration = 365*24, block_offset = 100
	):
	until_block = expected_blocks_hours_from_now(contract_duration) + block_offset
	rth = relative_timelock_hours(revoke_timeout)
	revokable_address = segwit(revokable_script(my_key, ur_key, ur_revoke_key))
	if my_payout_nblocks_first == my_payout_timeout_first:
	my_payout = my_payout_nblocks_first
	assert(ur_payout_nblocks_first == ur_payout_timeout_first)
	ur_payout = ur_payout_nblocks_first
	start = TxnBuilder()\
	.input(input_)\
	.output(my_payout, my_address)\
	.output(ur_payout, revokable_address)\
	.finish()
	finish = TxnBuilder()\
	.input(start.outpoint(1), rth)\
	.output(ur_payout, ur_address)

	revoked = TxnBuilder()\
	.input(start.outpoint(1))\
	.output(ur_payout, my_address)
	return [start, [finish], revoked]

	elif my_payout_nblocks_first > my_payout_timeout_first:
	my_payout = my_payout_nblocks_first - my_payout_timeout_first
	my_immediate_payout = my_payout_timeout_first
	start = TxnBuilder()\
	.input(input_)\
	.output(my_immediate_payout, my_address)\
	.output(ur_payout_timeout_first, revokable_address)\
	.finish()
	finish_timeout = TxnBuilder()\
	.absolute_timelock_time(contract_duration)\
	.input(start.outpoint(1), rth)\
	.output(ur_payout_timeout_first, ur_address)
	finish_nblocks = TxnBuilder()\
	.absolute_timelock_blocks(until_block)\
	.input(start.outpoint(1), rth)\
	.output(my_payout, my_address)\
	.output(ur_payout_nblocks_first, ur_address)

	revoked = TxnBuilder()\
	.input(start.outpoint(1))\
	.output(ur_payout, my_address)
	return [start, [finish_timeout, finish_nblocks], revoked]
	elif my_payout_timeout_first > my_payout_nblocks_first:
	my_payout = my_payout_timeout_first - my_payout_nblocks_first
	my_immediate_payout = my_payout_nblocks_first
	start = TxnBuilder()\
	.input(input_)\
	.output(my_immediate_payout, my_address)\
	.output(ur_payout_nblocks_first, revokable_address)\
	.finish()
	finish_timeout = TxnBuilder()\
	.absolute_timelock_time(contract_duration)\
	.input(start.outpoint(1))\
	.output(my_payout, my_address)\
	.output(ur_payout_timeout_first, ur_address)
	finish_nblocks = TxnBuilder()\
	.absolute_timelock_blocks(until_block)\
	.input(start.outpoint(1))\
	.output(ur_payout_nblocks_first, ur_address)
	revoked = TxnBuilder()\
	.input(start.outpoint(1))\
	.output(ur_payout, my_address)
	return [start, [finish_timeout, finish_nblocks], revoked]




	SEQUENCE_DISABLED = 0x80000000
	def relative_timelock_hours(h):
	b = SEQUENCE_DISABLED
	b ^= 1<<31
	b \|= 1<<31
	b \|= (h * 60) >> 9
	return b
	def abs_hours_from_now(h):
	return h
	def expected_blocks_hours_from_now(h):
	return (h/6.0)

	from bitcointx.core import b2x, lx, COIN, COutPoint, CMutableTxOut, CMutableTxIn, CMutableTransaction, Hash160
	class TxnBuilder:
	def __init__(self):
	self.outputs = []
	self.inputs = []
	self.locktime = 0
	self.finalized = None
	pass
	def input(self, input_, seq = SEQUENCE_DISABLED):
	self.inputs.append(CMutableTxIn(input_, nSequence=seq))
	return self
	def output(self, amount, to):
	self.outputs.append(CMutableTxOut(amount, to))
	return self
	def absolute_timelock_time(self, l):
	self.nLockTime = l
	return self
	def absolute_timelock_blocks(self, l):
	self.nLockTime = l
	return self
	def finish(self):
	self.finalized = CMutableTransaction(self.inputs, self.outputs, self.locktime, 2)
	return self
	def outpoint(self, n):
	assert(n < len(self.outputs))
	return COutPoint(self.finalized.GetTxid(), n)



	Alice = Player()
	Bob = Player()
	oc = OpenChannel(Alice, Bob, 100*COIN)
	oc.run_channel()
	print(CScript(list(oc.get_output_script())))