Exemplo n.º 1
0
 def test_exercise_5(self):
     prev_tx_1 = bytes.fromhex(
         '11d05ce707c1120248370d1cbf5561d22c4f83aeba0436792c82e0bd57fe2a2f')
     prev_index_1 = 1
     prev_tx_2 = bytes.fromhex(
         '51f61f77bd061b9a0da60d4bedaaf1b1fad0c11e65fdc744797ee22d20b03d15')
     prev_index_2 = 1
     target_address = 'mwJn1YPMq7y5F8J3LkC5Hxg9PHyZ5K4cFv'
     target_amount = 0.0429
     secret = 8675309
     priv = PrivateKey(secret=secret)
     tx_ins = []
     tx_ins.append(TxIn(prev_tx_1, prev_index_1, Script([]), 0xffffffff))
     tx_ins.append(TxIn(prev_tx_2, prev_index_2, Script([]), 0xffffffff))
     tx_outs = []
     h160 = decode_base58(target_address)
     script_pubkey = p2pkh_script(h160)
     target_satoshis = int(target_amount * 100000000)
     tx_outs.append(TxOut(target_satoshis, script_pubkey))
     tx_obj = Tx(1, tx_ins, tx_outs, 0, testnet=True)
     self.assertTrue(tx_obj.sign_input(0, priv))
     self.assertTrue(tx_obj.sign_input(1, priv))
     self.assertTrue(tx_obj.verify())
     want = '01000000022f2afe57bde0822c793604baae834f2cd26155bf1c0d37480212c107e75cd011010000006a47304402204cc5fe11b2b025f8fc9f6073b5e3942883bbba266b71751068badeb8f11f0364022070178363f5dea4149581a4b9b9dbad91ec1fd990e3fa14f9de3ccb421fa5b269012103935581e52c354cd2f484fe8ed83af7a3097005b2f9c60bff71d35bd795f54b67ffffffff153db0202de27e7944c7fd651ec1d0fab1f1aaed4b0da60d9a1b06bd771ff651010000006b483045022100b7a938d4679aa7271f0d32d83b61a85eb0180cf1261d44feaad23dfd9799dafb02205ff2f366ddd9555f7146861a8298b7636be8b292090a224c5dc84268480d8be1012103935581e52c354cd2f484fe8ed83af7a3097005b2f9c60bff71d35bd795f54b67ffffffff01d0754100000000001976a914ad346f8eb57dee9a37981716e498120ae80e44f788ac00000000'
     self.assertEqual(tx_obj.serialize().hex(), want)
Exemplo n.º 2
0
	def __init__(self, serialized_psbt):
		self.role = "Finalizer"
		self.psbt = PSBT.parse(BytesIO(serialized_psbt))
		for i in self.psbt.maps["inputs"]:
			if not self._check_for_sig(i):
				continue
			if IN_SIGHASH_TYPE not in i.keys():
				continue
			if self._is_witness_input(i):
				if IN_WITNESS_SCRIPT not in i.keys():
					continue
				# Step 3b: Then create scriptWitness
				new_scriptWitness = self._make_multisig_script(inp=i, witness=True)
				# Complete scriptWitness by adding the number of witness items to the beginning 
				new_scriptWitness.insert(0, len(new_scriptWitness))
				# Add key-type PSBT_IN_FINAL_SCRIPTWITNESS to PSBT with the finalized scriptWitness as its value     
				i[IN_FINAL_SCRIPTWITNESS] = Script(new_scriptWitness).serialize()
				# Add key-type PSBT_IN_FINAL_SCRIPTSIG to PSBT with the finalized scriptSig as its value
				# For witness inputs, this is the redeemScript preceded by its length
				i[IN_FINAL_SCRIPTSIG] = encode_varint(len(i[IN_REDEEM_SCRIPT])) + i[IN_REDEEM_SCRIPT]
			elif IN_REDEEM_SCRIPT in i.keys(): # ASSUME MULTISIG
				i[IN_FINAL_SCRIPTSIG] = Script(self._make_multisig_script(i)).serialize()
			else: # ASSUME P2PKH
				found_sec = False
				for k in i.keys():
					if k[:1] == IN_PARTIAL_SIG: # WTF IS THIS LOGIC???
						if found_sec:
							continue
						sec = k[1:]
						sig = i[k]
						found_sec = True
				i[IN_FINAL_SCRIPTSIG] = Script([sig, sec]).serialize()
			self._clear_keyvalues(i)
Exemplo n.º 3
0
def koopa_response(player: example.Wrap1, koopa: example.Wrap1, x, y):
    if koopa.getState() == 'hide':
        koopa.killScripts()
        if player.getState() == 'jump' and player.vy < 0:
            player.vy = 300
        #koopa.move(-10 * x, 0, 0)
        left = 0 if (player.x < koopa.x) else 1
        s = Script()
        s.add_action(
            act.SetState(state='walk2',
                         entity_id=koopa.id,
                         args={'left': left}))
        koopa.play(s)
    elif koopa.getState() == 'walk2':
        # hit player only if going towards player
        dx = player.x - koopa.x
        if (dx > 0 and not koopa.flipx) or (dx < 0 and koopa.flipx):
            player_hit_by_enemy(player)

    else:
        if player.getState() == "jump" and player.vy < 0:
            print('fokkami')
            player.vy = 300
            s = Script()
            s.add_action(act.SetState(state='hide', entity_id=koopa.id))
            s.add_action(act.Delay(20))
            s.add_action(
                act.Blink(duration=2, blink_duration=0.2, entity_id=koopa.id))
            s.add_action(act.SetState(state='walk', entity_id=koopa.id))
            koopa.play(s)
        else:
            player_hit_by_enemy(player)
Exemplo n.º 4
0
 def hash_to_sign(self, input_index, sighash):
     '''Returns the integer representation of the hash that needs to get
     signed for index input_index'''
     # create a new transaction that's a clone of self
     # use self.__class__(self.version, self.tx_ins, self.tx_outs, self.locktime)
     alternate_tx = self.__class__(self.version, self.tx_ins, self.tx_outs,
                                   self.locktime)
     # iterate through inputs
     for tx_in in alternate_tx.tx_ins:
         # for each input, create new TxIn with blanked out script_sig
         # use Script(b'')
         tx_in.script_sig = Script(b'')
     # grab the input at input_index
     tx_in = alternate_tx.tx_ins[input_index]
     # replace input_index input with scriptPubKey from that input
     # use Script(tx_in.script_pubkey())
     tx_in.script_sig = Script(tx_in.script_pubkey())
     # grab the serialization
     serialization = alternate_tx.serialize()
     # add the sighash int in 4 bytes, little endian
     serialization += int_to_little_endian(sighash, 4)
     # get the double_sha256 of the tx serialization
     ds256 = double_sha256(serialization)
     # convert this to a big-endian integer using int.from_bytes(x, 'big')
     return int.from_bytes(ds256, 'big')
Exemplo n.º 5
0
 def test_example_6(self):
     tx_ins = []
     prev_tx = bytes.fromhex(
         '0d6fe5213c0b3291f208cba8bfb59b7476dffacc4e5cb66f6eb20a080843a299')
     prev_index = 13
     tx_ins.append(TxIn(prev_tx, prev_index, Script([]), 0xffffffff))
     tx_outs = []
     change_amount = int(0.33 * 100000000)
     change_h160 = decode_base58('mzx5YhAH9kNHtcN481u6WkjeHjYtVeKVh2')
     change_script = p2pkh_script(change_h160)
     tx_outs.append(TxOut(amount=change_amount,
                          script_pubkey=change_script))
     target_amount = int(0.1 * 100000000)
     target_h160 = decode_base58('mnrVtF8DWjMu839VW3rBfgYaAfKk8983Xf')
     target_script = p2pkh_script(target_h160)
     tx_outs.append(TxOut(amount=target_amount,
                          script_pubkey=target_script))
     transaction = Tx(1, tx_ins, tx_outs, 0, testnet=True)
     z = transaction.sig_hash(0)
     private_key = PrivateKey(secret=8675309)
     der = private_key.sign(z).der()
     sig = der + SIGHASH_ALL.to_bytes(1, 'big')
     sec = private_key.point.sec()
     transaction.tx_ins[0].script_sig = Script([sig, sec])
     want = '010000000199a24308080ab26e6fb65c4eccfadf76749bb5bfa8cb08f291320b3c21e56f0d0d0000006b4830450221008ed46aa2cf12d6d81065bfabe903670165b538f65ee9a3385e6327d80c66d3b502203124f804410527497329ec4715e18558082d489b218677bd029e7fa306a72236012103935581e52c354cd2f484fe8ed83af7a3097005b2f9c60bff71d35bd795f54b67ffffffff02408af701000000001976a914d52ad7ca9b3d096a38e752c2018e6fbc40cdf26f88ac80969800000000001976a914507b27411ccf7f16f10297de6cef3f291623eddf88ac00000000'
     self.assertEqual(transaction.serialize().hex(), want)
Exemplo n.º 6
0
    def process_toggle_block_mention(self, minfo, keyword):
        log.debug(u'process_toggle_block_mention called with keyword: {}'.format(keyword.encode('utf8')))
        user = session.query(Follower).filter_by(uniqueid = minfo['id'])

        try: user = user.one()
        except NoResultFound: user = session.query(Follower).filter_by(mention_id = minfo['screen_name'])
        try: user = user.one()
        except: user = Follower(minfo['screen_name'], minfo['name'])

        SCRIPT_STOP = u'알았다요. 이제 먼저 말 걸지 않겠다요.. '
        SCRIPT_RESUME = u'헤헤 알았다요! 이제 닉시코가 먼저 말을 걸 수도 있다요!'

        if keyword.split()[1] in (u'중지', u'그만', u'중단'): # if suspend
            user.is_blocked = 1
            log.info(u'사용자 블록 전환: '.format(minfo['screen_name']))
            script = Script(SCRIPT_STOP)
            script.mention(minfo['screen_name'])
            self.do_tweet(script, minfo['id'])
        else: # if resume
            user.is_blocked = 0
            log.info(u'사용자 블록 해제: '.format(minfo['screen_name']))
            script = Script(SCRIPT_RESUME)
            script.mention(minfo['screen_name'])
            self.do_tweet(script, minfo['id'])

        session.add(user)
        session.commit()
        log.debug('toggle_block_mention done')
Exemplo n.º 7
0
 def test_example_1(self):
     z = 0x7c076ff316692a3d7eb3c3bb0f8b1488cf72e1afcd929e29307032997a838a3d
     sec = bytes.fromhex('04887387e452b8eacc4acfde10d9aaf7f6d9a0f975aabb10d006e4da568744d06c61de6d95231cd89026e286df3b6ae4a894a3378e393e93a0f45b666329a0ae34')
     sig = bytes.fromhex('3045022000eff69ef2b1bd93a66ed5219add4fb51e11a840f404876325a1e8ffe0529a2c022100c7207fee197d27c618aea621406f6bf5ef6fca38681d82b2f06fddbdce6feab601')
     script_pubkey = Script([sec, 0xac])
     script_sig = Script([sig])
     combined_script = script_sig + script_pubkey
     self.assertTrue(combined_script.evaluate(z))
Exemplo n.º 8
0
def build_combo(fn, config, platform):
    print('building {0} {1} {2}...'.format(fn.__name__, config, platform))
    bat = Script(True, fn.__name__, config, platform) #build script
    fn(bat)
    bat.run()

    print('installing {0} {1} {2}...'.format(fn.__name__, config, platform))
    bat = Script(False, fn.__name__, config, platform) #istallation script
    fn(bat)
    bat.run()
Exemplo n.º 9
0
 def finalize_p2wpkh(self, sig, sec, redeem_script=None):
     '''Puts together the ScriptSig and Witness for a p2wpkh input so the input verifies.'''
     # if the RedeemScript is given, the ScriptSig is a single element Script of its raw serialization
     if redeem_script:
         self.script_sig = Script([redeem_script.raw_serialize()])
     # else the ScriptSig should be empty
     else:
         self.script_sig = Script()
     # the Witness for p2wpkh is [sig, sec]
     self.witness = Witness([sig, sec])
Exemplo n.º 10
0
 def sig_hash(self, indice_input, tipo_hash):
     '''Devuelve la representación entera del hash que necesitas firmar
     para el índice indice_input'''
     # crea una nueva serie de tx_ins (alt_tx_ins)
     alt_tx_ins = []
     # itera sobre self.tx_ins
     for tx_in in self.tx_ins:
         # crea un nuevo TxIn que tenga un script_sig (b'') en blanco y añáde a alt_tx_ins
         alt_tx_ins.append(
             TxIn(
                 tx_previa=tx_in.tx_previa,
                 indice_previo=tx_in.indice_previo,
                 script_sig=Script([]),
                 sequence=tx_in.sequence,
             ))
     # obtén el input en el indice_input
     input_firmante = alt_tx_ins[indice_input]
     # obtén el script_pubkey del input
     script_pubkey = input_firmante.script_pubkey(self.testnet)
     # el script_sig del input_firmante debería ser script_pubkey
     input_firmante.script_sig = script_pubkey
     # crea una transacción alternativa con las tx_ins modificadas
     alt_tx = self.__class__(versión=self.versión,
                             tx_ins=alt_tx_ins,
                             tx_outs=self.tx_outs,
                             locktime=self.locktime)
     # añade el tipo_hash entero 4 bytes, little endian
     res = alt_tx.serializar() + int_a_little_endian(tipo_hash, 4)
     # obtén el doble_sha256 de la serialización de la tx
     s256 = doble_sha256(res)
     # convierte esto a un entero big-endian usando int.from_bytes(x, 'big')
     return int.from_bytes(s256, 'big')
Exemplo n.º 11
0
    def prueba_firmar_input(self):
        clave_privada = ClavePrivada(secreto=8675309)
        tx_ins = []
        tx_previa = bytes.fromhex(
            '0025bc3c0fa8b7eb55b9437fdbd016870d18e0df0ace7bc9864efc38414147c8')
        tx_ins.append(
            TxIn(
                tx_previa=tx_previa,
                indice_previo=0,
                script_sig=Script([]),
                sequence=0xffffffff,
            ))
        tx_outs = []
        h160 = decodificar_base58('mzx5YhAH9kNHtcN481u6WkjeHjYtVeKVh2')
        tx_outs.append(
            TxOut(cantidad=int(0.99 * 100000000),
                  script_pubkey=script_p2pkh(h160)))
        h160 = decodificar_base58('mnrVtF8DWjMu839VW3rBfgYaAfKk8983Xf')
        tx_outs.append(
            TxOut(cantidad=int(0.1 * 100000000),
                  script_pubkey=script_p2pkh(h160)))

        tx = Tx(
            versión=1,
            tx_ins=tx_ins,
            tx_outs=tx_outs,
            locktime=0,
            testnet=True,
        )
        self.assertTrue(tx.firmar_input(0, clave_privada, SIGHASH_ALL))
Exemplo n.º 12
0
 def sign_input(self, idx, private_key, sighash_type=SIGHASH_ALL):
     '''Signs the input using the private key'''
     # get the signature hash (z)
     tx_in = self.tx_ins[idx]
     script_pubkey = tx_in.script_pubkey(testnet=self.testnet)
     if script_pubkey.is_p2wpkh_script():
         z = self.sig_hash_bip143(idx)
     elif script_pubkey.is_p2pkh_script():
         z = self.sig_hash(idx, sighash_type=sighash_type)
     #TODO p2sh-p2wpkh
     elif script_pubkey.is_p2wsh_script():
         #z = self.sig_hash_bip143(idx, witness_script=tx_in.witness)
         raise NotImplementedError
     else:
         raise NotImplementedError
     # get der signature of z from private key
     der = private_key.sign(z).der()
     # append the sighash_type to der (use sighash_type.to_bytes(1, 'big'))
     sig = der + sighash_type.to_bytes(1, 'big')
     # calculate the sec
     sec = private_key.point.sec()
     # initialize a new script with [sig, sec] as the cmds
     script_sig = Script([sig, sec])
     # change input's script_sig to new script
     if tx_in.segwit:
         self.tx_ins[idx].witness = script_sig
     else:
         self.tx_ins[idx].script_sig = script_sig
     # return whether sig is valid using self.verify_input
     if self.verify_input(idx):
         return script_sig
     else:
         return False
Exemplo n.º 13
0
    def sign_input(self, input_index, private_key):
        # get the signature hash (z)

        ##
        ## Might need to provide logic to get sig_hash depending on whether it is segwit or not.
        ## The following right now is for not segwit
        ##

        ##  If spending a segwit utxo then --will need to look at the form of the utxo script pubkey
        ##      z = self.sig_hash_bip143
        ##  else

        z = self.sig_hash(input_index)

        # get der signature of z from private key
        der = private_key.sign(z).der()
        # append the SIGHASH_ALL to der (use SIGHASH_ALL.to_bytes(1, 'big'))
        sig = der + SIGHASH_ALL.to_bytes(1, 'big')
        # calculate the sec
        sec = private_key.point.sec()
        # initialize a new script with [sig, sec] as the cmds
        script = Script([sig, sec])
        print("Script_Sig from within sign_input:  ", script)
        # change input's script_sig to new script
        self.tx_ins[input_index].script_sig = script
        # return whether sig is valid using self.verify_input
        # verify_input will return True if the signautre is valid
        verify = self.verify_input(input_index)
        print(verify)
        return verify
Exemplo n.º 14
0
def new_commitment_tx(node, current_channel, cost, secret_hash):

    remote_peer = current_channel.peer

    # Create input using the output from the funding tx
    tx_in = TxIn(bytes.fromhex(current_channel.funding_tx.id()), 0)

    # Create 3 outputs. 1 to nodeA and 1 to nodeB and 1 to an HTLC script
    script_1 = p2pkh_script(decode_base58(node.address))
    tx_out_1 = TxOut(amount=current_channel.local_amt - cost,
                     script_pubkey=script_1)

    script_2 = p2pkh_script(decode_base58(remote_peer.btc_addr.decode()))
    tx_out_2 = TxOut(amount=current_channel.remote_amt, script_pubkey=script_2)

    #script_3 HTLC
    script_3 = Script([
        99, 168, secret_hash, 136, 118, 169,
        hash160(remote_peer.public_key.sec()), 103,
        encode_varint(1000), 177, 117, 118, 169,
        hash160(node.public_key.sec()), 104, 136, 172
    ])
    tx_out_3 = TxOut(amount=cost, script_pubkey=script_3)

    # Construct the commitment tx object
    commitment_tx = Tx(1, [tx_in], [tx_out_1, tx_out_2, tx_out_3], 0, True)

    #sign it
    commitment_tx.tx_ins[0].script_sig = get_script_sig(
        commitment_tx, node.private_key)

    return commitment_tx
Exemplo n.º 15
0
 def sig_hash(self, input_index, redeem_script=None):
     alt_tx_ins = []
     for tx_in in self.tx_ins:
         alt_tx_ins.append(
             TxIn(
                 prev_tx=tx_in.prev_tx,
                 prev_index=tx_in.prev_index,
                 script_sig=Script([]),
                 sequence=tx_in.sequence,
             ))
     signing_input = alt_tx_ins[input_index]
     if redeem_script:
         print(redeem_script)
         signing_input.script_sig = redeem_script
     else:
         signing_input.script_sig = signing_input.script_pubkey(
             self.testnet)
     for i in alt_tx_ins:
         print(i.script_sig)
     alt_tx = self.__class__(version=self.version,
                             tx_ins=alt_tx_ins,
                             tx_outs=self.tx_outs,
                             locktime=self.locktime)
     result = alt_tx.serialize() + int_to_little_endian(SIGHASH_ALL, 4)
     h256 = hash256(result)
     return int.from_bytes(h256, 'big')
Exemplo n.º 16
0
    def test_create_changer_from_pos(self):
        script_str = r'''
func1(
    param1,
    param2,
    func32(adfd),
    func3(1,2,3,4,
        "abcdefg(fsdsd)"),
    func39(1,2,3,4,
        "abc'defg(fsdsd)"),
    [1, 2, 3, 4],
    func4(1,2,3,4,
        "abc'd\"ef'g(fsdsd)"),
    ")))))))",
    '((((((')
func2(1,2,3)'''
        script = Script(script_str)
        manager = ParameterChangerManager(script)
        changer = manager._create_changer_from_pos(0)
        params = changer.get_parameters()
        self.assertEqual(params[0], 'param1')
        self.assertEqual(params[1], 'param2')
        self.assertEqual(params[2], 'func32(adfd)')
        self.assertEqual(params[3],
                         'func3(1,2,3,4,\n        "abcdefg(fsdsd)")')
        self.assertEqual(params[4],
                         'func39(1,2,3,4,\n        "abc\'defg(fsdsd)")')
        self.assertEqual(params[5], '[1, 2, 3, 4]')
        self.assertEqual(params[6],
                         'func4(1,2,3,4,\n        "abc\'d\\"ef\'g(fsdsd)")')
        self.assertEqual(params[7], '")))))))"')
        self.assertEqual(params[8], '\'((((((\'')
 def sign_input(self, input_index: int, private_key):
     z = self.sig_hash(input_index)
     der = private_key.sign(z).der()
     sig = der+SIGHASH_ALL.to_bytes(1, "big")
     sec = private_key.point.sec()
     self.tx_ins[input_index].script_sig = Script([sig, sec])
     return self.verify_input(input_index)
Exemplo n.º 18
0
 def __init__(self):
     self.list_speaks = []
     self.born_time = time.time()
     self.attributes = {}
     self.stop = False
     self.user = User()
     self.script = Script(self)
Exemplo n.º 19
0
def build_transaction(transidsarr, transindexarr, pubeysarr, amountsarr,
                      privatekey):
    tx_ins = buildinputs(transidsarr, transindexarr)
    tx_outs = buildoutputs(pubkeysarr, amountsarr)
    tx_obj = Tx(version=1,
                tx_ins=tx_ins,
                tx_outs=tx_outs,
                locktime=0,
                testnet=True)
    hash_type = SIGHASH_ALL
    z = tx_obj.sig_hash(0, hash_type)
    pk = PrivateKey(secret=privatekey)
    sighash = SIGHASH_ALL
    z = tx_obj.sig_hash(0, sighash)
    #print(z)
    sig = pk.sign(z)
    #print("r: " + str(sig.r))
    #print("s: " + str(sig.s))
    der = pk.sign(z).der()
    sig = der + bytes([sighash])
    sec = pk.point.sec()
    tx_obj.tx_ins[0].script_sig = Script([sig, sec])
    #print("serialized:")
    #print(hexlify(Script([sig,sec]).serialize()))
    #print("----------")
    return hexlify(tx_obj.serialize())
Exemplo n.º 20
0
 def sign_input_multisig_1by1(self, input_index, private_key,privkey_index, redeem_script,n):
     '''Signs the input using the private key
     n: n signatures that can sign transaction.
     private_key: must be a PrivateKey object.
     privkey_index: is the index of the private key according to the order of the public keys.
     '''
     # get the signature hash (z)
     z = self.sig_hash(input_index, redeem_script)
     # get der signature of z from private key
     cmds = self.tx_ins[input_index].script_sig.cmds
     if len(cmds) == 0:
         #We create an array full of 0s with a lentgth of n+1. n is the number of possible private keys that can
         #sign the transaction. This way we can place the signatures in the right order. We get rid of the unnecesarry
         #0s later.
         print(f"cmds is empty. Creating new set of commands")
         cmds = [0]*(n)
         #we also need to append at the end the serialized redeem script:
         cmds.append(redeem_script.serialize()[1:])
     der = private_key.sign(z).der()
     # append the SIGHASH_ALL to der (use SIGHASH_ALL.to_bytes(1, 'big'))
     sig = der + SIGHASH_ALL.to_bytes(1, 'big')
     #we add 1 to the index because of the OP_0 bug.
     cmds[privkey_index] = sig
     
     #commands.append(*redeem_script.cmds)
     print(f"sign_input_multisig commands: {cmds}")
     script_sig = Script(cmds)
     #script_sig = cmds
     # change input's script_sig to new script
     self.tx_ins[input_index].script_sig = script_sig
     # return whether sig is valid using self.verify_input
     #return self.verify_input(input_index)
     return True
Exemplo n.º 21
0
def add_channel(local_node, remote_peer, input_tx_id, input_tx_index):

    tx_in = TxIn(bytes.fromhex(input_tx_id), input_tx_index)
    local_amount = tx_in.value()
    remote_amount = 0

    # Construct the output: amount, scriptPubKey = 2-of-2 Bare Multisig  = Script([op_1, pubkey1, pubkey2, op_2, op_checkmultisig])
    scriptPubKey = Script([
        0x52,
        local_node.public_key.sec(),
        remote_peer.public_key.sec(), 0x52, 0xae
    ])
    tx_out = TxOut(amount=local_amount, script_pubkey=scriptPubKey)

    # Construct the transaction object
    funding_tx = Tx(1, [tx_in], [tx_out], 0, True)

    # Sign the input
    funding_tx.sign_input(0, local_node.private_key)

    #send channel request
    new_channel = Channel(remote_peer, local_amount, remote_amount, funding_tx)
    remote_peer.send(str.encode(new_channel.toJSON()))

    return new_channel
Exemplo n.º 22
0
 def test_exercise_4(self):
     prev_tx = bytes.fromhex(
         '75a1c4bc671f55f626dda1074c7725991e6f68b8fcefcfca7b64405ca3b45f1c')
     prev_index = 1
     target_address = 'miKegze5FQNCnGw6PKyqUbYUeBa4x2hFeM'
     target_amount = 0.01
     change_address = 'mzx5YhAH9kNHtcN481u6WkjeHjYtVeKVh2'
     change_amount = 0.009
     secret = 8675309
     priv = PrivateKey(secret=secret)
     tx_ins = []
     tx_ins.append(TxIn(prev_tx, prev_index, Script([]), 0xffffffff))
     tx_outs = []
     h160 = decode_base58(target_address)
     script_pubkey = p2pkh_script(h160)
     target_satoshis = int(target_amount * 100000000)
     tx_outs.append(TxOut(target_satoshis, script_pubkey))
     h160 = decode_base58(change_address)
     script_pubkey = p2pkh_script(h160)
     change_satoshis = int(change_amount * 100000000)
     tx_outs.append(TxOut(change_satoshis, script_pubkey))
     tx_obj = Tx(1, tx_ins, tx_outs, 0, testnet=True)
     self.assertTrue(tx_obj.sign_input(0, priv))
     self.assertTrue(tx_obj.verify())
     want = '01000000011c5fb4a35c40647bcacfeffcb8686f1e9925774c07a1dd26f6551f67bcc4a175010000006b483045022100a08ebb92422b3599a2d2fcdaa11f8f807a66ccf33e7f4a9ff0a3c51f1b1ec5dd02205ed21dfede5925362b8d9833e908646c54be7ac6664e31650159e8f69b6ca539012103935581e52c354cd2f484fe8ed83af7a3097005b2f9c60bff71d35bd795f54b67ffffffff0240420f00000000001976a9141ec51b3654c1f1d0f4929d11a1f702937eaf50c888ac9fbb0d00000000001976a914d52ad7ca9b3d096a38e752c2018e6fbc40cdf26f88ac00000000'
     self.assertEqual(tx_obj.serialize().hex(), want)
Exemplo n.º 23
0
    def test_sign_input(self):
        private_key = PrivateKey(secret=8675309)
        tx_ins = []
        prev_tx = bytes.fromhex(
            '0025bc3c0fa8b7eb55b9437fdbd016870d18e0df0ace7bc9864efc38414147c8')
        tx_ins.append(
            TxIn(
                prev_tx=prev_tx,
                prev_index=0,
                script_sig=Script([]),
                sequence=0xffffffff,
            ))
        tx_outs = []
        h160 = decode_base58('mzx5YhAH9kNHtcN481u6WkjeHjYtVeKVh2')
        tx_outs.append(
            TxOut(amount=int(0.99 * 100000000),
                  script_pubkey=p2pkh_script(h160)))
        h160 = decode_base58('mnrVtF8DWjMu839VW3rBfgYaAfKk8983Xf')
        tx_outs.append(
            TxOut(amount=int(0.1 * 100000000),
                  script_pubkey=p2pkh_script(h160)))

        tx = Tx(
            version=1,
            tx_ins=tx_ins,
            tx_outs=tx_outs,
            locktime=0,
            testnet=True,
        )
        self.assertTrue(tx.sign_input(0, private_key, SIGHASH_ALL))
Exemplo n.º 24
0
def clear(dir, start, end, mode):
    aS = Script(dir)
    if mode == "system":
        aS.s.nTask()
    else:
        aS.s.nScript()
    aS.s.allocm(1, 0, AnyType(16))
    aS.s.clearm(0)
    now = int(time() * 1e9)
    iS = now + int(start * 1e9)
    iE = now + int(end * 1e9)
    aS.s.immevl(1, AnyType(iS))
    aS.s.selfsc(1)
    aS.s.savevl(1, 0, AnyType(0))
    aS.s.immevl(1, AnyType(iE))
    aS.s.selfsc(1)
    aS.s.savevl(1, 0, AnyType(8))
    scriptCap = UUID(aS.cfg.keys["capWorkersClearer"]['k'])
    if mode == "system":
        aS.s.callsy(0, scriptCap)
    else:
        aS.s.selfst(0, 1)

    aS.s.ret()
    aS.s.test()
    aS.s.push()
Exemplo n.º 25
0
 def test_example_1(self):
     tx_ins = []
     prev_tx = bytes.fromhex(
         '8be2f69037de71e3bc856a6627ed3e222a7a2d0ce81daeeb54a3aea8db274149')
     prev_index = 4
     tx_ins.append(TxIn(prev_tx, prev_index))
     tx_outs = []
     h160 = decode_base58('mzx5YhAH9kNHtcN481u6WkjeHjYtVeKVh2')
     tx_outs.append(
         TxOut(
             amount=int(0.38 * 100000000),
             script_pubkey=p2pkh_script(h160),
         ))
     h160 = decode_base58('mnrVtF8DWjMu839VW3rBfgYaAfKk8983Xf')
     tx_outs.append(
         TxOut(
             amount=int(0.1 * 100000000),
             script_pubkey=p2pkh_script(h160),
         ))
     tx_obj = Tx(1, tx_ins, tx_outs, 0, testnet=True)
     z = tx_obj.sig_hash(0)
     pk = PrivateKey(secret=8675309)
     der = pk.sign(z).der()
     sig = der + SIGHASH_ALL.to_bytes(1, 'big')
     sec = pk.point.sec()
     tx_obj.tx_ins[0].script_sig = Script([sig, sec])
     want = '0100000001494127dba8aea354ebae1de80c2d7a2a223eed27666a85bce371de3790f6e28b040000006b483045022100fa3032607b50e8cb05bedc9d43f986f19dedc22e61320b9765061c5cd9c66946022072d514ef637988515bfa59a660596206de68f0ed4090d0a398e70f4d81370dfb012103935581e52c354cd2f484fe8ed83af7a3097005b2f9c60bff71d35bd795f54b67ffffffff0280d54302000000001976a914d52ad7ca9b3d096a38e752c2018e6fbc40cdf26f88ac80969800000000001976a914507b27411ccf7f16f10297de6cef3f291623eddf88ac00000000'
     self.assertEqual(tx_obj.serialize().hex(), want)
Exemplo n.º 26
0
    def init_variables(self):
        # Переменная времени
        self.clock = pygame.time.Clock()

        # Создание экземпляров классов
        self.menu = Menu(self.screen)
        self.script = Script(self.screen)
Exemplo n.º 27
0
 def sig_hash(self, input_index, hash_type):
     '''Returns the integer representation of the hash that needs to get
     signed for index input_index'''
     # create a new set of tx_ins (alt_tx_ins)
     alt_tx_ins = []
     # iterate over self.tx_ins
     for tx_in in self.tx_ins:
         # create a new TxIn that has a blank script_sig (b'') and add to alt_tx_ins
         alt_tx_ins.append(
             TxIn(
                 prev_tx=tx_in.prev_tx,
                 prev_index=tx_in.prev_index,
                 script_sig=Script([]),
                 sequence=tx_in.sequence,
             ))
     # grab the input at the input_index
     signing_input = alt_tx_ins[input_index]
     # grab the script_pubkey of the input
     script_pubkey = signing_input.script_pubkey(self.testnet)
     # the script_sig of the signing_input should be script_pubkey
     signing_input.script_sig = script_pubkey
     # create an alternate transaction with the modified tx_ins
     alt_tx = self.__class__(version=self.version,
                             tx_ins=alt_tx_ins,
                             tx_outs=self.tx_outs,
                             locktime=self.locktime)
     # add the hash_type int 4 bytes, little endian
     result = alt_tx.serialize() + int_to_little_endian(hash_type, 4)
     # get the double_sha256 of the tx serialization
     s256 = double_sha256(result)
     # convert this to a big-endian integer using int.from_bytes(x, 'big')
     return int.from_bytes(s256, 'big')
Exemplo n.º 28
0
 def parse_segwit(cls, s, version):
     '''Takes a byte stream and parses the segwit transaction in middle
     return a Tx object
     '''
     marker = s.read(1)
     if marker != b'\x01':
         raise RuntimeError('Not a segwit transaction {}'.format(marker))
     # num_inputs is a varint, use read_varint(s)
     num_inputs = read_varint(s)
     # each input needs parsing
     tx_ins = []
     for _ in range(num_inputs):
         tx_ins.append(TxIn.parse(s))
     # num_outputs is a varint, use read_varint(s)
     num_outputs = read_varint(s)
     # each output needs parsing
     tx_outs = []
     for _ in range(num_outputs):
         tx_outs.append(TxOut.parse(s))
     # now parse the witness program
     for tx_in in tx_ins:
         num_elements = read_varint(s)
         elements = [num_elements]
         for _ in range(num_elements):
             element_len = read_varint(s)
             elements.append(s.read(element_len))
         tx_in.witness_program = Script(elements).serialize()
     # locktime is 4 bytes, little-endian
     locktime = little_endian_to_int(s.read(4))
     # return an instance of the class (cls(...))
     return cls(version, tx_ins, tx_outs, locktime)
Exemplo n.º 29
0
def getScript():
    '''
    Store the JavaScript
    '''

    scriptTags = ScriptTag().getScriptTag()

    for link in Links().getContent():
        for scriptTag in scriptTags:
            headTag = scriptTag.replace('\n', '').split('|')[0]
            tailTag = scriptTag.replace('\n', '').split('|')[1]
            source = link.getPage()
            head = 0
            length = len(source)
            flag = True
            while ((flag) and (head < length)):
                flag = False
                pos1 = source[head:].find(headTag) + head
                pos2 = source[head:].find(tailTag) + head
                if (pos1 >= head) and (pos2 >= head):
                    flag = True
                    tempString = source[pos1:pos2 + 9]
                    tempString = tempString.replace('\t', '')
                    tempString = tempString.replace('\n', '')
                    tempString = tempString.replace(' ', '')
                    script = Script(tempString, link.getUrl())
                    Scripts().addText(script)
                    head = pos2 + 10

    pass
Exemplo n.º 30
0
 def sig_hash(self, índice_input, tipo_hash):
     '''Devuelve la representación entera del hash que debe ser
     firmado para índice índice_input'''
     # crea una nueva serie de tx_ins (alt_tx_ins)
     alt_tx_ins = []
     # itera sobre self.tx_ins
     for tx_in in self.tx_ins:
         # crea una nueva TxIn que tenga un script_sig en blanco (b'') y añádela a alt_tx_ins
         alt_tx_ins.append(TxIn(
             tx_previa=tx_in.tx_previa,
             índice_previo=tx_in.índice_previo,
             script_sig=Script([]),
             sequence=tx_in.sequence,
         ))
     # grab the input at the índice_input
     firmaring_input = alt_tx_ins[índice_input]
     # grab the script_pubkey of the input
     script_pubkey = firmaring_input.script_pubkey(self.testnet)
     # the script_sig of the firmaring_input should be script_pubkey
     firmaring_input.script_sig = script_pubkey
     # create an alternate transaction with the modified tx_ins
     alt_tx = self.__class__(
         versión=self.versión,
         tx_ins=alt_tx_ins,
         tx_outs=self.tx_outs,
         locktime=self.locktime)
     # añade el tipo_hash int 4 bytes, little endian
     res = alt_tx.serializar() + int_a_little_endian(tipo_hash, 4)
     # obtén el doble_sha256 de la serializacón de la tx
     s256 = doble_sha256(res)
     # convierte esto a big-endian entero usando int.from_bytes(x, 'big')
     return int.from_bytes(s256, 'big')