Hive MCP Server

Verified
ISC License
OverviewInspectSchema Related Servers Reviews Score
tests
tools
// tests/tools/crypto.test.ts
import { PrivateKey, cryptoUtils } from '@hiveio/dhive';
import { signMessage, verifySignature } from '../../src/tools/crypto';
import { canRunAuthenticatedTests } from '../utils/test-helpers';

describe('Crypto Tools', () => {
  // Skip all tests if we can't run authenticated tests
  const maybeDescribe = canRunAuthenticatedTests() ? describe : describe.skip;
  
  maybeDescribe('signMessage and verifySignature', () => {
    it('should sign a message and verify the signature', async () => {
      // Only run test if posting key is available
      if (!process.env.HIVE_POSTING_KEY) {
        return;
      }
      
      // Arrange
      const testMessage = 'This is a test message for signature verification';
      
      // Act - Sign the message
      const signResult = await signMessage({ 
        message: testMessage, 
        key_type: 'posting'
      });
      
      // Assert signature result
      expect(signResult).toBeDefined();
      expect(signResult.isError).toBeUndefined();
      
      const signData = JSON.parse(signResult.content[0].text);
      expect(signData.success).toBe(true);
      expect(signData.signature).toBeDefined();
      expect(signData.public_key).toBeDefined();
      expect(signData.message_hash).toBeDefined();
      
      // Now verify the signature
      const verifyResult = await verifySignature({
        message_hash: signData.message_hash,
        signature: signData.signature,
        public_key: signData.public_key
      });
      
      // Assert verification result
      expect(verifyResult).toBeDefined();
      expect(verifyResult.isError).toBeUndefined();
      
      const verifyData = JSON.parse(verifyResult.content[0].text);
      expect(verifyData.success).toBe(true);
      expect(verifyData.is_valid).toBe(true);
    });
    
    it('should return error for invalid signature', async () => {
      // Only run test if posting key is available
      if (!process.env.HIVE_POSTING_KEY) {
        return;
      }
      
      // Generate a message hash
      const testMessage = 'Test message';
      const messageHash = cryptoUtils.sha256(testMessage).toString('hex');
      
      // Create an invalid signature
      const invalidSignature = 'SIG_K1_INVALID_SIGNATURE_FOR_TESTING';
      
      // Generate a test public key
      const tempPrivateKey = PrivateKey.fromSeed('test');
      const publicKey = tempPrivateKey.createPublic().toString();
      
      // Act - Verify with invalid signature
      const verifyResult = await verifySignature({
        message_hash: messageHash,
        signature: invalidSignature,
        public_key: publicKey
      });
      
      // Assert verification result shows error
      expect(verifyResult).toBeDefined();
      expect(verifyResult.isError).toBe(true);
      expect(verifyResult.content[0].text).toContain('Error');
    });
  });
  
  // Test for error handling when environment variables are not set
  describe('Environment variable handling', () => {
    const originalEnv = process.env;
    
    // Save environment variables
    beforeEach(() => {
      jest.resetModules();
      process.env = { ...originalEnv };
    });
    
    // Restore environment variables after tests
    afterAll(() => {
      process.env = originalEnv;
    });
    
    it('should handle missing private keys gracefully', async () => {
      // Try to sign a message with a key_type that corresponds to a missing environment variable
      const signResult = await signMessage({
        message: 'Test message',
        key_type: 'owner',
      });
      
      // Should return error about missing environment variable
      expect(signResult).toBeDefined();
      expect(signResult.isError).toBe(true);
      expect(signResult.content[0].text).toContain('HIVE_OWNER_KEY');
      expect(signResult.content[0].text).toContain('not set');
    });
  });
});