@claritydao/midnight-agora-sdk 0.2.0 → 1.2.0

package/test/errors.test.ts

@@ -1,179 +0,0 @@
-/**
- * Tests for error classes
- */
-
-import { describe, it, expect } from 'vitest';
-import {
-  GovernorSDKError,
-  WalletNotConnectedError,
-  InsufficientStakeError,
-  InvalidParameterError,
-  ContractNotFoundError,
-  ProposalNotFoundError,
-  TransactionError,
-  DeploymentError,
-  InvalidConfigurationError,
-  NetworkNotConfiguredError,
-} from '../src/index';
-
-describe('Error Classes', () => {
-  describe('GovernorSDKError', () => {
-    it('should be an instance of Error', () => {
-      const error = new GovernorSDKError('test error');
-      expect(error).toBeInstanceOf(Error);
-      expect(error.message).toBe('test error');
-      expect(error.name).toBe('GovernorSDKError');
-    });
-  });
-
-  describe('WalletNotConnectedError', () => {
-    it('should have correct default message', () => {
-      const error = new WalletNotConnectedError();
-      expect(error).toBeInstanceOf(GovernorSDKError);
-      expect(error.message).toBe('Wallet not connected. Please ensure Lace wallet is installed and connected.');
-      expect(error.name).toBe('WalletNotConnectedError');
-    });
-  });
-
-  describe('InsufficientStakeError', () => {
-    it('should include required and actual stake amounts', () => {
-      const required = BigInt(1000);
-      const actual = BigInt(500);
-      const error = new InsufficientStakeError(required, actual);
-
-      expect(error).toBeInstanceOf(GovernorSDKError);
-      expect(error.message).toContain('1000');
-      expect(error.message).toContain('500');
-      expect(error.name).toBe('InsufficientStakeError');
-    });
-
-    it('should format bigint values correctly', () => {
-      const error = new InsufficientStakeError(BigInt(5000), BigInt(2500));
-      expect(error.message).toMatch(/Required.*5000/);
-      expect(error.message).toMatch(/Actual.*2500/);
-    });
-  });
-
-  describe('InvalidParameterError', () => {
-    it('should include parameter name and reason', () => {
-      const error = new InvalidParameterError('proposalId', 'must be positive');
-
-      expect(error).toBeInstanceOf(GovernorSDKError);
-      expect(error.message).toContain('proposalId');
-      expect(error.message).toContain('must be positive');
-      expect(error.name).toBe('InvalidParameterError');
-    });
-  });
-
-  describe('ContractNotFoundError', () => {
-    it('should include contract address', () => {
-      const address = 'test-contract-address';
-      const error = new ContractNotFoundError(address);
-
-      expect(error).toBeInstanceOf(GovernorSDKError);
-      expect(error.message).toContain(address);
-      expect(error.name).toBe('ContractNotFoundError');
-    });
-  });
-
-  describe('ProposalNotFoundError', () => {
-    it('should include proposal ID', () => {
-      const proposalId = BigInt(42);
-      const error = new ProposalNotFoundError(proposalId);
-
-      expect(error).toBeInstanceOf(GovernorSDKError);
-      expect(error.message).toContain('42');
-      expect(error.name).toBe('ProposalNotFoundError');
-    });
-  });
-
-  describe('TransactionError', () => {
-    it('should have custom message', () => {
-      const error = new TransactionError('Transaction failed');
-
-      expect(error).toBeInstanceOf(GovernorSDKError);
-      expect(error.message).toBe('Transaction failed: Transaction failed');
-      expect(error.name).toBe('TransactionError');
-    });
-  });
-
-  describe('DeploymentError', () => {
-    it('should have custom message', () => {
-      const error = new DeploymentError('Deployment failed');
-
-      expect(error).toBeInstanceOf(GovernorSDKError);
-      expect(error.message).toBe('Contract deployment failed: Deployment failed');
-      expect(error.name).toBe('DeploymentError');
-    });
-  });
-
-  describe('InvalidConfigurationError', () => {
-    it('should have custom message', () => {
-      const error = new InvalidConfigurationError('Invalid voting period');
-
-      expect(error).toBeInstanceOf(GovernorSDKError);
-      expect(error.message).toBe('Invalid configuration: Invalid voting period');
-      expect(error.name).toBe('InvalidConfigurationError');
-    });
-  });
-
-  describe('NetworkNotConfiguredError', () => {
-    it('should have default message', () => {
-      const error = new NetworkNotConfiguredError();
-
-      expect(error).toBeInstanceOf(GovernorSDKError);
-      expect(error.message).toBe('Network ID not configured. Set window.midnight.mnLace.networkId before initializing providers.');
-      expect(error.name).toBe('NetworkNotConfiguredError');
-    });
-  });
-
-  describe('Error Inheritance', () => {
-    it('all custom errors should be instances of GovernorSDKError', () => {
-      const errors = [
-        new WalletNotConnectedError(),
-        new InsufficientStakeError(BigInt(100), BigInt(50)),
-        new InvalidParameterError('test', 'reason'),
-        new ContractNotFoundError('address'),
-        new ProposalNotFoundError(BigInt(1)),
-        new TransactionError('test'),
-        new DeploymentError('test'),
-        new InvalidConfigurationError('test'),
-        new NetworkNotConfiguredError(),
-      ];
-
-      errors.forEach((error) => {
-        expect(error).toBeInstanceOf(GovernorSDKError);
-        expect(error).toBeInstanceOf(Error);
-      });
-    });
-  });
-
-  describe('Error Handling Patterns', () => {
-    it('should be catchable by specific type', () => {
-      try {
-        throw new InsufficientStakeError(BigInt(1000), BigInt(500));
-      } catch (error) {
-        expect(error).toBeInstanceOf(InsufficientStakeError);
-        expect(error).toBeInstanceOf(GovernorSDKError);
-        if (error instanceof InsufficientStakeError) {
-          expect(error.message).toContain('Insufficient stake');
-        }
-      }
-    });
-
-    it('should be catchable by base GovernorSDKError type', () => {
-      const errors = [
-        new InvalidParameterError('test', 'reason'),
-        new TransactionError('test'),
-      ];
-
-      errors.forEach((error) => {
-        try {
-          throw error;
-        } catch (e) {
-          expect(e).toBeInstanceOf(GovernorSDKError);
-        }
-      });
-    });
-  });
-});

package/test/integration/governor-api.test.ts

@@ -1,370 +0,0 @@
-/**
- * Integration tests for GovernorAPI
- * Tests SDK logic with mocked providers (no real blockchain)
- */
-
-import { describe, it, expect, beforeEach } from 'vitest';
-import { createMockProviders, createFailingMockProviders } from '../mocks/providers';
-import type { GovernorProviders } from '../../src/common-types';
-import { VoteChoice, ConfigPresets } from '../../src/types';
-import { TransactionError } from '../../src/errors';
-import * as validators from '../../src/validators';
-
-describe('GovernorAPI Integration (Mocked)', () => {
-  let mockProviders: GovernorProviders;
-
-  beforeEach(() => {
-    mockProviders = createMockProviders();
-  });
-
-  describe('Provider Interaction', () => {
-    it('should use public data provider to query contract state', async () => {
-      const state = await mockProviders.publicDataProvider.queryContractState('mock-address');
-
-      expect(state).toBeDefined();
-      expect(state.governanceConfig).toBeDefined();
-      expect(mockProviders.publicDataProvider.queryContractState).toHaveBeenCalledWith('mock-address');
-    });
-
-    it('should use wallet provider to submit transactions', async () => {
-      const mockTx = { data: 'mock-transaction' };
-      const result = await mockProviders.walletProvider.submitTransaction(mockTx as any);
-
-      expect(result.public.txHash).toBe('mock-tx-hash');
-      expect(mockProviders.walletProvider.submitTransaction).toHaveBeenCalledWith(mockTx);
-    });
-
-    it('should handle transaction failures', async () => {
-      const failingProviders = createFailingMockProviders();
-
-      await expect(
-        failingProviders.walletProvider.submitTransaction({ data: 'mock-tx' } as any)
-      ).rejects.toThrow('Transaction failed');
-    });
-  });
-
-  describe('Configuration Validation', () => {
-    it('should validate deployment config before deployment', () => {
-      const governanceConfig = ConfigPresets.testing();
-      const validConfig = {
-        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),
-      };
-
-      // Should not throw
-      expect(() => {
-        validators.validateDeploymentConfig(validConfig);
-      }).not.toThrow();
-    });
-
-    it('should reject invalid deployment config', () => {
-      const invalidConfig = {
-        governor: {
-          governance: ConfigPresets.testing(),
-          executionDelay: BigInt(60),
-          gracePeriod: BigInt(300),
-          maxActiveProposals: BigInt(100),
-          proposalLifetime: BigInt(86400),
-          emergencyVetoEnabled: true,
-          emergencyVetoThreshold: BigInt(75000),
-        },
-        token: {
-          name: 'Test DAO',
-          symbol: 'TDAO',
-          decimals: BigInt(18),
-        },
-        adminKey: new Uint8Array(16), // Invalid: should be 32 bytes
-      };
-
-      expect(() => {
-        validators.validateDeploymentConfig(invalidConfig);
-      }).toThrow();
-    });
-  });
-
-  describe('Vote Choice Validation', () => {
-    it('should accept valid vote choices', () => {
-      expect(() => validators.validateVoteChoice(VoteChoice.For)).not.toThrow();
-      expect(() => validators.validateVoteChoice(VoteChoice.Against)).not.toThrow();
-      expect(() => validators.validateVoteChoice(VoteChoice.Abstain)).not.toThrow();
-    });
-
-    it('should reject invalid vote choices', () => {
-      expect(() => validators.validateVoteChoice(3 as any)).toThrow();
-      expect(() => validators.validateVoteChoice(-1 as any)).toThrow();
-    });
-  });
-
-  describe('Proposal Validation', () => {
-    it('should validate proposal parameters', () => {
-      const creator = new Uint8Array(32);
-
-      expect(() => {
-        validators.validateProposal('Valid Title', 'Valid description', creator);
-      }).not.toThrow();
-    });
-
-    it('should reject proposals with empty title', () => {
-      const creator = new Uint8Array(32);
-
-      expect(() => {
-        validators.validateProposal('', 'Valid description', creator);
-      }).toThrow();
-    });
-
-    it('should reject proposals with title too long', () => {
-      const creator = new Uint8Array(32);
-
-      expect(() => {
-        validators.validateProposal('a'.repeat(257), 'Valid description', creator);
-      }).toThrow();
-    });
-
-    it('should reject proposals with empty description', () => {
-      const creator = new Uint8Array(32);
-
-      expect(() => {
-        validators.validateProposal('Valid title', '', creator);
-      }).toThrow();
-    });
-  });
-
-  describe('Transaction Flow', () => {
-    it('should balance and submit transaction', async () => {
-      const unbalancedTx = { data: 'unbalanced-tx' };
-
-      // Balance transaction
-      const balancedTx = await mockProviders.walletProvider.balanceTransaction(unbalancedTx as any);
-      expect(balancedTx).toBeDefined();
-
-      // Submit transaction
-      const result = await mockProviders.walletProvider.submitTransaction(balancedTx);
-
-      expect(result.public.txHash).toBe('mock-tx-hash');
-      expect(mockProviders.walletProvider.balanceTransaction).toHaveBeenCalled();
-      expect(mockProviders.walletProvider.submitTransaction).toHaveBeenCalled();
-    });
-
-    it('should handle transaction submission errors', async () => {
-      const failingProviders = createFailingMockProviders();
-      const tx = { data: 'mock-tx' };
-
-      await expect(
-        failingProviders.walletProvider.submitTransaction(tx as any)
-      ).rejects.toThrow();
-    });
-  });
-
-  describe('Private State Management', () => {
-    it('should retrieve private state', async () => {
-      const stateId = 'governorPrivateState';
-      const state = await mockProviders.privateStateProvider.get(stateId);
-
-      expect(mockProviders.privateStateProvider.get).toHaveBeenCalledWith(stateId);
-    });
-
-    it('should save private state', async () => {
-      const stateId = 'governorPrivateState';
-      const newState = {
-        secretKey: new Uint8Array(32),
-        currentTime: BigInt(Math.floor(Date.now() / 1000)),
-        userStake: {
-          amount: BigInt(100),
-          delegatedTo: new Uint8Array(32),
-          stakedAt: BigInt(0),
-        },
-        votingHistory: [],
-        proposalHistory: [],
-        governanceConfig: ConfigPresets.testing(),
-      };
-
-      await mockProviders.privateStateProvider.set(stateId, newState);
-
-      expect(mockProviders.privateStateProvider.set).toHaveBeenCalledWith(stateId, newState);
-    });
-  });
-
-  describe('Block Height Queries', () => {
-    it('should query current block height', async () => {
-      const height = await mockProviders.publicDataProvider.getBlockHeight();
-
-      expect(height).toBe(BigInt(1000));
-      expect(mockProviders.publicDataProvider.getBlockHeight).toHaveBeenCalled();
-    });
-  });
-
-  describe('Error Handling Scenarios', () => {
-    it('should handle wallet connection errors gracefully', async () => {
-      const errorProviders = createMockProviders({
-        walletProvider: {
-          state: async () => {
-            throw new Error('Wallet not connected');
-          },
-        } as any,
-      });
-
-      await expect(errorProviders.walletProvider.state()).rejects.toThrow('Wallet not connected');
-    });
-
-    it('should handle indexer query errors', async () => {
-      const errorProviders = createMockProviders({
-        publicDataProvider: {
-          queryContractState: async () => {
-            throw new Error('Indexer unavailable');
-          },
-        } as any,
-      });
-
-      await expect(
-        errorProviders.publicDataProvider.queryContractState('mock-address')
-      ).rejects.toThrow('Indexer unavailable');
-    });
-
-    it('should handle proof generation errors', async () => {
-      const errorProviders = createMockProviders({
-        proofProvider: {
-          generateProof: async () => {
-            throw new Error('Proof generation failed');
-          },
-        } as any,
-      });
-
-      await expect(
-        errorProviders.proofProvider.generateProof({} as any)
-      ).rejects.toThrow('Proof generation failed');
-    });
-  });
-
-  describe('Wallet State', () => {
-    it('should retrieve wallet state', async () => {
-      const state = await mockProviders.walletProvider.state();
-
-      expect(state.address).toBe('mock-wallet-address');
-      expect(state.coinPublicKey).toBeInstanceOf(Uint8Array);
-      expect(state.encryptionPublicKey).toBeInstanceOf(Uint8Array);
-    });
-  });
-
-  describe('Configuration Presets', () => {
-    it('should provide testing configuration', () => {
-      const config = ConfigPresets.testing();
-
-      expect(config.votingPeriod).toBe(BigInt(300));
-      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));
-      expect(config.quorumThreshold).toBe(BigInt(100000));
-      expect(config.proposalThreshold).toBe(BigInt(50000));
-      expect(config.minStakeAmount).toBe(BigInt(1000));
-    });
-
-    it('production config should have higher thresholds than testing', () => {
-      const testing = ConfigPresets.testing();
-      const production = ConfigPresets.production();
-
-      expect(production.votingPeriod).toBeGreaterThan(testing.votingPeriod);
-      expect(production.quorumThreshold).toBeGreaterThan(testing.quorumThreshold);
-      expect(production.proposalThreshold).toBeGreaterThan(testing.proposalThreshold);
-      expect(production.minStakeAmount).toBeGreaterThan(testing.minStakeAmount);
-    });
-  });
-
-  describe('GovernorAPI Method Calls (Mocked)', () => {
-    it('should call publicDataProvider.queryContractState when querying state', async () => {
-      const contractAddress = 'test-contract-address';
-      const state = await mockProviders.publicDataProvider.queryContractState(contractAddress);
-
-      expect(mockProviders.publicDataProvider.queryContractState).toHaveBeenCalledWith(contractAddress);
-      expect(state.governanceConfig).toBeDefined();
-      expect(state.activeProposalCount).toBe(BigInt(0));
-    });
-
-    it('should call walletProvider.balanceTransaction before submission', async () => {
-      const unbalancedTx = { data: 'test-transaction' };
-      await mockProviders.walletProvider.balanceTransaction(unbalancedTx as any);
-
-      expect(mockProviders.walletProvider.balanceTransaction).toHaveBeenCalledWith(unbalancedTx);
-    });
-
-    it('should call proofProvider.generateProof for ZK proofs', async () => {
-      const proofInput = { witness: 'test-witness' };
-      const proof = await mockProviders.proofProvider.generateProof(proofInput as any);
-
-      expect(mockProviders.proofProvider.generateProof).toHaveBeenCalledWith(proofInput);
-      expect(proof.proof).toBeInstanceOf(Uint8Array);
-    });
-
-    it('should retrieve block height from publicDataProvider', async () => {
-      const height = await mockProviders.publicDataProvider.getBlockHeight();
-
-      expect(height).toBe(BigInt(1000));
-      expect(mockProviders.publicDataProvider.getBlockHeight).toHaveBeenCalled();
-    });
-
-    it('should handle successful transaction submission', async () => {
-      const tx = { data: 'test-tx' };
-      const result = await mockProviders.walletProvider.submitTransaction(tx as any);
-
-      expect(result.public.txHash).toBe('mock-tx-hash');
-      expect(result.private.result.success).toBe(true);
-      expect(mockProviders.walletProvider.submitTransaction).toHaveBeenCalledWith(tx);
-    });
-
-    it('should handle transaction failure', async () => {
-      const failingProviders = createFailingMockProviders();
-      const tx = { data: 'failing-tx' };
-
-      await expect(
-        failingProviders.walletProvider.submitTransaction(tx as any)
-      ).rejects.toThrow('Transaction failed');
-    });
-
-    it('should save and retrieve private state', async () => {
-      const stateId = 'test-state';
-      const newState = {
-        secretKey: new Uint8Array(32),
-        currentTime: BigInt(Date.now()),
-        userStake: {
-          amount: BigInt(100),
-          delegatedTo: new Uint8Array(32),
-          stakedAt: BigInt(0),
-        },
-        votingHistory: [],
-        proposalHistory: [],
-        governanceConfig: ConfigPresets.testing(),
-      };
-
-      await mockProviders.privateStateProvider.set(stateId, newState);
-      expect(mockProviders.privateStateProvider.set).toHaveBeenCalledWith(stateId, newState);
-
-      const retrieved = await mockProviders.privateStateProvider.get(stateId);
-      expect(mockProviders.privateStateProvider.get).toHaveBeenCalledWith(stateId);
-    });
-
-    it('should handle network query', async () => {
-      const network = await mockProviders.publicDataProvider.queryNetwork();
-
-      expect(network.networkId).toBe('testnet');
-      expect(mockProviders.publicDataProvider.queryNetwork).toHaveBeenCalled();
-    });
-  });
-});

package/test/mocks/providers.ts

@@ -1,130 +0,0 @@
-/**
- * Mock providers for integration testing
- */
-
-import { vi } from 'vitest';
-import type { GovernorProviders } from '../../src/common-types';
-
-/**
- * Creates mock providers for testing SDK logic without real blockchain
- */
-export function createMockProviders(overrides?: Partial<GovernorProviders>): GovernorProviders {
-  const mockContractState = {
-    governanceConfig: {
-      votingPeriod: BigInt(300),
-      quorumThreshold: BigInt(100),
-      proposalThreshold: BigInt(100),
-      proposalLifetime: BigInt(86400),
-      executionDelay: BigInt(60),
-      gracePeriod: BigInt(300),
-      minStakeAmount: BigInt(10),
-      stakingPeriod: BigInt(60),
-    },
-    activeProposalCount: BigInt(0),
-    totalStaked: BigInt(0),
-  };
-
-  return {
-    privateStateProvider: {
-      get: vi.fn().mockResolvedValue(null),
-      set: vi.fn().mockResolvedValue(undefined),
-      ...overrides?.privateStateProvider,
-    },
-    publicDataProvider: {
-      queryContractState: vi.fn().mockResolvedValue(mockContractState),
-      getBlockHeight: vi.fn().mockResolvedValue(BigInt(1000)),
-      queryNetwork: vi.fn().mockResolvedValue({ networkId: 'testnet' }),
-      findDeployedContract: vi.fn(),
-      ...overrides?.publicDataProvider,
-    },
-    walletProvider: {
-      coinPublicKey: new Uint8Array(32),
-      state: vi.fn().mockResolvedValue({
-        address: 'mock-wallet-address',
-        coinPublicKey: new Uint8Array(32),
-        encryptionPublicKey: new Uint8Array(32),
-      }),
-      balanceTransaction: vi.fn().mockImplementation((unbalanced) => unbalanced),
-      submitTransaction: vi.fn().mockResolvedValue({
-        public: {
-          txHash: 'mock-tx-hash',
-          contractAddress: 'mock-contract-address',
-        },
-        private: {
-          result: {
-            proposalId: BigInt(1),
-            effectId: BigInt(0),
-            success: true,
-          },
-        },
-      }),
-      ...overrides?.walletProvider,
-    },
-    proofProvider: {
-      generateProof: vi.fn().mockResolvedValue({
-        proof: new Uint8Array(100),
-        publicInputs: [],
-      }),
-      ...overrides?.proofProvider,
-    },
-    zkConfigProvider: {
-      getZkConfig: vi.fn().mockResolvedValue({
-        contractAddress: 'mock-contract-address',
-        circuits: {},
-      }),
-      ...overrides?.zkConfigProvider,
-    },
-    midnightProvider: {
-      submitTx: vi.fn().mockResolvedValue('mock-tx-hash'),
-      ...overrides?.midnightProvider,
-    },
-    ...overrides,
-  } as unknown as GovernorProviders;
-}
-
-/**
- * Creates mock providers that simulate transaction failure
- */
-export function createFailingMockProviders(): GovernorProviders {
-  return createMockProviders({
-    walletProvider: {
-      coinPublicKey: new Uint8Array(32),
-      state: vi.fn().mockResolvedValue({
-        address: 'mock-wallet-address',
-        coinPublicKey: new Uint8Array(32),
-        encryptionPublicKey: new Uint8Array(32),
-      }),
-      balanceTransaction: vi.fn().mockImplementation((unbalanced) => unbalanced),
-      submitTransaction: vi.fn().mockRejectedValue(new Error('Transaction failed')),
-    } as any,
-  });
-}
-
-/**
- * Creates mock providers that simulate insufficient stake
- */
-export function createInsufficientStakeMockProviders(): GovernorProviders {
-  return createMockProviders({
-    publicDataProvider: {
-      queryContractState: vi.fn().mockResolvedValue({
-        governanceConfig: {
-          votingPeriod: BigInt(300),
-          quorumThreshold: BigInt(100),
-          proposalThreshold: BigInt(100),
-          proposalLifetime: BigInt(86400),
-          executionDelay: BigInt(60),
-          gracePeriod: BigInt(300),
-          minStakeAmount: BigInt(10),
-          stakingPeriod: BigInt(60),
-        },
-        stakes: {
-          // User has insufficient stake
-          'mock-user': { amount: BigInt(5), delegatedTo: new Uint8Array(32), stakedAt: BigInt(0) },
-        },
-      }),
-      getBlockHeight: vi.fn().mockResolvedValue(BigInt(1000)),
-      queryNetwork: vi.fn().mockResolvedValue({ networkId: 'testnet' }),
-      findDeployedContract: vi.fn(),
-    } as any,
-  });
-}