class OntologySdk(object): _instance_lock = threading.Lock() def __init__(self): self.rpc = RpcClient() self.wallet_manager = WalletManager() self.__native_vm = None self.__neo_vm = None self.defaultSignScheme = SignatureScheme.SHA256withECDSA def __new__(cls, *args, **kwargs): if not hasattr(OntologySdk, "_instance"): with OntologySdk._instance_lock: if not hasattr(OntologySdk, "_instance"): OntologySdk._instance = object.__new__(cls) return OntologySdk._instance def native_vm(self): if self.__native_vm is None: self.__native_vm = NativeVm(OntologySdk._instance) return self.__native_vm def neo_vm(self): if self.__neo_vm is None: self.__neo_vm = NeoVm(OntologySdk._instance) return self.__neo_vm def get_wallet_manager(self): if self.wallet_manager is None: self.wallet_manager = WalletManager() return self.wallet_manager def set_rpc(self, rpc_addr: str): self.rpc.set_address(rpc_addr) def get_rpc(self): if self.rpc is None: self.rpc = RpcClient() return self.rpc def set_signature_scheme(self, scheme: SignatureScheme): self.defaultSignScheme = scheme self.wallet_manager.set_signature_scheme(scheme) @staticmethod 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 @staticmethod 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 @staticmethod 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 signature_data(self, acct: Account, data: bytearray or bytes): return acct.generate_signature(data, acct.get_signature_scheme()) def verify_signature(self, public_key: bytearray, data: bytearray, signature: bytearray): key_type = KeyType.ECDSA if len(public_key) == 33: key_type = KeyType.ECDSA elif len(public_key) == 35: key_type = KeyType.from_label(public_key[0]) handler = SignatureHandler(key_type, SignatureScheme.SHA256withECDSA) if key_type == KeyType.ECDSA: handler = SignatureHandler(key_type, SignatureScheme.SHA256withECDSA) elif key_type == KeyType.SM2: handler = SignatureHandler(key_type, SignatureScheme.SM3withSM2) else: raise Exception("unsupport key type") return handler.verify_signature(public_key, data, signature) def open_wallet(self, wallet_file): return self.wallet_manager.open_wallet(wallet_file)
class OntologySdk(metaclass=_Singleton): def __init__(self, rpc_address: str = '', restful_address: str = '', ws_address: str = '', sig_svr_address='', default_signature_scheme: SignatureScheme = SignatureScheme. SHA256withECDSA): if not isinstance(default_signature_scheme, SignatureScheme): raise SDKException( ErrorCode.param_err('SignatureScheme object is required.')) self.__rpc = RpcClient(rpc_address) self.__restful = RestfulClient(restful_address) self.__websocket = WebsocketClient(ws_address) self.__native_vm = NativeVm(self) self.__neo_vm = NeoVm(self) self.__service = Service(self) self.__wallet_manager = WalletManager() self.__default_signature_scheme = default_signature_scheme def get_network(self) -> RpcClient or RestfulClient: if self.__rpc.get_address() != '': return self.__rpc elif self.__restful.get_address() != '': return self.__restful else: raise SDKException( ErrorCode.other_error('Invalid network instance.')) @property def wallet_manager(self): if self.__wallet_manager is None: self.__wallet_manager = WalletManager() return self.__wallet_manager @wallet_manager.setter def wallet_manager(self, wallet_manager: WalletManager): if isinstance(self.wallet_manager, WalletManager): self.__wallet_manager = wallet_manager else: raise SDKException( ErrorCode.other_error('Invalid WalletManager instance')) @property def default_signature_scheme(self): if self.__default_signature_scheme is None: self.__default_signature_scheme = SignatureScheme.SHA256withECDSA return self.__default_signature_scheme @default_signature_scheme.setter def default_signature_scheme(self, scheme: SignatureScheme): if isinstance(scheme, SignatureScheme): self.__default_signature_scheme = scheme self.__wallet_manager.set_signature_scheme(scheme) else: raise SDKException( ErrorCode.other_error('Invalid signature scheme')) @property def rpc(self) -> RpcClient: return self.__rpc @rpc.setter def rpc(self, rpc_client: RpcClient): if isinstance(rpc_client, RpcClient): self.__rpc = rpc_client @property def restful(self) -> RestfulClient: return self.__restful @restful.setter def restful(self, restful_client: RestfulClient): if isinstance(restful_client, RestfulClient): self.__restful = restful_client @property def websocket(self) -> WebsocketClient: return self.__websocket @websocket.setter def websocket(self, websocket_client: WebsocketClient): if isinstance(websocket_client, WebsocketClient): self.__websocket = websocket_client @property def native_vm(self): return self.__native_vm @property def neo_vm(self): return self.__neo_vm @property def service(self): return self.__service def set_rpc_address(self, rpc_address: str): if isinstance(self.__rpc, RpcClient): self.__rpc.set_address(rpc_address) else: self.__rpc = RpcClient(rpc_address) def get_rpc_address(self): if self.__rpc is None: return '' return self.__rpc.get_address() @staticmethod def get_random_test_rpc_address(): return choice(TEST_RPC_ADDRESS) @staticmethod def get_random_main_rpc_address(): return choice(MAIN_RPC_ADDRESS) def set_restful_address(self, restful_address: str): if isinstance(self.__restful, RestfulClient): self.__restful.set_address(restful_address) else: self.__restful = RestfulClient(restful_address) def get_restful_address(self): if not isinstance(self.__restful, RestfulClient): return '' return self.__restful.get_address() @staticmethod def get_random_test_restful_address(): choice(TEST_RESTFUL_ADDRESS) @staticmethod def get_random_main_restful_address(): return choice(MAIN_RESTFUL_ADDRESS) @staticmethod def get_test_net_restful_address_list(): return TEST_RESTFUL_ADDRESS @staticmethod def get_main_net_restful_address_list(): return MAIN_RESTFUL_ADDRESS def set_websocket_address(self, websocket_address: str): if isinstance(self.__websocket, WebsocketClient): self.__websocket.set_address(websocket_address) else: self.__websocket = WebsocketClient(websocket_address) def get_websocket_address(self): if not isinstance(self.__websocket, WebsocketClient): return '' return self.__websocket.get_address()
class OntologySdk(object): _instance_lock = threading.Lock() def __init__(self): self.rpc = RpcClient() self.wallet_manager = WalletManager() self.__native_vm = None self.defaultSignScheme = SignatureScheme.SHA256withECDSA def __new__(cls, *args, **kwargs): if not hasattr(OntologySdk, "_instance"): with OntologySdk._instance_lock: if not hasattr(OntologySdk, "_instance"): OntologySdk._instance = object.__new__(cls) return OntologySdk._instance def native_vm(self): if self.__native_vm is None: self.__native_vm = NativeVm(OntologySdk()) return self.__native_vm def get_wallet_manager(self): if self.wallet_manager is None: self.wallet_manager = WalletManager() return self.wallet_manager def get_rpc(self): if self.rpc is None: self.rpc = RpcClient() return self.rpc def set_signaturescheme(self, scheme: SignatureScheme): self.defaultSignScheme = scheme self.wallet_manager.set_signature_scheme(scheme) 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_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 add_multi_sign_transaction(self, tx: Transaction, m: int, pubkeys: [], signer: Account): pubkeys = ProgramBuilder.sort_publickeys(pubkeys) tx_hash = tx.hash256() sig_data = signer.generate_signature(tx_hash, signer.get_signature_scheme()) 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") else: for i in range(len(tx.sigs)): if tx.sigs[i].public_keys == pubkeys: print(type(tx.sigs[i].sig_data)) if len(tx.sigs[i].sig_data) + 1 > len(pubkeys): raise Exception("too more sigData") if tx.sigs[i].M != m: raise Exception("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 open_wallet(self, wallet_file): return self.wallet_manager.open_wallet(wallet_file)
class Ontology(AioRunner, metaclass=_Singleton): def __init__(self, rpc_address: str = '', restful_address: str = '', ws_address: str = '', default_signature_scheme: SignatureScheme = SignatureScheme. SHA256withECDSA): if not isinstance(default_signature_scheme, SignatureScheme): raise SDKException( ErrorCode.param_err('SignatureScheme object is required.')) self.__rpc = Rpc(rpc_address) self.__aio_rpc = AioRpc(rpc_address) self.__restful = Restful(restful_address) self.__aio_restful = AioRestful(restful_address) self.__websocket = Websocket(ws_address) self.__default_network = self.__rpc self.__default_aio_network = self.__aio_rpc self.__native_vm = NativeVm(self) self.__neo_vm = NeoVm(self) self.__wasm_vm = WasmVm(self) self.__service = Service(self) self.__wallet_manager = WalletManager() self.__default_signature_scheme = default_signature_scheme @property def default_network(self): return self.__default_network @default_network.setter def default_network(self, network: Union[Rpc, Restful]): self.__default_network = network @property def default_aio_network(self): return self.__default_aio_network @default_aio_network.setter def default_aio_network(self, network: Union[AioRpc, AioRestful, Websocket]): self.__default_aio_network = network @property def wallet_manager(self): if self.__wallet_manager is None: self.__wallet_manager = WalletManager() return self.__wallet_manager @wallet_manager.setter def wallet_manager(self, wallet_manager: WalletManager): if isinstance(self.wallet_manager, WalletManager): self.__wallet_manager = wallet_manager else: raise SDKException( ErrorCode.other_error('Invalid WalletManager instance')) @property def default_signature_scheme(self): if self.__default_signature_scheme is None: self.__default_signature_scheme = SignatureScheme.SHA256withECDSA return self.__default_signature_scheme @default_signature_scheme.setter def default_signature_scheme(self, scheme: SignatureScheme): if isinstance(scheme, SignatureScheme): self.__default_signature_scheme = scheme self.__wallet_manager.set_signature_scheme(scheme) else: raise SDKException( ErrorCode.other_error('Invalid signature scheme')) @property def rpc(self) -> Rpc: return self.__rpc @rpc.setter def rpc(self, rpc_client: Rpc): if isinstance(rpc_client, Rpc): self.__rpc = rpc_client @property def aio_rpc(self) -> AioRpc: return self.__aio_rpc @aio_rpc.setter def aio_rpc(self, aio_rpc: AioRpc): if isinstance(aio_rpc, AioRpc): self.__rpc = aio_rpc @property def restful(self) -> Restful: return self.__restful @restful.setter def restful(self, restful_client: Restful): if isinstance(restful_client, Restful): self.__restful = restful_client @property def aio_restful(self) -> AioRestful: return self.__aio_restful @restful.setter def restful(self, aio_restful: AioRestful): if isinstance(aio_restful, AioRestful): self.__aio_restful = aio_restful @property def websocket(self) -> Websocket: return self.__websocket @websocket.setter def websocket(self, websocket_client: Websocket): if isinstance(websocket_client, Websocket): self.__websocket = websocket_client @property def rpc_address(self): if self.__rpc is None: return '' return self.__rpc.get_address() @rpc_address.setter def rpc_address(self, rpc_address: str): if isinstance(self.__rpc, Rpc): self.__rpc.set_address(rpc_address) else: self.__rpc = Rpc(rpc_address) @property def restful_address(self): if not isinstance(self.__restful, Restful): return '' return self.__restful.get_address() @restful_address.setter def restful_address(self, restful_address: str): if isinstance(self.__restful, Restful): self.__restful.set_address(restful_address) else: self.__restful = Restful(restful_address) @property def websocket_address(self) -> str: if not isinstance(self.__websocket, Websocket): return '' return self.__websocket.get_address() @websocket_address.setter def websocket_address(self, websocket_address: str): if isinstance(self.__websocket, Websocket): self.__websocket.set_address(websocket_address) else: self.__websocket = Websocket(websocket_address) @property def native_vm(self): return self.__native_vm @property def neo_vm(self): return self.__neo_vm @property def wasm_vm(self): return self.__wasm_vm @property def service(self): return self.__service @staticmethod def get_random_test_rpc_address(): return choice(TEST_RPC_ADDRESS) @staticmethod def get_random_main_rpc_address(): return choice(MAIN_RPC_ADDRESS) @staticmethod def get_random_test_restful_address(): choice(TEST_RESTFUL_ADDRESS) @staticmethod def get_random_main_restful_address(): return choice(MAIN_RESTFUL_ADDRESS) @staticmethod def get_test_net_restful_address_list(): return TEST_RESTFUL_ADDRESS @staticmethod def get_main_net_restful_address_list(): return MAIN_RESTFUL_ADDRESS