oli-python 2.0.4__tar.gz → 2.0.6__tar.gz

{oli_python-2.0.4 → oli_python-2.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: oli-python
-Version: 2.0.4
+Version: 2.0.6
 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
@@ -32,6 +32,8 @@ Dynamic: summary
 
 This SDK lets you read, write, validate, and revoke address labels within the **OLI Label Pool** and compute confidence scores based on attesters' relationships within the **OLI Label Trust**.
 
+[Video Walkthrough](https://x.com/open_labels/status/1994353238699651328)
+
 ## Installation
 
 ```bash

{oli_python-2.0.4 → oli_python-2.0.6}/README.md

@@ -4,6 +4,8 @@
 
 This SDK lets you read, write, validate, and revoke address labels within the **OLI Label Pool** and compute confidence scores based on attesters' relationships within the **OLI Label Trust**.
 
+[Video Walkthrough](https://x.com/open_labels/status/1994353238699651328)
+
 ## Installation
 
 ```bash

{oli_python-2.0.4 → oli_python-2.0.6}/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.4 → oli_python-2.0.6}/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.4 → oli_python-2.0.6}/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.4 → oli_python-2.0.6}/oli/attestation/utils_validator.py

@@ -7,28 +7,23 @@ 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:
         """
         Fix basic formatting in the tags dictionary. This includes:
         - Ensuring all tag_ids are lowercase
-        - Booling values are converted from strings to booleans
         - Removing leading/trailing whitespace from string values
-        - Checksum address (string(42)) tags
+        - Converting boolean values from strings/integers to booleans
+          (accepts: 'true'/'t'/'1'/1 for True, 'false'/'f'/'0'/0 for False, case-insensitive)
+        - Converting integer values from strings to integers
+        - Checksumming address (string(42)) tags
         
         Args:
             tags (dict): Dictionary of tags
@@ -39,17 +34,49 @@ class UtilsValidator:
         # Convert tag_ids to lowercase
         tags = {k.lower(): v for k, v in tags.items()}
 
-        # Strip whitespaces, then turn boolean values from strings to booleans
+        # Strip whitespaces from strings
         for k, v in tags.items():
             if isinstance(v, str):
                 tags[k] = v.strip()
-                if tags[k] == 'true':
-                    tags[k] = True
-                elif tags[k] == 'false':
-                    tags[k] = False
             elif isinstance(v, list):
                 tags[k] = [i.strip() if isinstance(i, str) else i for i in v]
 
+        # Turn boolean strings to booleans based on schema
+        if self.oli.tag_definitions is not None:
+            boolean_keys = [
+                key
+                for key, value in self.oli.tag_definitions.items()
+                if value.get("schema", {}).get("type") == "boolean"
+            ]
+            for k, v in tags.items():
+                if k in boolean_keys:
+                    if isinstance(v, str):
+                        v_lower = v.lower()
+                        if v_lower in ('true', 't', '1'):
+                            tags[k] = True
+                        elif v_lower in ('false', 'f', '0'):
+                            tags[k] = False
+                    elif isinstance(v, int):
+                        if v == 1:
+                            tags[k] = True
+                        elif v == 0:
+                            tags[k] = False
+
+        # Turn integer strings to integers based on schema
+        if self.oli.tag_definitions is not None:
+            integer_keys = [
+                key
+                for key, value in self.oli.tag_definitions.items()
+                if value.get("schema", {}).get("type") == "integer"
+            ]
+            for k, v in tags.items():
+                if k in integer_keys and isinstance(v, str):
+                    if v.isdigit():
+                        try:
+                            tags[k] = int(v)
+                        except ValueError:
+                            pass
+
         # Checksum address tags
         for k, v in tags.items():
             if k in self.oli.tag_definitions and 'minLength' in self.oli.tag_definitions[k]['schema']:
@@ -63,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
@@ -73,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)
@@ -111,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:
         """
@@ -147,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.4 → oli_python-2.0.6}/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.4 → oli_python-2.0.6}/oli/data/api.py

@@ -11,6 +11,7 @@ class API:
         """
         self.oli = oli_client
         self.api_url = "https://api.openlabelsinitiative.org"
+        self.api_url = "http://0.0.0.0:8080" # testing
         self.api_key = api_key
 
     ### OLI Tags and Value Sets maintained in Github ###

{oli_python-2.0.4 → oli_python-2.0.6}/oli_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: oli-python
-Version: 2.0.4
+Version: 2.0.6
 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
@@ -32,6 +32,8 @@ Dynamic: summary
 
 This SDK lets you read, write, validate, and revoke address labels within the **OLI Label Pool** and compute confidence scores based on attesters' relationships within the **OLI Label Trust**.
 
+[Video Walkthrough](https://x.com/open_labels/status/1994353238699651328)
+
 ## Installation
 
 ```bash

{oli_python-2.0.4 → oli_python-2.0.6}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setup(
     name="oli-python",
-    version="2.0.4",
+    version="2.0.6",
     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.",