def sign(self, key): """Sets the signature for this block. Args: key (bytes): Private key to be used to sign. """ self.signature = sign(self.hash, key)
def confirm(self, index, key): """Adds a confirmation signature for this transaction. Args: index (int): Index of the input owner by the signer. key (bytes): Private key to be used to sign. """ self.confirmations[index] = sign(self.confirmation_hash, key)
def register(self, sender, privateKey): msg = "hi" messageHash = sha3(msg) sig = sign(messageHash, privateKey) self.root_chain.register(messageHash, sig, transact={ 'from': sender, 'gas': 40000000 })
def test_signature_scheme_respects_verifying_contract(testlang, utxo): alice = testlang.accounts[0] outputs = [(alice.address, NULL_ADDRESS, 50)] spend_id = testlang.spend_utxo([utxo.spend_id], [alice.key], outputs) testlang.start_standard_exit(spend_id, alice.key) exit_id = testlang.get_standard_exit_id(spend_id) spend_tx = Transaction(inputs=[decode_utxo_id(spend_id)], outputs=outputs) bad_contract_signature = sign(hash_struct(spend_tx, verifyingContract=None), alice.key) # challenge will fail on signature verification with pytest.raises(TransactionFailed): testlang.root_chain.challengeStandardExit(exit_id, spend_tx.encoded, 0, bad_contract_signature) # sanity check proper_signature = sign(hash_struct(spend_tx, verifyingContract=testlang.root_chain), alice.key) testlang.root_chain.challengeStandardExit(exit_id, spend_tx.encoded, 0, proper_signature)
def test_old_signature_scheme_does_not_work_any_longer(testlang, utxo): # In this test I will challenge standard exit with old signature schema to show it no longer works # Then passing new signature to the same challenge data, challenge will succeed alice = testlang.accounts[0] outputs = [(alice.address, NULL_ADDRESS, 50)] spend_id = testlang.spend_utxo([utxo.spend_id], [alice.key], outputs) testlang.start_standard_exit(spend_id, alice.key) exit_id = testlang.get_standard_exit_id(spend_id) # let's prepare old schema signature for a transaction with an input of exited utxo spend_tx = Transaction(inputs=[decode_utxo_id(spend_id)], outputs=outputs) old_signature = sign(spend_tx.hash, alice.key) # challenge will fail on signature verification with pytest.raises(TransactionFailed): testlang.root_chain.challengeStandardExit(exit_id, spend_tx.encoded, 0, old_signature) # sanity check: let's provide new schema signature for a challenge new_signature = sign(hash_struct(spend_tx, verifyingContract=testlang.root_chain), alice.key) testlang.root_chain.challengeStandardExit(exit_id, spend_tx.encoded, 0, new_signature)
def confirm_spend(self, tx_id, signer): """Signs a confirmation signature for a spend. Args: tx_id (int): Identifier of the transaction. signer (EthereumAccount): Account to sign this confirmation. """ spend_tx = self.child_chain.get_transaction(tx_id) (blknum, _, _) = decode_utxo_id(tx_id) block = self.child_chain.blocks[blknum] confirmation_hash = sha3(spend_tx.hash + block.root) self.confirmations[tx_id] = sign(confirmation_hash, signer.key)
def sign(self, key): self.sig = sign(self.hash, key)
def sign2(self, key): self.sig2 = sign(self.hash, key)
def sign1(self, key): self.sig1 = sign(self.hash, key)
def confirm(self, root, key): return sign(utils.sha3(self.hash + root), key)
def sign(self, index, key): self.signatures[index] = sign(self.hash, key)
def sign(self, key): return SignedBlock(self, sign(self.hash, key))
def sign(self, index, key, verifyingContract=None): hash = hash_struct(self, verifyingContract=verifyingContract) sig = sign(hash, key) self.signatures[index] = sig self._signers[index] = get_signer(hash, sig) if sig != NULL_SIGNATURE else NULL_ADDRESS
def confirm_tx(tx, root, key): return sign(u.sha3(tx.hash + root), key)
def test_signature(t, block): block.sign(t.k0) assert block.sig == sign(block.hash, t.k0) assert block.signer == get_signer(block.hash, sign(block.hash, t.k0))
def sign(self, key): self.signature = sign(self.hash, key)