oli-python 0.1.0__py3-none-any.whl

oli/__init__.py

@@ -0,0 +1,4 @@
+from oli.core import OLI
+
+__version__ = "0.1.0"
+__all__ = ["OLI"]

oli/attestation/__init__.py

@@ -0,0 +1,11 @@
+from oli.attestation.onchain import OnchainAttestations
+from oli.attestation.offchain import OffchainAttestations
+from oli.attestation.utils_validator import UtilsValidator
+from oli.attestation.utils_other import UtilsOther
+
+__all__ = [
+    "OnchainAttestations",
+    "OffchainAttestations",
+    "UtilsValidator",
+    "UtilsOther"
+]

oli/attestation/offchain.py

@@ -0,0 +1,273 @@
+import time
+import requests
+import secrets
+import json
+from requests import Response
+
+class OffchainAttestations:
+    def __init__(self, oli_client):
+        """
+        Initialize OffchainAttestations with an OLI client.
+        
+        Args:
+            oli_client: The OLI client instance
+        """
+        self.oli = oli_client
+    
+    def create_offchain_label(self, address: str, chain_id: str, tags: dict, ref_uid: str="0x0000000000000000000000000000000000000000000000000000000000000000", retry: int=4):
+        """
+        Create an offchain OLI label attestation for a contract.
+        
+        Args:
+            address (str): The contract address to label
+            chain_id (str): Chain ID in CAIP-2 format where the address/contract resides
+            tags (dict): OLI compliant tags as a dict  information (name, version, etc.)
+            ref_uid (str): Reference UID
+            retry (int): Number of retries for the API post request to EAS ipfs
+            
+        Returns:
+            dict: API request response
+        """
+        # fix simple formatting errors in tags
+        tags = self.oli.validator.fix_simple_tags_formatting(tags)
+
+        # Check all necessary input parameters
+        self.oli.validator.check_label_correctness(address, chain_id, tags, ref_uid, auto_fix=False)
+        
+        # Encode the label data
+        data = self.oli.utils_other.encode_label_data(chain_id, tags)
+        
+        # Build the attestation
+        attestation = self.build_offchain_attestation(
+            recipient=address, 
+            schema=self.oli.oli_label_pool_schema, 
+            data=data, 
+            ref_uid=ref_uid
+        )
+        
+        # Post to the API & retry if status code is not 200
+        response = self.post_offchain_attestation(attestation)
+        n0 = retry
+        while response.status_code != 200 and retry > 0:
+            retry -= 1
+            time.sleep(2 ** (n0 - retry)) # exponential backoff
+            response = self.post_offchain_attestation(attestation)
+        
+        # if it fails after all retries, raise an error
+        if response.status_code != 200:
+            raise Exception(f"Failed to submit offchain attestation to EAS API ipfs post endpoint after {n0} retries: {response.status_code} - {response.text}")
+
+        return response
+    
+    def post_offchain_attestation(self, attestation: dict, filename: str="OLI.txt") -> Response:
+        """
+        Post API an attestation to the EAS API.
+        
+        Args:
+            attestation (dict): The attestation package
+            filename (str): Custom filename
+            
+        Returns:
+            dict: API response
+        """
+        # Convert numerical values to strings for JSON serialization
+        attestation["sig"]["message"]["time"] = str(attestation["sig"]["message"]["time"])
+        attestation["sig"]["message"]["expirationTime"] = str(attestation["sig"]["message"]["expirationTime"])
+        attestation["sig"]["domain"]["chainId"] = str(attestation["sig"]["domain"]["chainId"])
+        
+        # Prepare payload for the API endpoint
+        payload = {
+            "filename": filename,
+            "textJson": json.dumps(attestation, separators=(',', ':'))
+        }
+        
+        headers = {
+            "Content-Type": "application/json"
+        }
+        
+        # Post the data to the API
+        response = requests.post(self.oli.eas_api_url, json=payload, headers=headers)
+        return response
+    
+    def build_offchain_attestation(self, recipient: str, schema: str, data: str, ref_uid: str, revocable: bool=True, expiration_time: int=0) -> dict:
+        """
+        Build an offchain attestation with the given parameters.
+        
+        Args:
+            recipient (str): Ethereum address of the contract to be labeled
+            schema (str): Schema hash
+            data (str): Hex-encoded data
+            ref_uid (str): Reference UID
+            revocable (bool): Whether the attestation is revocable
+            expiration_time (int): Expiration time in seconds since epoch
+            
+        Returns:
+            dict: The signed attestation and UID
+        """
+        # Create a random salt
+        salt = f"0x{secrets.token_hex(32)}"
+        
+        # Current time in seconds
+        current_time = int(time.time())
+        
+        # Typed data for the attestation
+        typed_data = {
+            "version": 2,
+            "recipient": recipient,
+            "time": current_time,
+            "revocable": revocable,
+            "schema": schema,
+            "refUID": ref_uid,
+            "data": data,
+            "expirationTime": expiration_time,
+            "salt": salt,
+        }
+        
+        # EIP-712 typed data format
+        types = {
+            "domain": {
+                "name": "EAS Attestation",
+                "version": "1.2.0",
+                "chainId": self.oli.rpc_chain_number,
+                "verifyingContract": self.oli.eas_address
+            },
+            "primaryType": "Attest",
+            "message": typed_data,
+            "types": {
+                "Attest": [
+                    {"name": "version", "type": "uint16"},
+                    {"name": "schema", "type": "bytes32"},
+                    {"name": "recipient", "type": "address"},
+                    {"name": "time", "type": "uint64"},
+                    {"name": "expirationTime", "type": "uint64"},
+                    {"name": "revocable", "type": "bool"},
+                    {"name": "refUID", "type": "bytes32"},
+                    {"name": "data", "type": "bytes"},
+                    {"name": "salt", "type": "bytes32"}
+                ]
+            }
+        }
+
+        # Sign the message using the account
+        signed_message = self.oli.account.sign_typed_data(
+            domain_data=types["domain"],
+            message_types=types["types"],
+            message_data=typed_data
+        )
+        
+        # Calculate the UID
+        attester = '0x0000000000000000000000000000000000000000'  # for offchain UID calculation
+        uid = self.oli.utils_other.calculate_attestation_uid_v2(
+            schema, recipient, attester, current_time, data, 
+            expiration_time, revocable, ref_uid, salt=salt
+        )
+        uid_hex = '0x' + uid.hex()
+        
+        # Package the result
+        result = {
+            "sig": {
+                "domain": types["domain"],
+                "primaryType": types["primaryType"],
+                "types": types["types"],
+                "message": typed_data,
+                "uid": uid_hex,
+                "version": 2,
+                "signature": {
+                    "r": hex(signed_message.r),
+                    "s": hex(signed_message.s),
+                    "v": signed_message.v
+                }
+            },
+            "signer": self.oli.address
+        }
+        
+        return result
+    
+    def revoke_attestation(self, uid_hex: str, gas_limit: int=200000):
+        """
+        Revoke an offchain attestation using its UID.
+        
+        Args:
+            uid_hex (str): UID of the attestation to revoke (in hex format)
+            gas_limit (int): Gas limit for the transaction. If not set, defaults to 200000. Gas estimation is not possible for revoke transactions.
+            
+        Returns:
+            str: Transaction hash
+        """
+        function = self.oli.eas.functions.revokeOffchain(self.oli.w3.to_bytes(hexstr=uid_hex))
+
+        # Define the transaction parameters
+        tx_params = {
+            'chainId': self.oli.rpc_chain_number,
+            'gasPrice': self.oli.w3.eth.gas_price,
+            'nonce': self.oli.w3.eth.get_transaction_count(self.oli.address),
+        }
+
+        # Estimate gas if no limit provided
+        tx_params = self.oli.utils_other.estimate_gas_limit(function, tx_params, gas_limit)
+
+        # Build the transaction to revoke an attestation
+        transaction = function.build_transaction(tx_params)
+
+        # Sign the transaction
+        signed_txn = self.oli.w3.eth.account.sign_transaction(transaction, private_key=self.oli.private_key)
+
+        # Send the transaction
+        try:
+            txn_hash = self.oli.w3.eth.send_raw_transaction(signed_txn.raw_transaction)
+        except Exception as e:
+            raise Exception(f"Failed to send revoke transaction to mempool: {e}")
+
+        # Get the transaction receipt
+        txn_receipt = self.oli.w3.eth.wait_for_transaction_receipt(txn_hash)
+        
+        # Check if the transaction was successful
+        if txn_receipt.status == 1:
+            return f"0x{txn_hash.hex()}"
+        else:
+            raise Exception(f"Transaction failed: {txn_receipt}")
+    
+    def multi_revoke_attestations(self, uids: str, gas_limit: int=10000000):
+        """
+        Revoke multiple offchain attestations in a single transaction.
+        
+        Args:
+            uids (list): List of UIDs to revoke (in hex format)
+            gas_limit (int): Gas limit for the transaction. If not set, defaults to 10000000. Gas estimation is not possible for revoke transactions.
+            
+        Returns:
+            str: Transaction hash
+            int: Number of attestations revoked
+        """
+        revocation_data = []
+        for uid in uids:
+            revocation_data.append(self.oli.w3.to_bytes(hexstr=uid))
+        function = self.oli.eas.functions.multiRevokeOffchain(revocation_data)
+
+        # Define the transaction parameters
+        tx_params = {
+            'chainId': self.oli.rpc_chain_number,
+            'gasPrice': self.oli.w3.eth.gas_price,
+            'nonce': self.oli.w3.eth.get_transaction_count(self.oli.address),
+        }
+
+        # Estimate gas if no limit provided
+        tx_params = self.oli.utils_other.estimate_gas_limit(function, tx_params, gas_limit)
+
+        # Build the transaction
+        transaction = function.build_transaction(tx_params)
+
+        # Sign the transaction
+        signed_txn = self.oli.w3.eth.account.sign_transaction(transaction, private_key=self.oli.private_key)
+
+        # Send the transaction
+        txn_hash = self.oli.w3.eth.send_raw_transaction(signed_txn.raw_transaction)
+
+        # Get the transaction receipt
+        txn_receipt = self.oli.w3.eth.wait_for_transaction_receipt(txn_hash)
+        
+        # Check if the transaction was successful
+        if txn_receipt.status == 1:
+            return f"0x{txn_hash.hex()}", len(uids)
+        else:
+            raise Exception(f"Transaction failed: {txn_receipt}")

oli/attestation/onchain.py

@@ -0,0 +1,272 @@
+class OnchainAttestations:
+    def __init__(self, oli_client):
+        """
+        Initialize OnchainAttestations with an OLI client.
+        
+        Args:
+            oli_client: The OLI client instance
+        """
+        self.oli = oli_client
+    
+    def create_onchain_label(self, address: str, chain_id: str, tags: dict, ref_uid: str="0x0000000000000000000000000000000000000000000000000000000000000000", gas_limit: int=0) -> tuple[str, str]:
+        """
+        Create an onchain OLI label attestation for a contract.
+        
+        Args:
+            address (str): The contract address to label
+            chain_id (str): Chain ID in CAIP-2 format where the address/contract resides
+            tags (dict): OLI compliant tags as a dict  information (name, version, etc.)
+            ref_uid (str): Reference UID
+            gas_limit (int): Gas limit for the transaction. If set to 0, the function will estimate the gas limit.
+            
+        Returns:
+            str: Transaction hash
+            str: UID of the attestation
+        """
+        # fix simple formatting errors in tags
+        tags = self.oli.validator.fix_simple_tags_formatting(tags)
+
+        # Check all necessary input parameters
+        self.oli.validator.check_label_correctness(address, chain_id, tags, ref_uid, auto_fix=False)
+
+        # Encode the label data
+        data = self.oli.utils_other.encode_label_data(chain_id, tags)
+        
+        # Create the attestation
+        function = self.oli.eas.functions.attest({
+            'schema': self.oli.w3.to_bytes(hexstr=self.oli.oli_label_pool_schema),
+            'data': {
+                'recipient': self.oli.w3.to_checksum_address(address),
+                'expirationTime': 0,
+                'revocable': True,
+                'refUID': self.oli.w3.to_bytes(hexstr=ref_uid),
+                'data': self.oli.w3.to_bytes(hexstr=data),
+                'value': 0
+            }
+        })
+
+        # Define the transaction parameters
+        tx_params = {
+            'chainId': self.oli.rpc_chain_number,
+            'gasPrice': self.oli.w3.eth.gas_price,
+            'nonce': self.oli.w3.eth.get_transaction_count(self.oli.address),
+        }
+
+        # Estimate gas if no limit provided
+        tx_params = self.oli.utils_other.estimate_gas_limit(function, tx_params, gas_limit)
+        
+        # Build the transaction to attest one label
+        transaction = function.build_transaction(tx_params)
+
+        # Sign the transaction with the private key
+        signed_txn = self.oli.w3.eth.account.sign_transaction(transaction, private_key=self.oli.private_key)
+        
+        # Send the transaction
+        try:
+            txn_hash = self.oli.w3.eth.send_raw_transaction(signed_txn.raw_transaction)
+        except Exception as e:
+            raise Exception(f"Failed to send transaction to mempool: {e}")
+
+        # Wait for the transaction receipt
+        txn_receipt = self.oli.w3.eth.wait_for_transaction_receipt(txn_hash)
+        
+        # Check if the transaction was successful
+        if txn_receipt.status == 1:
+            return f"0x{txn_hash.hex()}", f"0x{txn_receipt.logs[0].data.hex()}"
+        else:
+            raise Exception(f"Transaction failed onchain: {txn_receipt}")
+    
+    def create_multi_onchain_labels(self, labels: list, gas_limit: int=0) -> tuple[str, list]:
+        """
+        Batch submit OLI labels in one transaction.
+        
+        Args:
+            labels (list): List of labels, containing dictionaries with 'address', 'tags', and 'chain_id' (, optional 'ref_uid')
+                address (str): The contract address to label
+                chain_id (str): Chain ID in CAIP-2 format where the address/contract resides
+                tags (dict): OLI compliant tags as a dict  information (name, version, etc.)
+                ref_uid (str): Reference UID
+            gas_limit (int): Gas limit for one transaction to submit all labels passed, make sure to set it high enough for multiple attestations! If set to 0, the function will estimate the gas limit.
+            
+        Returns:
+            str: Transaction hash
+            list: List of UID of the attestation
+        """
+        # Prepare the list of "data" requests
+        full_data = []
+        for label in labels:
+            # check if address, chain_id & tags are provided
+            if 'chain_id' not in label:
+                raise ValueError("chain_id must be provided for each label in CAIP-2 format (e.g., Base -> 'eip155:8453')")
+            elif 'address' not in label:
+                raise ValueError("An address must be provided for each label")
+            elif 'tags' not in label:
+                raise ValueError("tags dictionary must be provided for each label")
+            
+            # fix simple formatting errors in tags
+            label['tags'] = self.oli.validator.fix_simple_tags_formatting(label['tags'])
+
+            # run checks on each label
+            self.oli.validator.check_label_correctness(label['address'], label['chain_id'], label['tags'], auto_fix=False)
+
+            # check if ref_uid is provided
+            if 'ref_uid' not in label:
+                label['ref_uid'] = "0x0000000000000000000000000000000000000000000000000000000000000000"
+            else:
+                self.oli.validator.checks_ref_uid(label['ref_uid'])
+
+            # ABI encode data for each attestation
+            data = self.oli.utils_other.encode_label_data(label['chain_id'], label['tags'])
+            full_data.append({
+                'recipient': self.oli.w3.to_checksum_address(label['address']),
+                'expirationTime': 0,
+                'revocable': True,
+                'refUID': self.oli.w3.to_bytes(hexstr=label['ref_uid']),
+                'data': self.oli.w3.to_bytes(hexstr=data),
+                'value': 0
+            })
+
+        # Create the multi-attestation request
+        multi_requests = [{
+            'schema': self.oli.w3.to_bytes(hexstr=self.oli.oli_label_pool_schema),
+            'data': full_data
+        }]
+
+        # Create the function call
+        function = self.oli.eas.functions.multiAttest(multi_requests)
+
+        # Define the transaction parameters
+        tx_params = {
+            'chainId': self.oli.rpc_chain_number,
+            'gasPrice': self.oli.w3.eth.gas_price,
+            'nonce': self.oli.w3.eth.get_transaction_count(self.oli.address),
+        }
+
+        # Estimate gas if no limit provided
+        tx_params = self.oli.utils_other.estimate_gas_limit(function, tx_params, gas_limit)
+
+        # Build the transaction to revoke an attestation
+        transaction = function.build_transaction(tx_params)
+
+        # Sign the transaction with the private key
+        signed_txn = self.oli.w3.eth.account.sign_transaction(transaction, private_key=self.oli.private_key)
+        
+        # Send the transaction
+        try:
+            txn_hash = self.oli.w3.eth.send_raw_transaction(signed_txn.raw_transaction)
+        except Exception as e:
+            raise Exception(f"Failed to send transaction to mempool: {e}")
+        
+        # Wait for the transaction receipt
+        txn_receipt = self.oli.w3.eth.wait_for_transaction_receipt(txn_hash)
+
+        # Check if the transaction was successful
+        if txn_receipt.status != 1:
+            raise Exception(f"Transaction failed onchain: {txn_receipt}")
+
+        # log the UIDs of the attestations in a list
+        uids = ['0x' + log.data.hex() for log in txn_receipt.logs]
+
+        return f"0x{txn_hash.hex()}", uids
+        
+    def revoke_attestation(self, uid_hex: str, gas_limit: int=200000) -> str:
+        """
+        Revoke an onchain attestation using its UID.
+        
+        Args:
+            uid_hex (str): UID of the attestation to revoke (in hex format)
+            gas_limit (int): Gas limit for the transaction. If not set, defaults to 200000. Gas estimation is not possible for revoke transactions.
+            
+        Returns:
+            str: Transaction hash
+        """
+        function = self.oli.eas.functions.revoke({
+            'schema': self.oli.w3.to_bytes(hexstr=self.oli.oli_label_pool_schema),
+            'data': {
+                'uid': self.oli.w3.to_bytes(hexstr=uid_hex),
+                'value': 0
+            }
+        })
+
+        # Define the transaction parameters
+        tx_params = {
+            'chainId': self.oli.rpc_chain_number,
+            'gasPrice': self.oli.w3.eth.gas_price,
+            'nonce': self.oli.w3.eth.get_transaction_count(self.oli.address),
+        }
+
+        # Estimate gas if no limit provided
+        tx_params = self.oli.utils_other.estimate_gas_limit(function, tx_params, gas_limit)
+
+        # Build the transaction to revoke an attestation
+        transaction = function.build_transaction(tx_params)
+
+        # Sign the transaction
+        signed_txn = self.oli.w3.eth.account.sign_transaction(transaction, private_key=self.oli.private_key)
+
+        # Send the transaction
+        try:
+            txn_hash = self.oli.w3.eth.send_raw_transaction(signed_txn.raw_transaction)
+        except Exception as e:
+            raise Exception(f"Failed to send revoke transaction to mempool: {e}")
+
+        # Get the transaction receipt
+        txn_receipt = self.oli.w3.eth.wait_for_transaction_receipt(txn_hash)
+        
+        # Check if the transaction was successful
+        if txn_receipt.status == 1:
+            return f"0x{txn_hash.hex()}"
+        else:
+            raise Exception(f"Transaction failed: {txn_receipt}")
+    
+    def multi_revoke_attestations(self, uids: list, gas_limit: int=10000000) -> tuple[str, int]:
+        """
+        Revoke multiple onchain attestations in a single transaction.
+        
+        Args:
+            uids (list): List of UIDs to revoke (in hex format)
+            gas_limit (int): Gas limit for the transaction. If not set, defaults to 10000000. Gas estimation is not possible for revoke transactions.
+            
+        Returns:
+            str: Transaction hash
+            int: Number of attestations revoked
+        """
+        revocation_data = []
+        for uid in uids:
+            revocation_data.append({
+                'uid': self.oli.w3.to_bytes(hexstr=uid),
+                'value': 0
+            })
+        multi_requests = [{
+            'schema': self.oli.w3.to_bytes(hexstr=self.oli.oli_label_pool_schema),
+            'data': revocation_data
+        }]
+        function = self.oli.eas.functions.multiRevoke(multi_requests)
+
+        # Define the transaction parameters
+        tx_params = {
+            'chainId': self.oli.rpc_chain_number,
+            'gasPrice': self.oli.w3.eth.gas_price,
+            'nonce': self.oli.w3.eth.get_transaction_count(self.oli.address),
+        }
+
+        # Estimate gas if no limit provided
+        tx_params = self.oli.utils_other.estimate_gas_limit(function, tx_params, gas_limit)
+
+        # Build the transaction
+        transaction = function.build_transaction(tx_params)
+
+        # Sign the transaction
+        signed_txn = self.oli.w3.eth.account.sign_transaction(transaction, private_key=self.oli.private_key)
+
+        # Send the transaction
+        txn_hash = self.oli.w3.eth.send_raw_transaction(signed_txn.raw_transaction)
+
+        # Get the transaction receipt
+        txn_receipt = self.oli.w3.eth.wait_for_transaction_receipt(txn_hash)
+        
+        # Check if the transaction was successful
+        if txn_receipt.status == 1:
+            return f"0x{txn_hash.hex()}", len(uids)
+        else:
+            raise Exception(f"Transaction failed: {txn_receipt}")

oli/attestation/utils_other.py

@@ -0,0 +1,111 @@
+import json
+from eth_abi.abi import encode
+import secrets
+from web3 import Web3
+
+class UtilsOther:
+    def __init__(self, oli_client):
+        """
+        Initialize the DataEncoder with an OLI client.
+        
+        Args:
+            oli_client: The OLI client instance
+        """
+        self.oli = oli_client
+    
+    def encode_label_data(self, chain_id: str, tags_json: dict) -> str:
+        """
+        Encode label data in the OLI format.
+        
+        Args:
+            chain_id (str): Chain ID in CAIP-2 format of the label (e.g. 'eip155:8453')
+            tags_json (dict): Dictionary of tag data following the OLI format
+            
+        Returns:
+            str: Hex-encoded ABI data
+        """
+        # Convert dict to JSON string if needed
+        if isinstance(tags_json, dict):
+            tags_json = json.dumps(tags_json)
+            
+        # ABI encode the data
+        encoded_data = encode(['string', 'string'], [chain_id, tags_json])
+        return f"0x{encoded_data.hex()}"
+    
+    def estimate_gas_limit(self, function, tx_params: dict, gas_limit: int) -> dict:
+        """
+        Estimate gas for a transaction.
+        
+        Args:
+            function: The function to estimate gas for
+            tx_params (dict): Transaction parameters
+            gas_limit (int): Gas limit
+            
+        Returns:
+            tx_params (dict): Transaction parameters with estimated 'gas' field
+        """
+        try:
+            if gas_limit == 0:
+                # Estimate gas with a buffer (e.g., 10% more than the estimate)
+                estimated_gas = function.estimate_gas(tx_params)
+                tx_params["gas"] = int(estimated_gas * 1.1)  # Add 10% buffer
+            else:
+                tx_params["gas"] = gas_limit
+        except Exception as e:
+            tx_params["gas"] = 10000000  # Default fallback
+        return tx_params
+    
+    def calculate_attestation_uid_v2(self, schema: str, recipient: str, attester: str, timestamp: int, data: str, expiration_time: int=0, revocable: bool=True, ref_uid: str="0x0000000000000000000000000000000000000000000000000000000000000000", bump: int=0, salt: str=None) -> bytes:
+        """
+        Calculate the UID for an offchain attestation (v2).
+        
+        Args:
+            schema (str): Schema hash
+            recipient (str): Recipient address
+            attester (str): Attester address
+            timestamp (int): Timestamp
+            data (str): Attestation data
+            expiration_time (int): Expiration time
+            revocable (bool): Whether attestation is revocable
+            ref_uid (str): Reference UID
+            bump (int): Bump value
+            salt (str): Salt value
+            
+        Returns:
+            bytes: The calculated UID
+        """
+        # Generate salt if not provided
+        if salt is None:
+            salt = f"0x{secrets.token_hex(32)}"
+            
+        # Version
+        version = 2
+        version_bytes = version.to_bytes(2, byteorder='big')
+        
+        # Handle schema formatting
+        if not schema.startswith('0x'):
+            schema = '0x' + schema
+        schema_utf8_bytes = schema.encode('utf-8')
+        schema_bytes = schema_utf8_bytes
+        
+        # Convert values to bytes
+        recipient_bytes = Web3.to_bytes(hexstr=recipient)
+        attester_bytes = Web3.to_bytes(hexstr=attester)
+        timestamp_bytes = timestamp.to_bytes(8, byteorder='big')
+        expiration_bytes = expiration_time.to_bytes(8, byteorder='big')
+        revocable_bytes = bytes([1]) if revocable else bytes([0])
+        ref_uid_bytes = Web3.to_bytes(hexstr=ref_uid)
+        data_bytes = Web3.to_bytes(hexstr=data)
+        salt_bytes = Web3.to_bytes(hexstr=salt)
+        bump_bytes = bump.to_bytes(4, byteorder='big')
+        
+        # Pack all values
+        packed_data = (
+            version_bytes + schema_bytes + recipient_bytes + attester_bytes + 
+            timestamp_bytes + expiration_bytes + revocable_bytes + ref_uid_bytes + 
+            data_bytes + salt_bytes + bump_bytes
+        )
+        
+        # Calculate keccak256 hash
+        uid = Web3.keccak(packed_data)
+        return uid