test(sdk): use neutral domain examples in the v1 suites

Author: kvinwang

sdk/go/dstack/client_v1_test.go

@@ -43,7 +43,7 @@ func TestV1GetKey(t *testing.T) {
 		{"secp256k1", 33},
 		{"ed25519", 32},
 	} {
-		resp, err := client.GetKey(context.Background(), "wallet", tc.algorithm)
+		resp, err := client.GetKey(context.Background(), "storage-encryption", tc.algorithm)
 		if err != nil {
 			t.Fatalf("%s: %v", tc.algorithm, err)
 		}
@@ -74,11 +74,11 @@ func TestV1GetKeyIsDomainSeparated(t *testing.T) {
 	client := dstack.NewDstackClientV1()
 	ctx := context.Background()
 
-	k256, err := client.GetKey(ctx, "wallet", "secp256k1")
+	k256, err := client.GetKey(ctx, "storage-encryption", "secp256k1")
 	if err != nil {
 		t.Fatal(err)
 	}
-	ed, err := client.GetKey(ctx, "wallet", "ed25519")
+	ed, err := client.GetKey(ctx, "storage-encryption", "ed25519")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -95,7 +95,7 @@ func TestV1GetKeyIsDomainSeparated(t *testing.T) {
 	}
 
 	// Derivation is stable for a given (domain, algorithm).
-	again, err := client.GetKey(ctx, "wallet", "secp256k1")
+	again, err := client.GetKey(ctx, "storage-encryption", "secp256k1")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -109,11 +109,11 @@ func TestV1GetKeyIsDomainSeparated(t *testing.T) {
 func TestV1GetKeyDiffersFromV0(t *testing.T) {
 	ctx := context.Background()
 
-	v1Resp, err := dstack.NewDstackClientV1().GetKey(ctx, "wallet", "secp256k1")
+	v1Resp, err := dstack.NewDstackClientV1().GetKey(ctx, "storage-encryption", "secp256k1")
 	if err != nil {
 		t.Fatal(err)
 	}
-	v0Resp, err := dstack.NewDstackClientV0().GetKey(ctx, "wallet", "", "secp256k1")
+	v0Resp, err := dstack.NewDstackClientV0().GetKey(ctx, "storage-encryption", "", "secp256k1")
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -133,7 +133,7 @@ func TestV1GetKeyRejectsMissingOrUnknownAlgorithms(t *testing.T) {
 	client := dstack.NewDstackClientV1()
 	ctx := context.Background()
 
-	_, err := client.GetKey(ctx, "wallet", "")
+	_, err := client.GetKey(ctx, "storage-encryption", "")
 	if err == nil {
 		t.Fatal("expected an empty algorithm to be rejected")
 	}
@@ -147,7 +147,7 @@ func TestV1GetKeyRejectsMissingOrUnknownAlgorithms(t *testing.T) {
 	}
 
 	for _, algorithm := range []string{"k256", "secp256k1_prehashed", "rsa"} {
-		if _, err := client.GetKey(ctx, "wallet", algorithm); err == nil {
+		if _, err := client.GetKey(ctx, "storage-encryption", algorithm); err == nil {
 			t.Errorf("expected algorithm %q to be rejected", algorithm)
 		}
 	}

sdk/js/src/__tests__/index-v1.test.ts

@@ -68,7 +68,7 @@ describe('DstackClientV1', () => {
   describe('getKey', () => {
     it('should derive a secp256k1 key with a public key and a two-link chain', async () => {
       const client = new DstackClientV1()
-      const result = await client.getKey('wallet', 'secp256k1')
+      const result = await client.getKey('storage-encryption', 'secp256k1')
       expect(result.key).toBeInstanceOf(Uint8Array)
       expect(result.key.length).toBe(32)
       // SEC1 compressed, so the chain's first link commits to these exact bytes.
@@ -83,29 +83,29 @@ describe('DstackClientV1', () => {
 
     it('should derive an ed25519 key with a 32-byte public key', async () => {
       const client = new DstackClientV1()
-      const result = await client.getKey('wallet', 'ed25519')
+      const result = await client.getKey('storage-encryption', 'ed25519')
       expect(result.key.length).toBe(32)
       expect(result.public_key.length).toBe(32)
       expect(result.signature_chain.length).toBe(2)
     })
 
     it('should be deterministic for the same domain and algorithm', async () => {
       const client = new DstackClientV1()
-      const first = await client.getKey('wallet', 'secp256k1')
-      const second = await client.getKey('wallet', 'secp256k1')
+      const first = await client.getKey('storage-encryption', 'secp256k1')
+      const second = await client.getKey('storage-encryption', 'secp256k1')
       expect(first.key).toEqual(second.key)
     })
 
     it('should separate the two curves, which v0 did not', async () => {
       const client = new DstackClientV1()
-      const secp = await client.getKey('wallet', 'secp256k1')
-      const ed = await client.getKey('wallet', 'ed25519')
+      const secp = await client.getKey('storage-encryption', 'secp256k1')
+      const ed = await client.getKey('storage-encryption', 'ed25519')
       expect(secp.key).not.toEqual(ed.key)
     })
 
     it('should derive different material than v0 for the same name', async () => {
-      const v0 = await new DstackClientV0().getKey('wallet', '', 'secp256k1')
-      const v1 = await new DstackClientV1().getKey('wallet', 'secp256k1')
+      const v0 = await new DstackClientV0().getKey('storage-encryption', '', 'secp256k1')
+      const v1 = await new DstackClientV1().getKey('storage-encryption', 'secp256k1')
       expect(v1.key).not.toEqual(v0.key)
     })
 
@@ -124,17 +124,17 @@ describe('DstackClientV1', () => {
 
     it('should reject an empty algorithm without a round trip', async () => {
       const client = new DstackClientV1()
-      await expect(() => client.getKey('wallet', '')).rejects.toThrow('algorithm is required')
+      await expect(() => client.getKey('storage-encryption', '')).rejects.toThrow('algorithm is required')
     })
 
     it('should reject the v0 k256 alias', async () => {
       const client = new DstackClientV1()
-      await expect(() => client.getKey('wallet', 'k256')).rejects.toThrow()
+      await expect(() => client.getKey('storage-encryption', 'k256')).rejects.toThrow()
     })
 
     it('should reject secp256k1_prehashed, which named a signing mode', async () => {
       const client = new DstackClientV1()
-      await expect(() => client.getKey('wallet', 'secp256k1_prehashed')).rejects.toThrow()
+      await expect(() => client.getKey('storage-encryption', 'secp256k1_prehashed')).rejects.toThrow()
     })
   })
 

sdk/python/tests/test_client_v1.py

@@ -43,9 +43,9 @@ def test_v0_call_shapes_fail_loudly_on_the_default_client():
     """
     client = DstackClient()
     with pytest.raises(TypeError):
-        client.get_key(path="wallet/eth", purpose="mainnet")
+        client.get_key(path="storage-encryption", purpose="mainnet")
     with pytest.raises(TypeError):
-        client.get_key("wallet/eth")
+        client.get_key("storage-encryption")
     for name in ["sign", "verify", "emit_event", "get_quote", "get_tls_key"]:
         assert not hasattr(client, name)
 
@@ -115,15 +115,15 @@ def check_info_response(result: InfoResponseV1):
 
 def test_sync_v1_get_key():
     client = DstackClientV1()
-    result = client.get_key("wallet/eth", "secp256k1")
+    result = client.get_key("storage-encryption", "secp256k1")
     assert isinstance(result, GetKeyResponseV1)
     assert len(result.decode_key()) == 32
     # secp256k1 public keys are SEC1 compressed, and the chain's first link
     # commits to exactly these bytes.
     assert len(result.decode_public_key()) == 33
     assert len(result.decode_signature_chain()) == 2
 
-    ed = client.get_key("wallet/eth", "ed25519")
+    ed = client.get_key("storage-encryption", "ed25519")
     assert len(ed.decode_key()) == 32
     assert len(ed.decode_public_key()) == 32
     # The v1 KDF binds the algorithm, so one name no longer serves two curves.
@@ -144,22 +144,22 @@ async def test_async_v1_get_key_is_deterministic_per_domain():
 def test_v1_get_key_requires_an_algorithm():
     client = DstackClientV1()
     with pytest.raises(ValueError, match="algorithm is required"):
-        client.get_key("wallet/eth", "")
+        client.get_key("storage-encryption", "")
 
 
 @pytest.mark.asyncio
 async def test_async_v1_get_key_rejects_the_v0_k256_alias():
     """v0 accepted `k256`; v1 refuses rather than guess what the caller meant."""
     client = AsyncDstackClientV1()
     with pytest.raises(Exception) as excinfo:
-        await client.get_key("wallet/eth", "k256")
+        await client.get_key("storage-encryption", "k256")
     assert "k256" in str(excinfo.value)
 
 
 def test_v1_keys_differ_from_v0_keys():
     """No compatibility mode: the same name yields different key material."""
-    v0 = DstackClientV0().get_key("wallet/eth", "")
-    v1 = DstackClientV1().get_key("wallet/eth", "secp256k1")
+    v0 = DstackClientV0().get_key("storage-encryption", "")
+    v1 = DstackClientV1().get_key("storage-encryption", "secp256k1")
     assert v1.decode_key() != v0.decode_key()