oli-python 2.0.5__tar.gz → 2.0.7__tar.gz

{oli_python-2.0.5 → oli_python-2.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: oli-python
-Version: 2.0.5
+Version: 2.0.7
 Summary: Python SDK for interacting with the Open Labels Initiative; A standard, registry and trust layer for EVM address labels.
 Home-page: https://github.com/openlabelsinitiative/oli-python
 Author: Lorenz Lehmann

{oli_python-2.0.5 → oli_python-2.0.7}/oli/attestation/offchain.py

@@ -41,12 +41,15 @@ class OffchainAttestations:
         else:
             print("Warning: OLI tag definitions not loaded, skipping tag formatting and validation. Please upgrade to the latest OLI version and ensure internet connectivity at initialization.")
 
+        # Merge chain_id (CAIP2) & address to CAIP10 format
+        caip10 = f"{chain_id}:{address}"
+
         # Encode the label data
-        data = self.oli.utils_other.encode_label_data(chain_id, tags)
+        data = self.oli.utils_other.encode_label_data(caip10, tags)
         
         # Build the attestation
         attestation = self.build_offchain_attestation(
-            recipient=address, 
+            recipient="0x0000000000000000000000000000000000000001",  # use 0x...1 to track python tooling was used
             schema=self.oli.oli_label_pool_schema, 
             data=data, 
             ref_uid=ref_uid
@@ -108,12 +111,15 @@ class OffchainAttestations:
                 else:
                     print("Warning: OLI tag definitions not loaded, skipping tag formatting and validation. Please upgrade to the latest OLI version and ensure internet connectivity at initialization.")
         
+                # Merge chain_id (CAIP2) & address to CAIP10 format
+                caip10 = f"{chain_id}:{address}"
+
                 # Encode the label data
-                data = self.oli.utils_other.encode_label_data(chain_id, tags)
-        
+                data = self.oli.utils_other.encode_label_data(caip10, tags)
+
                 # Build the attestation
                 attestation = self.build_offchain_attestation(
-                    recipient=address, 
+                    recipient="0x0000000000000000000000000000000000000001", # use 0x...1 to track python tooling was used
                     schema=self.oli.oli_label_pool_schema, 
                     data=data, 
                     ref_uid=ref_uid
@@ -164,10 +170,9 @@ class OffchainAttestations:
         data = self.oli.utils_other.encode_list_data(owner_name, attesters, attestations)
 
         # Build the attestation
-        recipient = "0x0000000000000000000000000000000000000000"
         ref_uid = "0x0000000000000000000000000000000000000000000000000000000000000000"
         attestation = self.build_offchain_attestation(
-            recipient=recipient, 
+            recipient="0x0000000000000000000000000000000000000001", # use 0x...1 to track python tooling was used
             schema=self.oli.oli_label_trust_schema, 
             data=data, 
             ref_uid=ref_uid

{oli_python-2.0.5 → oli_python-2.0.7}/oli/attestation/onchain.py

@@ -18,7 +18,7 @@ class OnchainAttestations:
             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 -1, the function will estimate the gas limit.
+            gas_limit (int): Gas limit for the transaction. If set to -1, the function will estimate the gas limit
             
         Returns:
             str: Transaction hash
@@ -36,14 +36,17 @@ class OnchainAttestations:
         else:
             print("Warning: OLI tag definitions not loaded, skipping tag formatting and validation. Please upgrade to the latest OLI version and ensure internet connectivity at initialization.")
 
+        # Prepare CAIP10 format for the address
+        caip10 = f"{chain_id}:{address}"
+
         # Encode the label data
-        data = self.oli.utils_other.encode_label_data(chain_id, tags)
+        data = self.oli.utils_other.encode_label_data(caip10, 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),
+                'recipient': "0x0000000000000000000000000000000000000001",  # use 0x...1 to track python tooling was used
                 'expirationTime': 0,
                 'revocable': True,
                 'refUID': self.oli.w3.to_bytes(hexstr=ref_uid),
@@ -128,10 +131,13 @@ class OnchainAttestations:
             else:
                 self.oli.validator.validate_ref_uid(label['ref_uid'])
 
+            # Merge chain_id (CAIP2) & address to CAIP10 format
+            caip10 = f"{label['chain_id']}:{label['address']}"
+
             # ABI encode data for each attestation
-            data = self.oli.utils_other.encode_label_data(label['chain_id'], label['tags'])
+            data = self.oli.utils_other.encode_label_data(caip10, label['tags'])
             full_data.append({
-                'recipient': self.oli.w3.to_checksum_address(label['address']),
+                'recipient': "0x0000000000000000000000000000000000000001", # use 0x...1 to track python tooling was used
                 'expirationTime': 0,
                 'revocable': True,
                 'refUID': self.oli.w3.to_bytes(hexstr=label['ref_uid']),
@@ -206,7 +212,7 @@ class OnchainAttestations:
         function = self.oli.eas.functions.attest({
             'schema': self.oli.w3.to_bytes(hexstr=self.oli.oli_label_trust_schema),
             'data': {
-                'recipient': "0x0000000000000000000000000000000000000000",  # Trust lists are not tied to a specific address
+                'recipient': "0x0000000000000000000000000000000000000001",  # Trust lists are not tied to a specific address, use 0x...1 to track python tooling was used
                 'expirationTime': 0, # never expires
                 'revocable': True, # can be revoked
                 'refUID': "0x0000000000000000000000000000000000000000000000000000000000000000", # no ref UID for trust lists

{oli_python-2.0.5 → oli_python-2.0.7}/oli/attestation/utils_other.py

@@ -13,12 +13,12 @@ class UtilsOther:
         """
         self.oli = oli_client
     
-    def encode_label_data(self, chain_id: str, tags_json: dict) -> str:
+    def encode_label_data(self, caip10: 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')
+            caip10 (str): address and chain_id in caip10 format (e.g. 'eip155:8453:0x3Ae5F83668B75328446c649B6ab342aC46D73B3c')
             tags_json (dict): Dictionary of tag data following the OLI format
             
         Returns:
@@ -27,9 +27,15 @@ class UtilsOther:
         # Convert dict to JSON string if needed
         if isinstance(tags_json, dict):
             tags_json = json.dumps(tags_json)
+
+        # Convert address to checksum if possible
+        try:
+            caip10 = caip10[:caip10.rfind(":")+1] + self.oli.w3.to_checksum_address(caip10.split(":")[-1])
+        except:
+            pass
             
         # ABI encode the data
-        encoded_data = encode(['string', 'string'], [chain_id, tags_json])
+        encoded_data = encode(['string', 'string'], [caip10, tags_json])
         return f"0x{encoded_data.hex()}"
     
     def encode_list_data(self, owner: str, trusted: list, untrusted: list) -> str:

{oli_python-2.0.5 → oli_python-2.0.7}/oli/attestation/utils_validator.py

@@ -7,20 +7,13 @@ class UtilsValidator:
             oli_client: The OLI client instance
         """
         self.oli = oli_client
-        self.allowed_prefixes = [
-            'eip155:',  # Ethereum and EVM-compatible chains
-            'solana:',  # Solana
-            'tron:',    # TRON
-            'stellar:', # Stellar
-            'bip122:',  # Bitcoin
-            'SN_MAIN'   # Starknet
-        ]
         # URLs for helpful resources
         self.url_1_label_schema = "https://github.com/openlabelsinitiative/OLI/tree/main/1_label_schema"
         self.url_2_label_pool = "https://github.com/openlabelsinitiative/OLI/tree/main/2_label_pool"
         self.url_3_label_trust = "https://github.com/openlabelsinitiative/OLI/tree/main/3_label_trust"
         self.url_tag_definitions = "https://github.com/openlabelsinitiative/OLI/blob/main/1_label_schema/tags/tag_definitions.yml"
         self.url_caip2_format = "https://docs.portalhq.io/resources/chain-id-formatting"
+        self.url_caip10_format = "https://github.com/ChainAgnostic/CAIPs/blob/main/CAIPs/caip-10.md"
 
     def fix_simple_tags_formatting(self, tags: dict) -> dict:
         """
@@ -97,7 +90,7 @@ class UtilsValidator:
         Validates if the label is compliant with the OLI Label Schema. See OLI Github documentation for more details: https://github.com/openlabelsinitiative/OLI/tree/main/1_label_schema
         
         Args:
-            address (str): Address to check
+            address (str): Address that is labelled to check
             chain_id (str): Chain ID to check
             tags (dict): Tags to check
             ref_uid (str): Reference UID to check
@@ -107,7 +100,7 @@ class UtilsValidator:
             bool: True if the label is correct, False otherwise
         """
         # basic checks
-        self.validate_address(address)
+        self.validate_address_to_be_labelled(address)
         self.validate_chain_id(chain_id)
         self.validate_tags(tags, auto_fix=auto_fix)
         self.validate_ref_uid(ref_uid)
@@ -145,25 +138,25 @@ class UtilsValidator:
         Returns:
             bool: True if correct, False otherwise
         """
-        # Check if the chain_id starts with any of the allowed prefixes
-        for prefix in self.allowed_prefixes:
-            if chain_id.startswith(prefix):
-                # For eip155, further validate that the rest is a number or 'any'
-                if prefix == 'eip155:':
-                    rest = chain_id[len(prefix):]
-                    if rest.isdigit():
-                        return True
-                    elif rest == 'any':
-                        print("Please ensure the label is accurate and consistent across all EVM chains before setting chain_id = 'eip155:any'.")
-                        return True
-                    else:
-                        print(f"Invalid eip155 chain_id format: {chain_id}")
-                        raise ValueError("For eip155 chains, format must be 'eip155:' followed by a number or 'any'")
-                return True
+        # Check if the chain_id has one ":" in it which is not at the start or end
+        if ":" in chain_id and chain_id.count(":") == 1 and chain_id.find(":") != 0 and chain_id.find(":") != len(chain_id)-1:
+            prefix = chain_id[:chain_id.find(":")+1].lower()
+            # For eip155, further validate that the rest is a number or 'any'
+            if prefix == 'eip155:':
+                rest = chain_id[len(prefix):]
+                if rest.isdigit():
+                    return True
+                elif rest == 'any':
+                    print("Please ensure the label is accurate and consistent across all EVM chains before setting chain_id = 'eip155:any'.")
+                    return True
+                else:
+                    print(f"Invalid eip155 chain_id format: {chain_id}")
+                    raise ValueError("For eip155 chains, format must be 'eip155:' followed by a number or 'any'")
+            return True
         
         # If we get here, the chain_id didn't match any allowed format
         print(f"Unsupported chain ID format: {chain_id}")
-        raise ValueError(f"Chain ID must be in CAIP-2 format (e.g., Base -> 'eip155:8453'), see this guide on CAIP-2: {self.url_caip2_format}")
+        raise ValueError(f"Chain ID must be in CAIP-2 format (e.g., Base -> 'eip155:8453' or Starknet -> 'starknet:SN_MAIN'), see this guide on CAIP-2: {self.url_caip2_format}")
 
     def validate_address(self, address: str) -> bool:
         """
@@ -181,6 +174,24 @@ class UtilsValidator:
             print(address)
             raise ValueError("Address must be a valid Ethereum address in hex format")
         
+    def validate_address_to_be_labelled(self, address: str) -> bool:
+        """
+        Validates if address to be labelled is within CAIP10 limits
+
+        Args:
+            address (str): Address to check
+        
+        Returns:
+            bool: True if correct, False otherwise
+        """
+        if len(address) > 66 or len(address) == 0:
+            print(f"Unexpected address length ({len(address)}): '{address}'")
+            raise ValueError(f"Address to be labelled exceeds maximum length of 66 characters or is empty. See this guide on CAIP-10 address limitations: {self.url_caip10_format}")
+        if ":" in address:
+            print(f"Address to be labelled must not contain ':' character: '{address}'")
+            raise ValueError(f"Address to be labelled must not contain ':' character. See this guide on CAIP-10 address limitations: {self.url_caip10_format}")
+        return True
+
     def validate_tags(self, tags: dict, auto_fix: bool=False) -> bool:
         """
         Check if tags are in the correct format.

{oli_python-2.0.5 → oli_python-2.0.7}/oli/core.py

@@ -82,7 +82,7 @@ class OLI:
                 self.source_address = None # for Label Trust
         
         # Label Pool Schema for OLI Label Pool
-        self.oli_label_pool_schema = '0xb763e62d940bed6f527dd82418e146a904e62a297b8fa765c9b3e1f0bc6fdd68'
+        self.oli_label_pool_schema = '0xcff83309b59685fdae9dad7c63d969150676d51d8eeda66799d1c4898b84556a' # v2.0.0 of EAS schema
         
         # Label Trust Schema for OLI Label Trust
         self.oli_label_trust_schema = '0x6d780a85bfad501090cd82868a0c773c09beafda609d54888a65c106898c363d'

{oli_python-2.0.5 → oli_python-2.0.7}/oli_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: oli-python
-Version: 2.0.5
+Version: 2.0.7
 Summary: Python SDK for interacting with the Open Labels Initiative; A standard, registry and trust layer for EVM address labels.
 Home-page: https://github.com/openlabelsinitiative/oli-python
 Author: Lorenz Lehmann

{oli_python-2.0.5 → oli_python-2.0.7}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setup(
     name="oli-python",
-    version="2.0.5",
+    version="2.0.7",
     author="Lorenz Lehmann",
     author_email="lorenz@growthepie.com",
     description="Python SDK for interacting with the Open Labels Initiative; A standard, registry and trust layer for EVM address labels.",