Merge pull request #256 from Dstack-TEE/sdk-compat

jssdk: Add back TappdClient for compatibility

Author: kvinwang

sdk/js/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phala/dstack-sdk",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "description": "Dstack SDK",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

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

@@ -1,8 +1,20 @@
 import { expect, describe, it, vi } from 'vitest'
-import { DstackClient } from '../index'
+import { DstackClient, TappdClient } from '../index'
 
 describe('DstackClient', () => {
-  it('should able to derive key', async () => {
+  it('should able to derive key in TappdClient', async () => {
+    const client = new TappdClient()
+    const result = await client.deriveKey('/', 'test')
+    expect(result).toHaveProperty('key')
+    expect(result).toHaveProperty('certificate_chain')
+  })
+
+  it('should throws error in DstackClient', async () => {
+    const client = new DstackClient()
+    await expect(() => client.deriveKey('/', 'test')).rejects.toThrow('deriveKey is deprecated, please use getKey instead.')
+  })
+
+  it('should able to get key', async () => {
     const client = new DstackClient()
     const result = await client.getKey('/', 'test')
     expect(result).toHaveProperty('key')
@@ -139,21 +151,21 @@ describe('DstackClient', () => {
     expect(typeof isReachable).toBe('boolean')
   })
 
-  describe('deprecated methods', () => {
+  describe('deprecated methods with TappdClient', () => {
     it('should support deprecated deriveKey method with warning', async () => {
-      const client = new DstackClient()
+      const client = new TappdClient()
       const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
 
       const result = await client.deriveKey('/', 'test')
       expect(result).toHaveProperty('key')
-      expect(result).toHaveProperty('signature_chain')
+      expect(result).toHaveProperty('certificate_chain')
       expect(consoleSpy).toHaveBeenCalledWith('deriveKey is deprecated, please use getKey instead')
 
       consoleSpy.mockRestore()
     })
 
     it('should support deprecated tdxQuote method with warning', async () => {
-      const client = new DstackClient()
+      const client = new TappdClient()
       const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
 
       const result = await client.tdxQuote('test data')
@@ -165,7 +177,7 @@ describe('DstackClient', () => {
     })
 
     it('should support tdxQuote with hash algorithm parameter', async () => {
-      const client = new DstackClient()
+      const client = new TappdClient()
       const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
 
       const result = await client.tdxQuote('test data', 'sha256')
@@ -176,4 +188,54 @@ describe('DstackClient', () => {
       consoleSpy.mockRestore()
     })
   })
+
+  describe('deprecated methods with DstackClient', () => {
+    it('should throws error in deriveKey method', async () => {
+      const client = new DstackClient()
+      const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+      
+      await expect(() => client.deriveKey('/', 'test')).rejects.toThrow('deriveKey is deprecated, please use getKey instead.')
+      
+      consoleSpy.mockRestore()
+    })
+
+    it('should throws error in tdxQuote method without hash algorithm parameter', async () => {
+      const client = new DstackClient()
+      const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+      
+      await expect(() => client.tdxQuote('test data')).rejects.toThrow('tdxQuote only supports raw hash algorithm.')
+
+      consoleSpy.mockRestore()
+    })
+
+    it("should throws error in tdxQuote method with hash algorithm parameter other than raw", async () => {
+      const client = new DstackClient()
+      const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+      
+      await expect(() => client.tdxQuote('test data', 'sha256')).rejects.toThrow('tdxQuote only supports raw hash algorithm.')
+
+      consoleSpy.mockRestore()
+    })
+
+    it('should able to get quote with plain report_data in tdxQuote method with warning', async () => {
+      const client = new DstackClient()
+      const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+      
+      const result = await client.tdxQuote('test data', "raw")
+      expect(result).toHaveProperty('quote')
+      expect(result).toHaveProperty('event_log')
+      expect(consoleSpy).toHaveBeenCalledWith('tdxQuote is deprecated, please use getQuote instead')
+
+      consoleSpy.mockRestore()
+    })
+
+    it('should throws error in tdxQuote with hash algorithm parameter', async () => {
+      const client = new DstackClient()
+      const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+      
+      await expect(() => client.tdxQuote('test data', 'sha256')).rejects.toThrow('tdxQuote only supports raw hash algorithm.')
+      
+      consoleSpy.mockRestore()
+    })
+  })
 })

sdk/js/src/__tests__/solana.test.ts

@@ -1,15 +1,96 @@
-import { expect, describe, it } from 'vitest'
+import crypto from 'crypto'
+import { expect, describe, it, vi } from 'vitest'
 import { Keypair } from '@solana/web3.js'
 
-import { DstackClient } from '../index'
-import { toKeypair } from '../solana'
+import { DstackClient, TappdClient } from '../index'
+import { toKeypair, toKeypairSecure } from '../solana'
 
 describe('solana support', () => {
-  it('should able to get keypair from deriveKey', async () => {
-    const client = new DstackClient()
-    const result = await client.getKey('/', 'test')
-    const keypair = toKeypair(result)
-    expect(keypair).toBeInstanceOf(Keypair)
-    console.log(keypair.publicKey.toBase58())
+  describe('toKeypair (legacy)', () => {
+    it('should able to get keypair from getKey with DstackClient', async () => {
+      const client = new DstackClient()
+      const result = await client.getKey('/', 'test')
+      const keypair = toKeypair(result)
+      expect(keypair).toBeInstanceOf(Keypair)
+      expect(keypair.secretKey.length).toBe(64)
+    })
+
+    it('should able to get keypair from deriveKey with TappdClient', async () => {
+      const client = new TappdClient()
+      const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+      
+      const result = await client.deriveKey('/', 'test')
+      const keypair = toKeypair(result)
+      expect(keypair).toBeInstanceOf(Keypair)
+      expect(keypair.secretKey.length).toBe(64)
+      expect(consoleSpy).toHaveBeenCalledWith('toKeypair: Please don\'t use `deriveKey` method to get key, use `getKey` instead.')
+      
+      consoleSpy.mockRestore()
+    })
+
+    it('should able to get keypair from getTlsKey with DstackClient', async () => {
+      const client = new DstackClient()
+      const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+      
+      const result = await client.getTlsKey()
+      const keypair = toKeypair(result)
+      expect(keypair).toBeInstanceOf(Keypair)
+      expect(keypair.secretKey.length).toBe(64)
+      expect(consoleSpy).toHaveBeenCalledWith('toKeypair: Please don\'t use `deriveKey` method to get key, use `getKey` instead.')
+      
+      consoleSpy.mockRestore()
+    })
+  })
+
+  describe('toKeypairSecure', () => {
+    it('should able to get keypair from getKey with DstackClient', async () => {
+      const client = new DstackClient()
+      const result = await client.getKey('/', 'test')
+      const keypair = toKeypairSecure(result)
+      expect(keypair).toBeInstanceOf(Keypair)
+      expect(keypair.secretKey.length).toBe(64)
+    })
+
+    it('should able to get keypair from deriveKey with TappdClient', async () => {
+      const client = new TappdClient()
+      const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+      
+      const result = await client.deriveKey('/', 'test')
+      const keypair = toKeypairSecure(result)
+      expect(keypair).toBeInstanceOf(Keypair)
+      expect(keypair.secretKey.length).toBe(64)
+      expect(consoleSpy).toHaveBeenCalledWith('toKeypairSecure: Please don\'t use `deriveKey` method to get key, use `getKey` instead.')
+      
+      consoleSpy.mockRestore()
+    })
+
+    it('should able to get keypair from getTlsKey with DstackClient', async () => {
+      const client = new DstackClient()
+      const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+      
+      const result = await client.getTlsKey()
+      const keypair = toKeypairSecure(result)
+      expect(keypair).toBeInstanceOf(Keypair)
+      expect(keypair.secretKey.length).toBe(64)
+      expect(consoleSpy).toHaveBeenCalledWith('toKeypairSecure: Please don\'t use `deriveKey` method to get key, use `getKey` instead.')
+      
+      consoleSpy.mockRestore()
+    })
+
+    it('should throw error when sha256 is not supported', async () => {
+      const client = new DstackClient()
+      const result = await client.getTlsKey()
+      
+      // Mock crypto.createHash to simulate missing sha256 support
+      const originalCreateHash = crypto.createHash
+      crypto.createHash = () => {
+        throw new Error('sha256 not supported')
+      }
+      
+      expect(() => toKeypairSecure(result)).toThrow('toKeypairSecure: missing sha256 support')
+      
+      // Restore original createHash
+      crypto.createHash = originalCreateHash
+    })
   })
 })

sdk/js/src/__tests__/viem.test.ts

@@ -1,15 +1,106 @@
-import { expect, describe, it } from 'vitest'
-import { DstackClient } from '../index'
-import { toViemAccount } from '../viem'
+import crypto from 'crypto'
+import { expect, describe, it, vi } from 'vitest'
+import { DstackClient, TappdClient } from '../index'
+import { toViemAccount, toViemAccountSecure } from '../viem'
 
 describe('viem support', () => {
-  it('should able to get account from getKey', async () => {
-    const client = new DstackClient()
-    const result = await client.getKey('/', 'test')
-    const account = toViemAccount(result)
-
-    expect(account.source).toBe('privateKey')
-    expect(typeof account.sign).toBe('function')
-    expect(typeof account.signMessage).toBe('function')
+  describe('toViemAccount (legacy)', () => {
+    it('should able to get account from getKey with DstackClient', async () => {
+      const client = new DstackClient()
+      const result = await client.getKey('/', 'test')
+      const account = toViemAccount(result)
+  
+      expect(account.source).toBe('privateKey')
+      expect(typeof account.sign).toBe('function')
+      expect(typeof account.signMessage).toBe('function')
+    })
+
+    it('should able to get account from deriveKey with TappdClient', async () => {
+      const client = new TappdClient()
+      const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+      
+      const result = await client.deriveKey('/', 'test')
+      const account = toViemAccount(result)
+  
+      expect(account.source).toBe('privateKey')
+      expect(typeof account.sign).toBe('function')
+      expect(typeof account.signMessage).toBe('function')
+      expect(consoleSpy).toHaveBeenCalledWith('toViemAccount: Please don\'t use `deriveKey` method to get key, use `getKey` instead.')
+      
+      consoleSpy.mockRestore()
+    })
+
+    it('should able to get account from getTlsKey with DstackClient', async () => {
+      const client = new DstackClient()
+      const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+      
+      const result = await client.getTlsKey()
+      const account = toViemAccount(result)
+  
+      expect(account.source).toBe('privateKey')
+      expect(typeof account.sign).toBe('function')
+      expect(typeof account.signMessage).toBe('function')
+      expect(consoleSpy).toHaveBeenCalledWith('toViemAccount: Please don\'t use `deriveKey` method to get key, use `getKey` instead.')
+      
+      consoleSpy.mockRestore()
+    })
+  })
+
+  describe('toViemAccountSecure', () => {
+    it('should able to get account from getKey with DstackClient', async () => {
+      const client = new DstackClient()
+      const result = await client.getKey('/', 'test')
+      const account = toViemAccountSecure(result)
+  
+      expect(account.source).toBe('privateKey')
+      expect(typeof account.sign).toBe('function')
+      expect(typeof account.signMessage).toBe('function')
+    })
+
+    it('should able to get account from deriveKey with TappdClient', async () => {
+      const client = new TappdClient()
+      const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+      
+      const result = await client.deriveKey('/', 'test')
+      const account = toViemAccountSecure(result)
+  
+      expect(account.source).toBe('privateKey')
+      expect(typeof account.sign).toBe('function')
+      expect(typeof account.signMessage).toBe('function')
+      expect(consoleSpy).toHaveBeenCalledWith('toViemAccountSecure: Please don\'t use `deriveKey` method to get key, use `getKey` instead.')
+      
+      consoleSpy.mockRestore()
+    })
+
+    it('should able to get account from getTlsKey with DstackClient', async () => {
+      const client = new DstackClient()
+      const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+      
+      const result = await client.getTlsKey()
+      const account = toViemAccountSecure(result)
+  
+      expect(account.source).toBe('privateKey')
+      expect(typeof account.sign).toBe('function')
+      expect(typeof account.signMessage).toBe('function')
+      expect(consoleSpy).toHaveBeenCalledWith('toViemAccountSecure: Please don\'t use `deriveKey` method to get key, use `getKey` instead.')
+      
+      consoleSpy.mockRestore()
+    })
+
+    it('should throw error when sha256 is not supported', async () => {
+      const client = new DstackClient()
+      const result = await client.getTlsKey()
+      
+      // Mock crypto.createHash to simulate missing sha256 support
+      const originalCreateHash = crypto.createHash
+      crypto.createHash = () => {
+        throw new Error('sha256 not supported')
+      }
+      
+      expect(() => toViemAccountSecure(result)).toThrow('toViemAccountSecure: missing sha256 support')
+      
+      // Restore original createHash
+      crypto.createHash = originalCreateHash
+    })
   })
 })