@ocap/types 1.28.8 → 1.29.0

package/tests/interfaces.spec.ts

@@ -0,0 +1,265 @@
+// core/types/tests/interfaces.spec.ts
+// 冒烟测试：验证接口定义可正确导入和使用
+
+import { describe, expect, test } from 'bun:test';
+import { BN } from '@ocap/util';
+import type {
+  // base
+  BN as BNType,
+  BytesType,
+  DeepPartial,
+  // hooks
+  HookPhase,
+  IAccountState,
+  IAny,
+  IChainConfig,
+  // statedb
+  IDBTransaction,
+  IHookHandler,
+  IHookResult,
+  IPage,
+  IPageInfo,
+  IPagedResult,
+  IRangeFilter,
+  ISearchResult,
+  // state
+  IState,
+  IStateContext,
+  IStateWithOwner,
+  ITimeFilter,
+  PartialBy,
+  RequiredBy,
+  StateChangeType,
+  StateKind,
+  Timestamp,
+} from '../interfaces';
+
+describe('core/types/interfaces', () => {
+  describe('base types', () => {
+    test('should define BytesType as string | Buffer | Uint8Array', () => {
+      const str: BytesType = 'hello';
+      const buf: BytesType = Buffer.from('hello');
+      const arr: BytesType = new Uint8Array([1, 2, 3]);
+      expect(str).toBeDefined();
+      expect(buf).toBeDefined();
+      expect(arr).toBeDefined();
+    });
+
+    test('should define BN type compatible with @ocap/util BN class', () => {
+      // BN class from @ocap/util should satisfy BNType from @ocap/types
+      const fromStr: BNType = new BN('1000000');
+      const fromNum: BNType = new BN(1000000);
+      const fromNull: BNType = new BN(null);
+      expect(fromStr.toString()).toBe('1000000');
+      expect(fromNum.toString()).toBe('1000000');
+      expect(fromNull.toString()).toBe('0');
+    });
+
+    test('should define Timestamp as string | number | Date', () => {
+      const str: Timestamp = '2024-01-01T00:00:00Z';
+      const num: Timestamp = Date.now();
+      const date: Timestamp = new Date();
+      expect(str).toBeDefined();
+      expect(num).toBeDefined();
+      expect(date).toBeDefined();
+    });
+
+    test('should define IAny interface', () => {
+      const any: IAny = {
+        typeUrl: 'type.googleapis.com/example',
+        value: new Uint8Array([1, 2, 3]),
+      };
+      expect(any.typeUrl).toBe('type.googleapis.com/example');
+      expect(any.value).toBeInstanceOf(Uint8Array);
+    });
+
+    test('should define utility types', () => {
+      type Example = { a: string; b: number; c: boolean };
+      type PartialA = PartialBy<Example, 'a'>;
+      type RequiredC = RequiredBy<Partial<Example>, 'c'>;
+      type Deep = DeepPartial<Example>;
+
+      const partial: PartialA = { b: 1, c: true };
+      const required: RequiredC = { c: false };
+      const deep: Deep = { a: 'test' };
+
+      expect(partial).toBeDefined();
+      expect(required).toBeDefined();
+      expect(deep).toBeDefined();
+    });
+  });
+
+  describe('state types', () => {
+    test('should define IStateContext', () => {
+      const context: IStateContext = {
+        genesisTx: 'tx123',
+        renaissanceTx: 'tx456',
+        genesisTime: new Date(),
+        renaissanceTime: '2024-01-01',
+      };
+      expect(context.genesisTx).toBe('tx123');
+    });
+
+    test('should define IState', () => {
+      const state: IState = {
+        address: 'z1234567890',
+        context: {
+          genesisTx: 'tx123',
+          renaissanceTx: 'tx456',
+        },
+      };
+      expect(state.address).toBe('z1234567890');
+    });
+
+    test('should define IStateWithOwner extending IState', () => {
+      const state: IStateWithOwner = {
+        address: 'z1234567890',
+        owner: 'z0987654321',
+        issuer: 'z1111111111',
+      };
+      expect(state.owner).toBeDefined();
+      expect(state.issuer).toBeDefined();
+    });
+
+    test('should define StateKind union', () => {
+      const types: StateKind[] = [
+        'account',
+        'asset',
+        'token',
+        'token-factory',
+        'asset-factory',
+        'stake',
+        'delegation',
+        'rollup',
+        'rollup-block',
+        'evidence',
+      ];
+      expect(types).toHaveLength(10);
+    });
+
+    test('should define StateChangeType union', () => {
+      const types: StateChangeType[] = ['create', 'update', 'delete'];
+      expect(types).toHaveLength(3);
+    });
+  });
+
+  describe('execution types', () => {
+    test('should define IChainConfig', () => {
+      const config: IChainConfig = {
+        chainId: 'test-chain',
+        chainName: 'Test Chain',
+        consensus: {},
+        transaction: {},
+        token: {},
+      };
+      expect(config.chainId).toBe('test-chain');
+    });
+
+    test('should define IAccountState extending IState', () => {
+      const account: IAccountState = {
+        address: 'z1234567890',
+        balance: '1000000',
+        nonce: '1',
+        numTxs: '10',
+        pk: 'pk123',
+        moniker: 'alice',
+      };
+      expect(account.balance).toBe('1000000');
+    });
+  });
+
+  describe('hook types', () => {
+    test('should define HookPhase union', () => {
+      const phases: HookPhase[] = ['pre-check', 'post-check', 'pre-apply', 'post-apply', 'pre-commit', 'post-commit'];
+      expect(phases).toHaveLength(6);
+    });
+
+    test('should define IHookResult', () => {
+      const result: IHookResult = {
+        continue: true,
+        code: 0,
+        message: 'success',
+      };
+      expect(result.continue).toBe(true);
+    });
+
+    test('should define IHookHandler', () => {
+      const handler: IHookHandler = {
+        name: 'test-hook',
+        priority: 50,
+        handler: async () => ({ continue: true }),
+      };
+      expect(handler.name).toBe('test-hook');
+      expect(handler.priority).toBe(50);
+    });
+  });
+
+  describe('statedb types', () => {
+    test('should define IDBTransaction', () => {
+      const tx: IDBTransaction = {
+        id: 'tx-123',
+        state: 'pending',
+      };
+      expect(tx.state).toBe('pending');
+    });
+  });
+
+  describe('indexdb types', () => {
+    test('should define IPage', () => {
+      const page: IPage = {
+        cursor: 'abc123',
+        size: 20,
+        order: 'desc',
+      };
+      expect(page.size).toBe(20);
+    });
+
+    test('should define IPageInfo extending IPage', () => {
+      const pageInfo: IPageInfo = {
+        cursor: 'abc123',
+        size: 20,
+        order: 'desc',
+        next: 'def456',
+        hasMore: true,
+      };
+      expect(pageInfo.hasMore).toBe(true);
+    });
+
+    test('should define IPagedResult', () => {
+      const result: IPagedResult<{ id: string }> = {
+        data: [{ id: '1' }, { id: '2' }],
+        page: { hasMore: false },
+        total: 2,
+      };
+      expect(result.data).toHaveLength(2);
+      expect(result.total).toBe(2);
+    });
+
+    test('should define ITimeFilter', () => {
+      const filter: ITimeFilter = {
+        start: '2024-01-01',
+        end: new Date(),
+      };
+      expect(filter.start).toBeDefined();
+    });
+
+    test('should define IRangeFilter', () => {
+      const filter: IRangeFilter = {
+        min: 0,
+        max: '1000000',
+      };
+      expect(filter.min).toBe(0);
+    });
+
+    test('should define ISearchResult', () => {
+      const result: ISearchResult = {
+        type: 'account',
+        address: 'z1234567890',
+        score: 0.95,
+        highlights: ['<em>alice</em>'],
+        data: { moniker: 'alice' },
+      };
+      expect(result.score).toBe(0.95);
+    });
+  });
+});

package/tests/pipeline.spec.ts

@@ -0,0 +1,249 @@
+// core/types/tests/pipeline.spec.ts
+// Tests for 5-phase context type hierarchy
+
+import { describe, expect, test } from 'bun:test';
+import type {
+  IBaseContext,
+  IChainConfig,
+  IDecodedContext,
+  IGasContext,
+  IReadyContext,
+  IStateDB,
+  IWithSender,
+} from '../interfaces';
+import type { TStakeTx, TTransferTx } from '../lib/tx_pb';
+
+describe('Pipeline Context Types', () => {
+  const mockStateDB = {} as IStateDB;
+  const mockConfig = { chainId: 'test', chainName: 'Test' } as IChainConfig;
+  const mockIndexDB = {} as IBaseContext['indexdb'];
+
+  describe('IBaseContext', () => {
+    test('should require mandatory fields', () => {
+      const context: IBaseContext = {
+        txBase64: 'base64data',
+        statedb: mockStateDB,
+        config: mockConfig,
+        indexdb: mockIndexDB,
+      };
+      expect(context.txBase64).toBe('base64data');
+      expect(context.statedb).toBe(mockStateDB);
+      expect(context.config).toBe(mockConfig);
+    });
+
+    test('should allow optional fields', () => {
+      const context: IBaseContext = {
+        txBase64: 'base64data',
+        statedb: mockStateDB,
+        config: mockConfig,
+        indexdb: mockIndexDB,
+        logger: { debug: () => {}, info: () => {}, warn: () => {}, error: () => {} },
+        extra: { key: 'value' },
+      };
+      expect(context.logger).toBeDefined();
+      expect(context.extra?.key).toBe('value');
+    });
+  });
+
+  describe('IDecodedContext', () => {
+    test('should include tx and itx fields', () => {
+      const context: IDecodedContext<TTransferTx> = {
+        txBase64: 'base64data',
+        statedb: mockStateDB,
+        config: mockConfig,
+        indexdb: mockIndexDB,
+        tx: {
+          from: 'z123',
+          chainId: 'test',
+          nonce: 1,
+          pk: new Uint8Array(),
+          itx: { typeUrl: '', value: new Uint8Array() },
+        },
+        txHash: 'hash123',
+        txTime: '2024-01-01T00:00:00Z',
+        txSize: 256,
+        txBaseGas: true,
+        itx: { to: 'z456', value: '100', tokens: [] },
+        txType: 'fg:t:transfer',
+      };
+      expect(context.txHash).toBe('hash123');
+      expect(context.txType).toBe('fg:t:transfer');
+      expect(context.itx?.to).toBe('z456');
+    });
+  });
+
+  describe('IGasContext', () => {
+    test('should include gas calculation fields', () => {
+      const context: IGasContext = {
+        txBase64: 'base64data',
+        statedb: mockStateDB,
+        config: mockConfig,
+        indexdb: mockIndexDB,
+        tx: {
+          from: 'z123',
+          chainId: 'test',
+          nonce: 1,
+          pk: new Uint8Array(),
+          itx: { typeUrl: '', value: new Uint8Array() },
+        },
+        txHash: 'hash123',
+        txTime: '2024-01-01T00:00:00Z',
+        txSize: 256,
+        txBaseGas: true,
+        itx: {},
+        txType: 'fg:t:transfer',
+        gasEstimate: { create: 1, update: 2, payment: 0 },
+        senderUpdates: {},
+        gasPaid: false,
+      };
+      expect(context.gasEstimate?.create).toBe(1);
+      expect(context.gasPaid).toBe(false);
+    });
+  });
+
+  describe('IReadyContext', () => {
+    test('should include state snapshot', () => {
+      const context: IReadyContext = {
+        txBase64: 'base64data',
+        statedb: mockStateDB,
+        config: mockConfig,
+        indexdb: mockIndexDB,
+        tx: {
+          from: 'z123',
+          chainId: 'test',
+          nonce: 1,
+          pk: new Uint8Array(),
+          itx: { typeUrl: '', value: new Uint8Array() },
+        },
+        txHash: 'hash123',
+        txTime: '2024-01-01T00:00:00Z',
+        txSize: 256,
+        txBaseGas: true,
+        itx: {},
+        txType: 'fg:t:transfer',
+        stateSnapshot: { z123: { address: 'z123', tokens: {} } },
+      };
+      expect(context.stateSnapshot).toBeDefined();
+      expect(context.stateSnapshot.z123).toBeDefined();
+    });
+
+    test('should support generic TItx', () => {
+      type TransferContext = IReadyContext<TTransferTx>;
+      const context: TransferContext = {
+        txBase64: 'base64data',
+        statedb: mockStateDB,
+        config: mockConfig,
+        indexdb: mockIndexDB,
+        tx: {
+          from: 'z123',
+          chainId: 'test',
+          nonce: 1,
+          pk: new Uint8Array(),
+          itx: { typeUrl: '', value: new Uint8Array() },
+        },
+        txHash: 'hash123',
+        txTime: '2024-01-01T00:00:00Z',
+        txSize: 256,
+        txBaseGas: true,
+        itx: { to: 'z456', value: '100', tokens: [] },
+        txType: 'fg:t:transfer',
+        stateSnapshot: {},
+      };
+      expect(context.itx?.to).toBe('z456');
+      expect(context.itx?.value).toBe('100');
+    });
+
+    test('should support TStakeTx via generic', () => {
+      type StakeContext = IReadyContext<TStakeTx>;
+      const context: StakeContext = {
+        txBase64: 'base64data',
+        statedb: mockStateDB,
+        config: mockConfig,
+        indexdb: mockIndexDB,
+        tx: {
+          from: 'z123',
+          chainId: 'test',
+          nonce: 1,
+          pk: new Uint8Array(),
+          itx: { typeUrl: '', value: new Uint8Array() },
+        },
+        txHash: 'hash123',
+        txTime: '2024-01-01T00:00:00Z',
+        txSize: 256,
+        txBaseGas: true,
+        itx: { to: 'z456', tokens: [] },
+        txType: 'fg:t:stake',
+        stateSnapshot: {},
+      };
+      expect(context.itx?.to).toBe('z456');
+    });
+  });
+
+  describe('Mixin Interfaces', () => {
+    test('should allow combining phase types with mixins', () => {
+      type TransferContext = IReadyContext<TTransferTx> & IWithSender;
+      const context: TransferContext = {
+        txBase64: 'base64data',
+        statedb: mockStateDB,
+        config: mockConfig,
+        indexdb: mockIndexDB,
+        tx: {
+          from: 'z123',
+          chainId: 'test',
+          nonce: 1,
+          pk: new Uint8Array(),
+          itx: { typeUrl: '', value: new Uint8Array() },
+        },
+        txHash: 'hash123',
+        txTime: '2024-01-01T00:00:00Z',
+        txSize: 256,
+        txBaseGas: true,
+        itx: { to: 'z456', value: '100', tokens: [] },
+        txType: 'fg:t:transfer',
+        stateSnapshot: {},
+        senderState: {
+          address: 'z123',
+          balance: '1000',
+          nonce: '1',
+          numTxs: '10',
+          pk: 'pk',
+          moniker: 'alice',
+          tokens: {},
+          context: { genesisTime: '', genesisTx: '' },
+        },
+      };
+      expect(context.senderState.address).toBe('z123');
+      expect(context.senderState.balance).toBe('1000');
+    });
+  });
+
+  describe('Dynamic extension', () => {
+    test('should allow protocol-specific fields via index signature', () => {
+      const context: IReadyContext = {
+        txBase64: 'base64data',
+        statedb: mockStateDB,
+        config: mockConfig,
+        indexdb: mockIndexDB,
+        tx: {
+          from: 'z123',
+          chainId: 'test',
+          nonce: 1,
+          pk: new Uint8Array(),
+          itx: { typeUrl: '', value: new Uint8Array() },
+        },
+        txHash: 'hash123',
+        txTime: '2024-01-01T00:00:00Z',
+        txSize: 256,
+        txBaseGas: true,
+        itx: {},
+        txType: 'fg:t:transfer',
+        stateSnapshot: {},
+        // Protocol-specific fields
+        factoryState: { address: 'z789' },
+        customField: 'value',
+      };
+      expect(context.factoryState).toBeDefined();
+      expect(context.customField).toBe('value');
+    });
+  });
+});