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 sign_transaction(self, tx: Transaction, signer: Account):
tx_hash = tx.hash256()
sig_data = signer.generate_signature(tx_hash,
signer.get_signature_scheme())
sig = [Sig([signer.get_public_key()], 1, [sig_data])]
tx.sigs = 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 test_generate_signature(self):
raw_hex_data = '523c5fcf74823831756f0bcb3634234f10b3beb1c05595058534577752ad2d9f'
account = Account(raw_hex_data, SignatureScheme.SHA256withECDSA)
msg = 'test'.encode('utf-8')
signature = account.generate_signature(msg)
result = account.verify_signature(msg, signature)
self.assertEqual(True, result)
def sign_transaction(self, signer: Account):
"""
This interface is used to sign the transaction.
"""
tx_hash = self.hash256()
sig_data = signer.generate_signature(tx_hash)
sig = [Sig([signer.get_public_key_bytes()], 1, [sig_data])]
self.sig_list = sig
def test_signature(self):
for strength in self.strengths:
master_key = HDPrivateKey.master_key_from_mnemonic(
self.mnemonic.generate(strength))
acct = Account(master_key.hex())
signature = acct.generate_signature(self.msg)
self.assertTrue(acct.verify_signature(self.msg, signature))
root_sk = HDPrivateKey.from_path(master_key)[-1]
root_pk = root_sk.public_key
bip32_root_pk = root_pk.b58encode()
for index in range(10):
child_sk = HDPrivateKey.from_path(root_sk, f'0/{index}')[-1]
child_pk = HDPublicKey.from_path(
HDPublicKey.b58decode(bip32_root_pk), f'0/{index}')[-1]
child_acct = Account(child_sk.hex())
signature = child_acct.generate_signature(self.msg)
handler = SignatureHandler(SignatureScheme.SHA256withECDSA)
handler.verify_signature(child_pk.hex(), self.msg, signature)
def sign_transaction(self, signer: Account):
"""
This interface is used to sign the transaction.
:param signer: an Account object which will sign the transaction.
:return: a Transaction object which has been signed.
"""
tx_hash = self.hash256()
sig_data = signer.generate_signature(tx_hash)
sig = [Sig([signer.get_public_key_bytes()], 1, [sig_data])]
self.sig_list = sig
def add_sign_transaction(self, tx: Transaction, signer: Account):
if tx.sigs == None or len(tx.sigs) == 0:
tx.sigs = []
elif len(tx.sigs) >= Common.TX_MAX_SIG_SIZE:
raise Exception(
"the number of transaction signatures should not be over 16")
tx_hash = tx.hash256()
sig_data = signer.generate_signature(tx_hash,
signer.get_signature_scheme())
sig = Sig([signer.serialize_public_key()], 1, [sig_data])
tx.sigs.append(sig)
return tx
def generate_signature(self, iss: Account, verify_kid: bool = True):
if not isinstance(self.__head, Header) or not isinstance(self.__payload, Payload):
raise SDKException(ErrorCode.other_error('Please set claim parameters first.'))
if verify_kid:
key_index = int(self.__head.kid.split('-')[1])
result = self.__sdk.native_vm.ont_id().verify_signature(iss.get_ont_id(), key_index, iss)
if not result:
raise SDKException(ErrorCode.other_error('Issuer account error.'))
b64_head = self.__head.to_base64()
b64_payload = self.__payload.to_base64()
msg = f'{b64_head}.{b64_payload}'.encode('utf-8')
self.__signature = iss.generate_signature(msg)
return self.__signature
def test_generateSignature(self):
acc = Account(
"75de8489fcb2dcaf2ef3cd607feffde18789de7da129b5e97c81e001793cb7cf")
sigaa = "01cf157a48216bfcd455a97a39c0ad65bd1b27d1da07965b19848146045c9f2e5a12f905a5ee0923412d589e615a5d6954c58cade367dce67fcf13eaa82c12e87a"
byte_signature = acc.generate_signature(
"sss".encode(), SignatureScheme.SHA256withECDSA)
handler = SignatureHandler(KeyType.ECDSA,
SignatureScheme.SHA256withECDSA)
res = handler.verify_signature(acc.serialize_public_key(),
"sss".encode(),
bytearray.fromhex(sigaa))
self.assertTrue(res)
def sign_transaction(tx: Transaction, signer: Account) -> Transaction:
"""
This interface is used to sign the transaction.
:param tx: a Transaction object which will be signed.
:param signer: an Account object which will sign the transaction.
:return: a Transaction object which has been signed.
"""
tx_hash = tx.hash256_bytes()
sig_data = signer.generate_signature(tx_hash,
signer.get_signature_scheme())
sig = [Sig([signer.get_public_key_bytes()], 1, [sig_data])]
tx.sigs = sig
return tx
def add_sign_transaction(self, signer: Account):
"""
This interface is used to add signature into the transaction.
"""
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'
))
tx_hash = self.hash256()
sig_data = signer.generate_signature(tx_hash)
sig = Sig([signer.get_public_key_bytes()], 1, [sig_data])
self.sig_list.append(sig)
def add_sign_transaction(tx: Transaction, signer: Account):
"""
This interface is used to add signature into the transaction.
:param tx: a Transaction object which will be signed.
:param signer: an Account object which will sign the transaction.
:return: a Transaction object which has been signed.
"""
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'
))
tx_hash = tx.hash256_bytes()
sig_data = signer.generate_signature(tx_hash,
signer.get_signature_scheme())
sig = Sig([signer.serialize_public_key()], 1, [sig_data])
tx.sigs.append(sig)
return tx
def test_generate_signature(self):
raw_hex_data = "523c5fcf74823831756f0bcb3634234f10b3beb1c05595058534577752ad2d9f"
account = Account(raw_hex_data, SignatureScheme.SHA256withECDSA)
data = account.generate_signature(bytes("test".encode()),
SignatureScheme.SHA256withECDSA)
def signature_data(self, acct: Account, data: bytearray or bytes):
return acct.generate_signature(data, acct.get_signature_scheme())
