@claritydao/midnight-agora-sdk 0.1.0

package/test/types.test.ts

@@ -0,0 +1,112 @@
+/**
+ * Tests for production-ready type system
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  VoteChoice,
+  ProposalStatus,
+  ConfigPresets,
+  type DeploymentConfig,
+  type GovernanceConfig,
+  type TokenConfig,
+  type ProposalAction,
+} from '../src/index';
+
+describe('Type System', () => {
+  describe('VoteChoice Enum', () => {
+    it('should have correct vote choice values', () => {
+      expect(VoteChoice.For).toBe(0);
+      expect(VoteChoice.Against).toBe(1);
+      expect(VoteChoice.Abstain).toBe(2);
+    });
+
+    it('should be type-safe', () => {
+      const choice: VoteChoice = VoteChoice.For;
+      expect(choice).toBe(0);
+    });
+  });
+
+  describe('ProposalStatus Enum', () => {
+    it('should have all status values', () => {
+      expect(ProposalStatus.Pending).toBe(0);
+      expect(ProposalStatus.Active).toBe(1);
+      expect(ProposalStatus.Succeeded).toBe(2);
+      expect(ProposalStatus.Defeated).toBe(3);
+      expect(ProposalStatus.Queued).toBe(4);
+      expect(ProposalStatus.Executed).toBe(5);
+      expect(ProposalStatus.Expired).toBe(6);
+      expect(ProposalStatus.Canceled).toBe(7);
+    });
+  });
+
+  describe('ConfigPresets', () => {
+    it('should provide testing configuration', () => {
+      const config = ConfigPresets.testing();
+
+      expect(config.votingPeriod).toBe(BigInt(300)); // 5 minutes
+      expect(config.quorumThreshold).toBe(BigInt(100));
+      expect(config.proposalThreshold).toBe(BigInt(100));
+      expect(config.minStakeAmount).toBe(BigInt(10));
+    });
+
+    it('should provide production configuration', () => {
+      const config = ConfigPresets.production();
+
+      expect(config.votingPeriod).toBe(BigInt(604800)); // 7 days
+      expect(config.quorumThreshold).toBe(BigInt(100000));
+      expect(config.proposalThreshold).toBe(BigInt(50000));
+      expect(config.minStakeAmount).toBe(BigInt(1000));
+    });
+
+    it('testing config should have shorter periods than production', () => {
+      const testing = ConfigPresets.testing();
+      const production = ConfigPresets.production();
+
+      expect(testing.votingPeriod < production.votingPeriod).toBe(true);
+      expect(testing.quorumThreshold < production.quorumThreshold).toBe(true);
+      expect(testing.proposalThreshold < production.proposalThreshold).toBe(true);
+    });
+  });
+
+  describe('Type Definitions', () => {
+    it('should have valid DeploymentConfig structure', () => {
+      const config: DeploymentConfig = {
+        governor: {
+          governance: ConfigPresets.testing(),
+          executionDelay: BigInt(60),
+          gracePeriod: BigInt(300),
+          maxActiveProposals: BigInt(100),
+          proposalLifetime: BigInt(3600),
+          emergencyVetoEnabled: true,
+          emergencyVetoThreshold: BigInt(75000),
+        },
+        token: {
+          name: 'Test DAO',
+          symbol: 'TDAO',
+          decimals: BigInt(18),
+        },
+        adminKey: new Uint8Array(32),
+      };
+
+      expect(config.governor.governance).toBeDefined();
+      expect(config.token.name).toBe('Test DAO');
+      expect(config.adminKey.length).toBe(32);
+    });
+
+    it('should have valid ProposalAction structure', () => {
+      const action: ProposalAction = {
+        typ: 0,
+        token: new Uint8Array(32),
+        amount: BigInt(1000),
+        to: new Uint8Array(32),
+        configKey: new Uint8Array(32),
+        configValue: new Uint8Array(32),
+      };
+
+      expect(action.typ).toBe(0);
+      expect(action.amount).toBe(BigInt(1000));
+      expect(action.token.length).toBe(32);
+    });
+  });
+});

package/test/utils.test.ts

@@ -0,0 +1,111 @@
+/**
+ * Tests for utility functions
+ */
+
+import { describe, it, expect } from 'vitest';
+import { randomBytes, addressToBytes, bytesToHex, hexToBytes } from '../src/utils';
+
+describe('Utility Functions', () => {
+  describe('randomBytes', () => {
+    it('should generate correct length', () => {
+      const bytes = randomBytes(32);
+      expect(bytes.length).toBe(32);
+      expect(bytes).toBeInstanceOf(Uint8Array);
+    });
+
+    it('should generate different values each time', () => {
+      const bytes1 = randomBytes(32);
+      const bytes2 = randomBytes(32);
+
+      // Extremely unlikely to be equal
+      expect(bytes1).not.toEqual(bytes2);
+    });
+
+    it('should generate non-zero values', () => {
+      const bytes = randomBytes(32);
+      const hasNonZero = Array.from(bytes).some(b => b !== 0);
+      expect(hasNonZero).toBe(true);
+    });
+  });
+
+  describe('bytesToHex', () => {
+    it('should convert bytes to hex string', () => {
+      const bytes = new Uint8Array([0, 1, 15, 255]);
+      const hex = bytesToHex(bytes);
+      expect(hex).toBe('00010fff');
+    });
+
+    it('should handle empty array', () => {
+      const bytes = new Uint8Array([]);
+      const hex = bytesToHex(bytes);
+      expect(hex).toBe('');
+    });
+
+    it('should pad single digits with zero', () => {
+      const bytes = new Uint8Array([0, 1, 2, 15]);
+      const hex = bytesToHex(bytes);
+      expect(hex).toBe('0001020f');
+    });
+  });
+
+  describe('hexToBytes', () => {
+    it('should convert hex string to bytes', () => {
+      const hex = '00010fff';
+      const bytes = hexToBytes(hex);
+      expect(bytes).toEqual(new Uint8Array([0, 1, 15, 255]));
+    });
+
+    it('should handle 0x prefix', () => {
+      const hex = '0x00010fff';
+      const bytes = hexToBytes(hex);
+      expect(bytes).toEqual(new Uint8Array([0, 1, 15, 255]));
+    });
+
+    it('should handle empty string', () => {
+      const hex = '';
+      const bytes = hexToBytes(hex);
+      expect(bytes).toEqual(new Uint8Array([]));
+    });
+  });
+
+  describe('bytesToHex and hexToBytes round-trip', () => {
+    it('should be reversible', () => {
+      const original = new Uint8Array([0, 1, 15, 127, 255]);
+      const hex = bytesToHex(original);
+      const decoded = hexToBytes(hex);
+      expect(decoded).toEqual(original);
+    });
+
+    it('should work with random bytes', () => {
+      const original = randomBytes(32);
+      const hex = bytesToHex(original);
+      const decoded = hexToBytes(hex);
+      expect(decoded).toEqual(original);
+    });
+  });
+
+  describe('addressToBytes', () => {
+    it('should convert address string to 32 bytes', () => {
+      const address = 'mn_shield-addr_test1n3axpjpcwj8fjutdfqa9jnum8x7zvu8u7382pw4u99zax3qwdndqxq85jv7yda6yls72sqsgx8hqkvr7fzatfykypp7au3ye9qrysa3wru5e4wz9';
+      const bytes = addressToBytes(address);
+
+      expect(bytes).toBeInstanceOf(Uint8Array);
+      expect(bytes.length).toBe(32);
+    });
+
+    it('should handle addresses without prefix', () => {
+      const address = 'abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890';
+      const bytes = addressToBytes(address);
+
+      expect(bytes.length).toBe(32);
+    });
+
+    it('should extract last 64 hex chars', () => {
+      const address = 'prefix_1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef';
+      const bytes = addressToBytes(address);
+
+      // Should extract the 64 hex chars (32 bytes)
+      expect(bytes.length).toBe(32);
+    });
+  });
+});

package/test/validators.test.ts

@@ -0,0 +1,368 @@
+/**
+ * Tests for validation functions
+ */
+
+import { describe, it, expect } from 'vitest';
+import { validators } from '../src/index';
+import { VoteChoice, ConfigPresets } from '../src/index';
+import {
+  InvalidParameterError,
+  InvalidConfigurationError,
+} from '../src/index';
+
+describe('Validators', () => {
+  describe('validateProposal', () => {
+    it('should accept valid proposal parameters', () => {
+      const title = 'Valid Proposal Title';
+      const description = 'This is a valid proposal description';
+      const creator = new Uint8Array(32);
+
+      expect(() => {
+        validators.validateProposal(title, description, creator);
+      }).not.toThrow();
+    });
+
+    it('should reject empty title', () => {
+      const title = '';
+      const description = 'Valid description';
+      const creator = new Uint8Array(32);
+
+      expect(() => {
+        validators.validateProposal(title, description, creator);
+      }).toThrow(InvalidParameterError);
+    });
+
+    it('should reject title that is too long', () => {
+      const title = 'a'.repeat(257); // Max is 256
+      const description = 'Valid description';
+      const creator = new Uint8Array(32);
+
+      expect(() => {
+        validators.validateProposal(title, description, creator);
+      }).toThrow(InvalidParameterError);
+    });
+
+    it('should reject empty description', () => {
+      const title = 'Valid title';
+      const description = '';
+      const creator = new Uint8Array(32);
+
+      expect(() => {
+        validators.validateProposal(title, description, creator);
+      }).toThrow(InvalidParameterError);
+    });
+
+    it('should reject description that is too long', () => {
+      const title = 'Valid title';
+      const description = 'a'.repeat(10001); // Max is 10000
+      const creator = new Uint8Array(32);
+
+      expect(() => {
+        validators.validateProposal(title, description, creator);
+      }).toThrow(InvalidParameterError);
+    });
+
+    it('should reject invalid creator address (not 32 bytes)', () => {
+      const title = 'Valid title';
+      const description = 'Valid description';
+      const creator = new Uint8Array(16); // Should be 32
+
+      expect(() => {
+        validators.validateProposal(title, description, creator);
+      }).toThrow(InvalidParameterError);
+    });
+
+    it('should reject non-Uint8Array creator', () => {
+      const title = 'Valid title';
+      const description = 'Valid description';
+      const creator = [1, 2, 3] as any;
+
+      expect(() => {
+        validators.validateProposal(title, description, creator);
+      }).toThrow(InvalidParameterError);
+    });
+  });
+
+  describe('validateVoteChoice', () => {
+    it('should accept VoteChoice.For', () => {
+      expect(() => {
+        validators.validateVoteChoice(VoteChoice.For);
+      }).not.toThrow();
+    });
+
+    it('should accept VoteChoice.Against', () => {
+      expect(() => {
+        validators.validateVoteChoice(VoteChoice.Against);
+      }).not.toThrow();
+    });
+
+    it('should accept VoteChoice.Abstain', () => {
+      expect(() => {
+        validators.validateVoteChoice(VoteChoice.Abstain);
+      }).not.toThrow();
+    });
+
+    it('should reject invalid vote choice (3)', () => {
+      expect(() => {
+        validators.validateVoteChoice(3 as any);
+      }).toThrow(InvalidParameterError);
+    });
+
+    it('should reject invalid vote choice (-1)', () => {
+      expect(() => {
+        validators.validateVoteChoice(-1 as any);
+      }).toThrow(InvalidParameterError);
+    });
+  });
+
+  describe('validateAddress', () => {
+    it('should accept valid 32-byte address', () => {
+      const address = new Uint8Array(32);
+
+      expect(() => {
+        validators.validateAddress(address, 'testAddress');
+      }).not.toThrow();
+    });
+
+    it('should reject address that is too short', () => {
+      const address = new Uint8Array(31);
+
+      expect(() => {
+        validators.validateAddress(address, 'testAddress');
+      }).toThrow(InvalidParameterError);
+    });
+
+    it('should reject address that is too long', () => {
+      const address = new Uint8Array(33);
+
+      expect(() => {
+        validators.validateAddress(address, 'testAddress');
+      }).toThrow(InvalidParameterError);
+    });
+
+    it('should reject non-Uint8Array', () => {
+      const address = 'not-a-uint8array' as any;
+
+      expect(() => {
+        validators.validateAddress(address, 'testAddress');
+      }).toThrow(InvalidParameterError);
+    });
+  });
+
+  describe('validateGovernanceConfig', () => {
+    it('should accept valid testing config', () => {
+      const config = ConfigPresets.testing();
+
+      expect(() => {
+        validators.validateGovernanceConfig(config);
+      }).not.toThrow();
+    });
+
+    it('should accept valid production config', () => {
+      const config = ConfigPresets.production();
+
+      expect(() => {
+        validators.validateGovernanceConfig(config);
+      }).not.toThrow();
+    });
+
+    it('should reject config with votingPeriod less than 60', () => {
+      const config = {
+        ...ConfigPresets.testing(),
+        votingPeriod: BigInt(59), // Less than minimum
+      };
+
+      expect(() => {
+        validators.validateGovernanceConfig(config);
+      }).toThrow(InvalidConfigurationError);
+    });
+
+    it('should reject config where proposalThreshold > quorumThreshold', () => {
+      const config = {
+        ...ConfigPresets.testing(),
+        proposalThreshold: BigInt(200),
+        quorumThreshold: BigInt(100), // Should be >= proposalThreshold
+      };
+
+      expect(() => {
+        validators.validateGovernanceConfig(config);
+      }).toThrow(InvalidConfigurationError);
+    });
+
+    it('should reject negative values', () => {
+      const config = {
+        ...ConfigPresets.testing(),
+        executionDelay: BigInt(-1),
+      };
+
+      expect(() => {
+        validators.validateGovernanceConfig(config);
+      }).toThrow(InvalidParameterError);
+    });
+  });
+
+  describe('validateTokenConfig', () => {
+    it('should accept valid token config', () => {
+      const config = {
+        name: 'My DAO Token',
+        symbol: 'MDAO',
+        decimals: BigInt(18),
+      };
+
+      expect(() => {
+        validators.validateTokenConfig(config);
+      }).not.toThrow();
+    });
+
+    it('should reject empty token name', () => {
+      const config = {
+        name: '',
+        symbol: 'MDAO',
+        decimals: BigInt(18),
+      };
+
+      expect(() => {
+        validators.validateTokenConfig(config);
+      }).toThrow(InvalidParameterError);
+    });
+
+    it('should reject token name that is too long', () => {
+      const config = {
+        name: 'a'.repeat(65), // Max is 64
+        symbol: 'MDAO',
+        decimals: BigInt(18),
+      };
+
+      expect(() => {
+        validators.validateTokenConfig(config);
+      }).toThrow(InvalidParameterError);
+    });
+
+    it('should reject empty token symbol', () => {
+      const config = {
+        name: 'My DAO Token',
+        symbol: '',
+        decimals: BigInt(18),
+      };
+
+      expect(() => {
+        validators.validateTokenConfig(config);
+      }).toThrow(InvalidParameterError);
+    });
+
+    it('should reject token symbol that is too long', () => {
+      const config = {
+        name: 'My DAO Token',
+        symbol: 'a'.repeat(17), // Max is 16
+        decimals: BigInt(18),
+      };
+
+      expect(() => {
+        validators.validateTokenConfig(config);
+      }).toThrow(InvalidParameterError);
+    });
+
+    it('should reject decimals greater than 18', () => {
+      const config = {
+        name: 'My DAO Token',
+        symbol: 'MDAO',
+        decimals: BigInt(19),
+      };
+
+      expect(() => {
+        validators.validateTokenConfig(config);
+      }).toThrow(InvalidConfigurationError);
+    });
+
+    it('should reject zero decimals', () => {
+      const config = {
+        name: 'My DAO Token',
+        symbol: 'MDAO',
+        decimals: BigInt(0),
+      };
+
+      expect(() => {
+        validators.validateTokenConfig(config);
+      }).toThrow(InvalidParameterError);
+    });
+  });
+
+  describe('validateDeploymentConfig', () => {
+    it('should accept valid deployment config', () => {
+      const governanceConfig = ConfigPresets.testing();
+      const config = {
+        governor: {
+          governance: governanceConfig,
+          executionDelay: governanceConfig.executionDelay,
+          gracePeriod: governanceConfig.gracePeriod,
+          maxActiveProposals: BigInt(100),
+          proposalLifetime: governanceConfig.proposalLifetime,
+          emergencyVetoEnabled: true,
+          emergencyVetoThreshold: BigInt(75000),
+        },
+        token: {
+          name: 'Test DAO',
+          symbol: 'TDAO',
+          decimals: BigInt(18),
+        },
+        adminKey: new Uint8Array(32),
+      };
+
+      expect(() => {
+        validators.validateDeploymentConfig(config);
+      }).not.toThrow();
+    });
+
+    it('should reject config with invalid admin key length', () => {
+      const governanceConfig = ConfigPresets.testing();
+      const config = {
+        governor: {
+          governance: governanceConfig,
+          executionDelay: governanceConfig.executionDelay,
+          gracePeriod: governanceConfig.gracePeriod,
+          maxActiveProposals: BigInt(100),
+          proposalLifetime: governanceConfig.proposalLifetime,
+          emergencyVetoEnabled: true,
+          emergencyVetoThreshold: BigInt(75000),
+        },
+        token: {
+          name: 'Test DAO',
+          symbol: 'TDAO',
+          decimals: BigInt(18),
+        },
+        adminKey: new Uint8Array(16), // Should be 32
+      };
+
+      expect(() => {
+        validators.validateDeploymentConfig(config);
+      }).toThrow(InvalidParameterError);
+    });
+
+    it('should reject config with inconsistent executionDelay', () => {
+      const config = {
+        governor: {
+          governance: {
+            ...ConfigPresets.testing(),
+            executionDelay: BigInt(120),
+          },
+          executionDelay: BigInt(60), // Doesn't match governance.executionDelay
+          gracePeriod: BigInt(300),
+          maxActiveProposals: BigInt(100),
+          proposalLifetime: BigInt(3600),
+          emergencyVetoEnabled: true,
+          emergencyVetoThreshold: BigInt(75000),
+        },
+        token: {
+          name: 'Test DAO',
+          symbol: 'TDAO',
+          decimals: BigInt(18),
+        },
+        adminKey: new Uint8Array(32),
+      };
+
+      expect(() => {
+        validators.validateDeploymentConfig(config);
+      }).toThrow(InvalidConfigurationError);
+    });
+  });
+});