def sign_tx(self,
tx: payloads.Transaction,
password: str,
magic: Optional[int] = None) -> None:
"""
Helper function that signs the TX, adds the Witness and Sender
Args:
tx: transaction to sign
password: the password to decrypt the private key for signing
magic: the network magic
Raises:
ValueError: if transaction validation fails
"""
if magic is None:
magic = settings.network.magic
self._validate_tx(tx)
message = magic.to_bytes(4, byteorder="little",
signed=False) + tx.hash().to_array()
signature = self.sign(message, password)
invocation_script = vm.ScriptBuilder().emit_push(signature).to_array()
# mypy can't infer that the is_watchonly check ensures public_key has a value
verification_script = contracts.Contract.create_signature_redeemscript(
self.public_key) # type: ignore
tx.witnesses.insert(
0, payloads.Witness(invocation_script, verification_script))
def _serializable_init(cls):
return cls(0,
types.UInt256.zero(),
0,
0,
0,
types.UInt160.zero(),
payloads.Witness(b'', b''))
def test_contract_is_standard_fail3(self):
# test on witnesses of a transaction
engine = test_engine(has_container=True, has_snapshot=True)
witness = payloads.Witness(invocation_script=b'\x01',
verification_script=b'\x02')
engine.script_container.witnesses = [witness]
engine.push(vm.ByteStringStackItem(witness.script_hash().to_array()))
engine.invoke_syscall_by_name("System.Contract.IsStandard")
engine.execute()
self.assertEqual(False, engine.result_stack.pop().to_boolean())
def __init__(self,
version: int = 0,
prev_hash: types.UInt256 = None,
block_index: int = 0,
validator_index: int = 0,
data: bytes = None,
witness: payloads.Witness = None):
self.version = version
self.prev_hash = prev_hash if prev_hash else types.UInt256.zero()
self.block_index = block_index
self.validator_index = validator_index
self.data = data if data else b''
self.witness = witness if witness else payloads.Witness()
def _create_genesis_block() -> payloads.Block:
script = vm.ScriptBuilder().emit_syscall(
contracts.syscall_name_to_int("Neo.Native.Deploy")).to_array()
b = payloads.Block(
version=0,
prev_hash=types.UInt256.zero(),
timestamp=int(
datetime(2016, 7, 15, 15, 8, 21, 0, timezone.utc).timestamp() *
1000),
index=0,
next_consensus=Blockchain.get_consensus_address(
settings.standby_validators),
witness=payloads.Witness(
invocation_script=b'',
verification_script=b'\x11' # (OpCode.PUSH1)
),
consensus_data=payloads.ConsensusData(primary_index=0,
nonce=2083236893),
transactions=[
payloads.Transaction(
version=0,
script=script,
system_fee=0,
network_fee=0,
nonce=0,
valid_until_block=0,
signers=[
payloads.Signer(account=to_script_hash(b'\x11'),
scope=payloads.WitnessScope.FEE_ONLY)
],
witnesses=[
payloads.Witness(invocation_script=b'',
verification_script=b'\x11')
])
])
return b
def test_block(with_index=1) -> payloads.Block:
tx = test_tx(with_index)
header1 = payloads.Header(
version=0,
prev_hash=types.UInt256.from_string(
"f782c7fbb2eef6afe629b96c0d53fb525eda64ce5345057caf975ac3c2b9ae0a"
),
timestamp=123,
index=with_index,
primary_index=0,
next_consensus=types.UInt160.from_string(
"d7678dd97c000be3f33e9362e673101bac4ca654"),
witness=payloads.Witness(invocation_script=b'',
verification_script=b'\x55'))
block1 = payloads.Block(header1, transactions=[tx])
block1.rebuild_merkle_root()
return block1
def __init__(self,
version: int = 0,
prev_hash: types.UInt256 = None,
merkle_root: types.UInt256 = None,
timestamp: int = 0,
index: int = 0,
next_consensus: types.UInt160 = None,
witness: payloads.Witness = None
):
self.version = version
self.prev_hash = prev_hash if prev_hash else types.UInt256.zero()
self.merkle_root = merkle_root if merkle_root else types.UInt256.zero()
self.timestamp = timestamp
self.index = index
self.next_consensus = next_consensus if next_consensus else types.UInt160.zero()
self.witness = witness if witness else payloads.Witness()
def _create_genesis_block() -> payloads.Block:
h = payloads.Header(
version=0,
prev_hash=types.UInt256.zero(),
timestamp=int(
datetime(2016, 7, 15, 15, 8, 21, 0, timezone.utc).timestamp() *
1000),
index=0,
primary_index=0,
next_consensus=contracts.Contract.get_consensus_address(
settings.standby_validators),
witness=payloads.Witness(
invocation_script=b'',
verification_script=b'\x11' # (OpCode.PUSH1)
),
)
return payloads.Block(header=h, transactions=[])
def sign_multisig_tx(self,
tx: payloads.Transaction,
password: str,
context: wallet.MultiSigContext,
magic: Optional[int] = None) -> None:
if magic is None:
magic = settings.network.magic
if not self.contract:
raise ValueError("Account is not a valid multi-signature account")
# When importing a multi-sig account it searches for an associated regular account to copy key material from.
# However, it is possible to add a multi-sig account before having a regular account with one of the required
# public keys for the multi-sig account. Therefore, we should check if we actually have key material to continue
if self.is_watchonly:
_, _, public_keys = contracts.Contract.parse_as_multisig_contract(
self.contract.script)
raise ValueError(
f"Cannot sign with watch only account. Try adding a regular account to your wallet "
f"matching one of the following public keys, or update the key material for this account "
f"directly."
f" {list(map(lambda pk: str(pk), public_keys))}")
self._validate_tx(tx)
if not self.is_multisig:
raise ValueError("Account is not a valid multi-signature account")
if not context.initialised:
context.process_contract(self.contract.script)
if self.public_key not in context.expected_public_keys:
raise ValueError(
"Account is not in the required key list for this signing context"
)
message = magic.to_bytes(4, byteorder="little",
signed=False) + tx.hash().to_array()
signature = self.sign(message, password)
context.signature_pairs.update({self.public_key: signature})
if context.is_complete:
# build and insert multisig witness
sb = vm.ScriptBuilder()
pairs = list(context.signature_pairs.items())
# sort by public key
pairs.sort(key=lambda p: p[0])
for i, (key, sig) in enumerate(pairs):
if i == context.signing_threshold:
break
sb.emit_push(sig)
invocation_script = sb.to_array()
verification_script = contracts.Contract.create_multisig_redeemscript(
context.signing_threshold, context.expected_public_keys)
tx.witnesses.insert(
0, payloads.Witness(invocation_script, verification_script))
