def test_sort_public_key(self):
pub_keys = [acct1.get_public_key_bytes(), acct2.get_public_key_bytes(), acct3.get_public_key_bytes()]
builder = ProgramBuilder()
sort_pub_keys = builder.sort_public_keys(pub_keys)
self.assertEqual("023cab3b268c4f268456a972c672c276d23a9c3ca3dfcfc0004d786adbf1fb9282", sort_pub_keys[0].hex())
self.assertEqual("03d0fdb54acba3f81db3a6e16fa02e7ea3678bd205eb4ed2f1cfa8ab5e5d45633e", sort_pub_keys[1].hex())
self.assertEqual("02e8e84be09b87985e7f9dfa74298f6bb7f70f85515afca7e041fe964334e4b6c1", sort_pub_keys[2].hex())
def test_sort_public_key(self):
pub_keys = [acc.get_public_key(), acc2.get_public_key(), acc3.get_public_key()]
p = ProgramBuilder()
a = p.sort_publickeys(pub_keys)
self.assertEqual("03036c12be3726eb283d078dff481175e96224f0b0c632c7a37e10eb40fe6be889", a[0].hex())
self.assertEqual("020f9ce29ede5f0e271b67e61b2480dccc98c3aabad095c604ef9ab1d92a475c0a", a[1].hex())
self.assertEqual("035384561673e76c7e3003e705e4aa7aee67714c8b68d62dd1fb3221f48c5d3da0", a[2].hex())
def deserialize(reader: BinaryReader):
invocation_script = reader.read_var_bytes()
verification_script = reader.read_var_bytes()
sig = Sig()
sig.__sig_data = ProgramBuilder.get_param_info(invocation_script)
info = ProgramBuilder.get_program_info(verification_script)
sig.public_keys = info.pubkeys
sig.m = info.m
return sig
def test_aa(self):
pubkeys = [
acc.get_public_key(),
acc2.get_public_key(),
acc3.get_public_key()
]
p = ProgramBuilder()
a = p.sort_publickeys(pubkeys)
print(a[0].hex())
print(a[1].hex())
print(a[2].hex())
def serialize(self):
invoke_script = ProgramBuilder.program_from_params(self.sig_data)
if len(self.public_keys) == 0:
raise ValueError("np public key in sig")
verification_script = ProgramBuilder.program_from_pubkey(self.public_keys[0])
ms = StreamManager.GetStream()
writer = BinaryWriter(ms)
writer.WriteVarBytes(invoke_script)
writer.WriteVarBytes(verification_script)
ms.flush()
res = ms.ToArray()
res = bytes_reader(res)
StreamManager.ReleaseStream(ms)
return res
def add_multi_sign_transaction(tx: Transaction, m: int, pub_keys: list,
signer: Account):
"""
This interface is used to generate an Transaction object which has multi signature.
:param tx: a Transaction object which will be signed.
:param m: the amount of signer.
:param pub_keys: a list of public keys.
:param signer: an Account object which will sign the transaction.
:return: a Transaction object which has been signed.
"""
pub_keys = ProgramBuilder.sort_publickeys(pub_keys)
tx_hash = tx.hash256_bytes()
sig_data = signer.generate_signature(tx_hash,
signer.get_signature_scheme())
if tx.sigs is None or len(tx.sigs) == 0:
tx.sigs = []
elif len(tx.sigs) >= Common.TX_MAX_SIG_SIZE:
raise SDKException(
ErrorCode.param_err(
'the number of transaction signatures should not be over 16'
))
else:
for i in range(len(tx.sigs)):
if tx.sigs[i].public_keys == pub_keys:
if len(tx.sigs[i].sig_data) + 1 > len(pub_keys):
raise SDKException(
ErrorCode.param_err('too more sigData'))
if tx.sigs[i].M != m:
raise SDKException(ErrorCode.param_err('M error'))
tx.sigs[i].sig_data.append(sig_data)
return tx
sig = Sig(pub_keys, m, [sig_data])
tx.sigs.append(sig)
return tx
def add_multi_sign_transaction(self, m: int, pub_keys: List[bytes]
or List[str], signer: Account):
"""
This interface is used to generate an Transaction object which has multi signature.
"""
for index, pk in enumerate(pub_keys):
if isinstance(pk, str):
pub_keys[index] = pk.encode('ascii')
pub_keys = ProgramBuilder.sort_public_keys(pub_keys)
tx_hash = self.hash256()
sig_data = signer.generate_signature(tx_hash)
if self.sig_list is None or len(self.sig_list) == 0:
self.sig_list = []
elif len(self.sig_list) >= TX_MAX_SIG_SIZE:
raise SDKException(
ErrorCode.param_err(
'the number of transaction signatures should not be over 16'
))
else:
for i in range(len(self.sig_list)):
if self.sig_list[i].public_keys == pub_keys:
if len(self.sig_list[i].sig_data) + 1 > len(pub_keys):
raise SDKException(
ErrorCode.param_err('too more sigData'))
if self.sig_list[i].m != m:
raise SDKException(ErrorCode.param_err('M error'))
self.sig_list[i].sig_data.append(sig_data)
return
sig = Sig(pub_keys, m, [sig_data])
self.sig_list.append(sig)
def add_multi_sign_transaction(self, tx: Transaction, m: int, pubkeys: [],
signer: Account):
pubkeys = ProgramBuilder.sort_publickeys(pubkeys)
tx_hash = tx.hash256_bytes()
sig_data = signer.generate_signature(tx_hash,
signer.get_signature_scheme())
if tx.sigs is None or len(tx.sigs) == 0:
tx.sigs = []
elif len(tx.sigs) >= Common.TX_MAX_SIG_SIZE:
raise SDKException(
ErrorCode.param_err(
'the number of transaction signatures should not be over 16'
))
else:
for i in range(len(tx.sigs)):
if tx.sigs[i].public_keys == pubkeys:
if len(tx.sigs[i].sig_data) + 1 > len(pubkeys):
raise SDKException(
ErrorCode.param_err('too more sigData'))
if tx.sigs[i].M != m:
raise SDKException(ErrorCode.param_err('M error'))
tx.sigs[i].sig_data.append(sig_data)
return tx
sig = Sig(pubkeys, m, [sig_data])
tx.sigs.append(sig)
return tx
def serialize(self) -> bytes:
invoke_script = ProgramBuilder.program_from_params(self.__sig_data)
if len(self.public_keys) == 0:
raise SDKException(ErrorCode.other_error('Public key in sig is empty.'))
if len(self.public_keys) == 1:
verification_script = ProgramBuilder.program_from_pubkey(self.public_keys[0])
else:
verification_script = ProgramBuilder.program_from_multi_pubkey(self.m, self.public_keys)
ms = StreamManager.get_stream()
writer = BinaryWriter(ms)
writer.write_var_bytes(invoke_script)
writer.write_var_bytes(verification_script)
ms.flush()
res = ms.to_bytes()
res = bytes_reader(res)
StreamManager.release_stream(ms)
return res
def test_sort_public_keys(self):
pub_keys = [
'02035b015221686aef1054b02605da2c3958885670b8298d36706593d3c451fa7e',
'022b06295115ef825b8a17524815d77cd79a44c9c8980288e35bab542792425fc2',
'03616dbe28eb6f2efdebe6a7b8fd824a56cf3e2ea5e03f802e19e686cb347d986f',
'0364c210b769c73ffc2782c74beb881581148023e42562a53d6dd8273e26845901',
'0296b60945cdbe44e9c8cfbeef7f6e462cb638dc65a5424e364ab0304063043950',
'02a2d9e83c40303a3439db54e55052c0133cbbc61580f008197d2d9c03abc2a8ef',
'02f7ec18df95f869e475361923105b9511dd8491d06ec0072530c174783a837846'
]
pub_keys = ProgramBuilder.sort_public_keys(pub_keys)
self.assertEqual(7, len(pub_keys))
def from_multi_pub_keys(cls, m: int, pub_keys: List[bytes]):
return cls.__from_byte_script(
ProgramBuilder.program_from_multi_pubkey(m, pub_keys))
def address_from_multi_pub_keys(m: int, pub_keys: []):
return Address(Address.to_script_hash(ProgramBuilder.program_from_multi_pubkey(m, pub_keys)))
def b58_address_from_multi_pub_keys(m: int, pub_keys: List[bytes]):
return Address(
Address.to_script_hash(
ProgramBuilder.program_from_multi_pubkey(
m, pub_keys))).b58encode()
