refactor: extract b64url_decode utility and bump to 0.0.3

- Extract b64url_decode from ArweaveSigner to turbo_sdk/bundle/utils.py
- Add unit tests for b64url_decode
- Bump version to 0.0.3

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: Dylan Fiedler

CHANGELOG.md

@@ -1,5 +1,12 @@
 # turbo-python-sdk
 
+## 0.0.3
+
+### Changed
+
+- Moved `turbo_sdk` package from `src/` to root directory
+- Extracted `b64url_decode` utility function to `turbo_sdk/bundle/utils.py`
+
 ## 0.0.2
 
 ### Changed

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "turbo-sdk"
-version = "0.0.2"
+version = "0.0.3"
 description = "Python SDK for interacting with the Ardrive Turbo Upload and Payment Service"
 readme = "README.md"
 license = {text = "MIT"}

tests/test_utils.py

@@ -1,5 +1,5 @@
 import pytest
-from turbo_sdk.bundle.utils import set_bytes, byte_array_to_long
+from turbo_sdk.bundle.utils import set_bytes, byte_array_to_long, b64url_decode
 
 
 class TestUtils:
@@ -86,3 +86,41 @@ def test_byte_array_to_long_two_bytes(self):
         data = bytearray([1, 1])  # 257 in little-endian
         result = byte_array_to_long(data)
         assert result == 257
+
+    def test_b64url_decode_with_padding(self):
+        """Test decoding base64url with proper padding"""
+        # "hello" in base64url with padding
+        result = b64url_decode("aGVsbG8=")
+        assert result == b"hello"
+
+    def test_b64url_decode_without_padding(self):
+        """Test decoding base64url without padding"""
+        # "hello" in base64url without padding
+        result = b64url_decode("aGVsbG8")
+        assert result == b"hello"
+
+    def test_b64url_decode_url_safe_chars(self):
+        """Test that url-safe characters are decoded correctly"""
+        import base64
+
+        # Data that would have + and / in standard base64
+        data = b"\xfb\xff\xfe"
+        encoded = base64.urlsafe_b64encode(data).decode().rstrip("=")
+        result = b64url_decode(encoded)
+        assert result == data
+
+    def test_b64url_decode_empty(self):
+        """Test decoding empty string"""
+        result = b64url_decode("")
+        assert result == b""
+
+    def test_b64url_decode_various_lengths(self):
+        """Test decoding strings of various lengths (different padding needs)"""
+        import base64
+
+        for length in [1, 2, 3, 4, 5, 10, 100]:
+            data = bytes(range(length % 256)) * (length // 256 + 1)
+            data = data[:length]
+            encoded = base64.urlsafe_b64encode(data).decode().rstrip("=")
+            result = b64url_decode(encoded)
+            assert result == data

turbo_sdk/bundle/utils.py

@@ -1,3 +1,14 @@
+import base64
+
+
+def b64url_decode(s: str) -> bytes:
+    """Decode a base64url-encoded string (with or without padding)"""
+    padding = 4 - len(s) % 4
+    if padding != 4:
+        s += "=" * padding
+    return base64.urlsafe_b64decode(s)
+
+
 def set_bytes(dest: bytearray, src: bytearray, offset: int):
     """Set bytes in destination array at offset"""
     for i in range(offset, offset + len(src), 1):

turbo_sdk/client.py

@@ -8,7 +8,10 @@ class Turbo:
     """Main Turbo client for uploading data and managing payments"""
 
     SERVICE_URLS = {
-        "mainnet": {"upload": "https://upload.ardrive.io", "payment": "https://payment.ardrive.io"},
+        "mainnet": {
+            "upload": "https://upload.ardrive.io", 
+            "payment": "https://payment.ardrive.io"
+        },
         "testnet": {
             "upload": "https://upload.ardrive.dev",
             "payment": "https://payment.ardrive.dev",

turbo_sdk/signers/arweave.py

@@ -1,4 +1,5 @@
 from turbo_sdk.signers.signer import Signer
+from turbo_sdk.bundle.utils import b64url_decode
 from cryptography.hazmat.primitives import hashes
 from cryptography.hazmat.primitives.asymmetric import rsa, padding
 import base64
@@ -25,13 +26,6 @@ def __init__(self, jwk: dict):
 
     def _jwk_to_rsa_key(self, jwk: dict):
         """Convert JWK to RSA private key"""
-
-        def b64url_decode(s):
-            padding = 4 - len(s) % 4
-            if padding != 4:
-                s += "=" * padding
-            return base64.urlsafe_b64decode(s)
-
         # Extract RSA components
         n = int.from_bytes(b64url_decode(jwk["n"]), "big")
         e = int.from_bytes(b64url_decode(jwk["e"]), "big")
@@ -52,13 +46,6 @@ def b64url_decode(s):
 
     def _jwk_to_public_key_bytes(self, jwk: dict) -> bytearray:
         """Extract 512-byte public key from JWK"""
-
-        def b64url_decode(s):
-            padding = 4 - len(s) % 4
-            if padding != 4:
-                s += "=" * padding
-            return base64.urlsafe_b64decode(s)
-
         n_bytes = b64url_decode(jwk["n"])
         if len(n_bytes) != 512:
             raise ValueError(f"Invalid Arweave public key length: {len(n_bytes)} (expected 512)")