Master (#1262)

* clear * feat: Add everything * fix: Commenht
2026-08-03 01:41:44 +00:00 · 2025-10-03 14:45:52 -04:00
parent 43b4a11c06
commit 13e6c3e84d
1935 changed files with 655061 additions and 40058 deletions
@@ -0,0 +1,221 @@
+package test
+
+import (
+	"testing"
+	"time"
+
+	"github.com/sonr-io/sonr/crypto/ucan"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestModuleSpecificUCANCapabilities(t *testing.T) {
+	t.Run("TestDIDCapabilityCreation", func(t *testing.T) {
+		// Create DID-specific attenuation
+		didAttenuation := ucan.CreateDIDAttenuation(
+			[]string{"create", "update"},
+			"*",
+			[]string{"owner"},
+		)
+
+		assert.Equal(t, "did:*", didAttenuation.Resource.GetURI())
+
+		didCap, ok := didAttenuation.Capability.(*ucan.DIDCapability)
+		require.True(t, ok, "Expected DIDCapability")
+		assert.Contains(t, didCap.Actions, "create")
+		assert.Contains(t, didCap.Actions, "update")
+		assert.Contains(t, didCap.Caveats, "owner")
+	})
+
+	t.Run("TestDWNCapabilityCreation", func(t *testing.T) {
+		// Create DWN-specific attenuation
+		dwnAttenuation := ucan.CreateDWNAttenuation(
+			[]string{"create", "read", "update", "delete"},
+			"personal/*",
+			[]string{"owner"},
+		)
+
+		assert.Equal(t, "dwn:records/personal/*", dwnAttenuation.Resource.GetURI())
+
+		dwnCap, ok := dwnAttenuation.Capability.(*ucan.DWNCapability)
+		require.True(t, ok, "Expected DWNCapability")
+		assert.Contains(t, dwnCap.Actions, "create")
+		assert.Contains(t, dwnCap.Actions, "read")
+		assert.Contains(t, dwnCap.Caveats, "owner")
+	})
+
+	t.Run("TestDEXCapabilityCreation", func(t *testing.T) {
+		// Create DEX-specific attenuation
+		dexAttenuation := ucan.CreateDEXAttenuation(
+			[]string{"swap", "provide-liquidity"},
+			"snr/usd",
+			[]string{"max-amount"},
+			"1000snr",
+		)
+
+		assert.Equal(t, "dex:pool/snr/usd", dexAttenuation.Resource.GetURI())
+
+		dexCap, ok := dexAttenuation.Capability.(*ucan.DEXCapability)
+		require.True(t, ok, "Expected DEXCapability")
+		assert.Contains(t, dexCap.Actions, "swap")
+		assert.Contains(t, dexCap.Actions, "provide-liquidity")
+		assert.Contains(t, dexCap.Caveats, "max-amount")
+		assert.Equal(t, "1000snr", dexCap.MaxAmount)
+	})
+
+	t.Run("TestCrossModuleCapability", func(t *testing.T) {
+		// Create cross-module capability
+		crossCap := &ucan.CrossModuleCapability{
+			Modules: map[string]ucan.Capability{
+				"did": &ucan.DIDCapability{
+					Actions: []string{"create", "update"},
+				},
+				"dwn": &ucan.DWNCapability{
+					Actions: []string{"create", "read"},
+				},
+			},
+		}
+
+		actions := crossCap.GetActions()
+		assert.Contains(t, actions, "create")
+		assert.Contains(t, actions, "update")
+		assert.Contains(t, actions, "read")
+
+		assert.True(t, crossCap.Grants([]string{"create"}))
+		assert.True(t, crossCap.Grants([]string{"update", "read"}))
+		assert.False(t, crossCap.Grants([]string{"delete"}))
+	})
+
+	t.Run("TestGaslessCapability", func(t *testing.T) {
+		// Create gasless capability wrapper
+		baseCap := &ucan.DIDCapability{
+			Actions: []string{"create"},
+		}
+
+		gaslessCap := &ucan.GaslessCapability{
+			Capability:   baseCap,
+			AllowGasless: true,
+			GasLimit:     100000,
+		}
+
+		assert.True(t, gaslessCap.SupportsGasless())
+		assert.Equal(t, uint64(100000), gaslessCap.GetGasLimit())
+		assert.True(t, gaslessCap.Grants([]string{"create"}))
+	})
+}
+
+func TestModuleJWTTokenGeneration(t *testing.T) {
+	t.Run("TestGenerateAndVerifyModuleToken", func(t *testing.T) {
+		// Create attenuations for different modules
+		attenuations := []ucan.Attenuation{
+			ucan.CreateDIDAttenuation([]string{"create", "update"}, "*", []string{"owner"}),
+			ucan.CreateDWNAttenuation([]string{"create", "read"}, "personal/*", []string{"owner"}),
+		}
+
+		issuer := "did:key:alice"
+		audience := "did:key:bob"
+
+		// Generate token
+		tokenString, err := ucan.GenerateModuleJWTToken(
+			attenuations,
+			issuer,
+			audience,
+			time.Hour,
+		)
+		require.NoError(t, err)
+		assert.NotEmpty(t, tokenString)
+
+		// Verify token
+		token, err := ucan.VerifyModuleJWTToken(tokenString, issuer, audience)
+		require.NoError(t, err)
+		assert.Equal(t, issuer, token.Issuer)
+		assert.Equal(t, audience, token.Audience)
+		assert.Len(t, token.Attenuations, 2)
+
+		// Check that attenuations are properly parsed
+		var didAtt, dwnAtt *ucan.Attenuation
+		for _, att := range token.Attenuations {
+			switch att.Resource.GetScheme() {
+			case "did":
+				didAtt = &att
+			case "dwn":
+				dwnAtt = &att
+			}
+		}
+
+		require.NotNil(t, didAtt, "DID attenuation not found")
+		require.NotNil(t, dwnAtt, "DWN attenuation not found")
+
+		didCap, ok := didAtt.Capability.(*ucan.DIDCapability)
+		assert.True(t, ok)
+		assert.Contains(t, didCap.Actions, "create")
+		assert.Contains(t, didCap.Actions, "update")
+
+		dwnCap, ok := dwnAtt.Capability.(*ucan.DWNCapability)
+		assert.True(t, ok)
+		assert.Contains(t, dwnCap.Actions, "create")
+		assert.Contains(t, dwnCap.Actions, "read")
+	})
+}
+
+func TestModuleCapabilityTemplates(t *testing.T) {
+	t.Run("TestDIDTemplate", func(t *testing.T) {
+		template := ucan.StandardDIDTemplate()
+
+		// Test valid DID actions
+		didAtt := ucan.CreateDIDAttenuation([]string{"create", "update"}, "*", nil)
+		err := template.ValidateAttenuation(didAtt)
+		assert.NoError(t, err)
+
+		// Test invalid DID action
+		invalidAtt := ucan.CreateDIDAttenuation([]string{"invalid-action"}, "*", nil)
+		err = template.ValidateAttenuation(invalidAtt)
+		assert.Error(t, err)
+	})
+
+	t.Run("TestDWNTemplate", func(t *testing.T) {
+		template := ucan.StandardDWNTemplate()
+
+		// Test valid DWN actions
+		dwnAtt := ucan.CreateDWNAttenuation([]string{"create", "read"}, "*", nil)
+		err := template.ValidateAttenuation(dwnAtt)
+		assert.NoError(t, err)
+	})
+
+	t.Run("TestDEXTemplate", func(t *testing.T) {
+		template := ucan.StandardDEXTemplate()
+
+		// Test valid DEX actions
+		dexAtt := ucan.CreateDEXAttenuation([]string{"swap", "provide-liquidity"}, "*", nil, "")
+		err := template.ValidateAttenuation(dexAtt)
+		assert.NoError(t, err)
+	})
+}
+
+func TestEnhancedVerification(t *testing.T) {
+	t.Run("TestVerifierWithModuleCapabilities", func(t *testing.T) {
+		// Create a test token
+		attenuations := []ucan.Attenuation{
+			ucan.CreateDIDAttenuation([]string{"create"}, "*", []string{"owner"}),
+		}
+
+		tokenString, err := ucan.GenerateModuleJWTToken(
+			attenuations,
+			"did:key:alice",
+			"did:key:bob",
+			time.Hour,
+		)
+		require.NoError(t, err)
+
+		// Verify capability - this would normally require proper DID resolution
+		// For now, just test that the parsing works
+		token, err := ucan.VerifyModuleJWTToken(tokenString, "did:key:alice", "did:key:bob")
+		require.NoError(t, err)
+		assert.Len(t, token.Attenuations, 1)
+
+		didCap, ok := token.Attenuations[0].Capability.(*ucan.DIDCapability)
+		assert.True(t, ok)
+		assert.Contains(t, didCap.Actions, "create")
+		assert.Contains(t, didCap.Caveats, "owner")
+	})
+}