@uvrn/adapter 1.0.0

package/tests/integration.test.ts

@@ -0,0 +1,123 @@
+/**
+ * Integration Tests
+ * Tests the full flow from DeltaBundle → DeltaReceipt → DRVC3Receipt
+ */
+
+import { Wallet, HDNodeWallet } from 'ethers';
+import { 
+  runDeltaEngine, 
+  verifyReceipt,
+  DeltaBundle 
+} from '@uvrn/core';
+import { wrapInDRVC3, extractDeltaReceipt, validateDRVC3 } from '../src';
+
+describe('Integration: Layer 1 → Layer 2', () => {
+  let testWallet: HDNodeWallet;
+
+  beforeAll(() => {
+    testWallet = Wallet.createRandom();
+  });
+
+  it('should complete full flow: bundle → receipt → DRVC3', async () => {
+    // 1. Create a DeltaBundle (input to Layer 1)
+    const bundle: DeltaBundle = {
+      bundleId: 'integration-test-001',
+      claim: 'Integration Test',
+      thresholdPct: 0.1,
+      dataSpecs: [
+        {
+          id: 'source-1',
+          label: 'Source 1',
+          sourceKind: 'metric',
+          originDocIds: ['doc-1'],
+          metrics: [
+            { key: 'revenue', value: 1000 },
+            { key: 'users', value: 500 }
+          ]
+        },
+        {
+          id: 'source-2',
+          label: 'Source 2',
+          sourceKind: 'metric',
+          originDocIds: ['doc-2'],
+          metrics: [
+            { key: 'revenue', value: 1050 },
+            { key: 'users', value: 510 }
+          ]
+        }
+      ]
+    };
+
+    // 2. Run Layer 1 Engine
+    const deltaReceipt = runDeltaEngine(bundle);
+
+    // Verify Layer 1 receipt
+    const verifyResult = verifyReceipt(deltaReceipt);
+    expect(verifyResult.verified).toBe(true);
+
+    // 3. Wrap in DRVC3 (Layer 2)
+    const drvc3 = await wrapInDRVC3(deltaReceipt, testWallet, {
+      issuer: 'uvrn-integration',
+      event: 'delta-reconciliation',
+      tags: ['#uvrn', '#integration-test']
+    });
+
+    // 4. Validate DRVC3 schema
+    const schemaResult = validateDRVC3(drvc3);
+    expect(schemaResult.valid).toBe(true);
+
+    // 5. Verify hash chain integrity
+    expect(drvc3.integrity.hash).toBe(deltaReceipt.hash);
+
+    // 6. Extract and verify embedded receipt
+    const extracted = extractDeltaReceipt(drvc3);
+    expect(extracted.hash).toBe(deltaReceipt.hash);
+    expect(verifyReceipt(extracted).verified).toBe(true);
+  });
+
+  it('should maintain hash integrity through Layer 2 wrapping', async () => {
+    const bundle: DeltaBundle = {
+      bundleId: 'hash-integrity-test',
+      claim: 'Hash Test',
+      thresholdPct: 0.05,
+      dataSpecs: [
+        {
+          id: 'a',
+          label: 'A',
+          sourceKind: 'metric',
+          originDocIds: [],
+          metrics: [{ key: 'val', value: 100 }]
+        },
+        {
+          id: 'b',
+          label: 'B',
+          sourceKind: 'metric',
+          originDocIds: [],
+          metrics: [{ key: 'val', value: 100 }]
+        }
+      ]
+    };
+
+    const receipt = runDeltaEngine(bundle);
+    const originalHash = receipt.hash;
+
+    // Wrap multiple times - hash should always match
+    const drvc3_1 = await wrapInDRVC3(receipt, testWallet, {
+      issuer: 'test',
+      event: 'test'
+    });
+
+    const drvc3_2 = await wrapInDRVC3(receipt, testWallet, {
+      issuer: 'test',
+      event: 'test'
+    });
+
+    // Envelope metadata differs (receipt_id, timestamp)
+    expect(drvc3_1.receipt_id).not.toBe(drvc3_2.receipt_id);
+    expect(drvc3_1.timestamp).not.toBe(drvc3_2.timestamp);
+
+    // But hash domain remains identical
+    expect(drvc3_1.integrity.hash).toBe(originalHash);
+    expect(drvc3_2.integrity.hash).toBe(originalHash);
+  });
+});

package/tests/wrapper.test.ts

@@ -0,0 +1,115 @@
+/**
+ * DRVC3 Wrapper Tests
+ * Tests the wrapInDRVC3 function and schema validation
+ */
+
+import { Wallet, HDNodeWallet } from 'ethers';
+import { wrapInDRVC3, extractDeltaReceipt } from '../src/wrapper';
+import { validateDRVC3 } from '../src/validator';
+import { recoverSigner } from '../src/signer';
+import { DeltaReceipt } from '@uvrn/core';
+
+describe('DRVC3 Wrapper', () => {
+  // Mock DeltaReceipt (as would come from Layer 1)
+  const mockDeltaReceipt: DeltaReceipt = {
+    bundleId: 'test-bundle-001',
+    deltaFinal: 0.05,
+    sources: ['Source A', 'Source B'],
+    rounds: [
+      {
+        round: 1,
+        deltasByMetric: { revenue: 0.05, users: 0.0 },
+        withinThreshold: true,
+        witnessRequired: false
+      }
+    ],
+    suggestedFixes: [],
+    outcome: 'consensus',
+    hash: 'a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2'
+  };
+
+  let testWallet: HDNodeWallet;
+
+  beforeAll(() => {
+    // Create a deterministic wallet for testing
+    testWallet = Wallet.createRandom();
+  });
+
+  it('should wrap DeltaReceipt in valid DRVC3 envelope', async () => {
+    const drvc3 = await wrapInDRVC3(mockDeltaReceipt, testWallet, {
+      issuer: 'uvrn-test',
+      event: 'delta-reconciliation'
+    });
+
+    // Check required fields
+    expect(drvc3.receipt_id).toMatch(/^drvc3-test-bundle-001-\d+$/);
+    expect(drvc3.issuer).toBe('uvrn-test');
+    expect(drvc3.event).toBe('delta-reconciliation');
+    expect(drvc3.timestamp).toBeDefined();
+    expect(drvc3.block_state).toBe('loose');
+    expect(drvc3.certificate).toBe('DRVC3 v1.0');
+
+    // Check integrity block
+    expect(drvc3.integrity.hash_algorithm).toBe('sha256');
+    expect(drvc3.integrity.hash).toBe(mockDeltaReceipt.hash);
+    expect(drvc3.integrity.signature_method).toBe('eip191');
+    expect(drvc3.integrity.signature).toBeDefined();
+    expect(drvc3.integrity.signer_address).toBe(testWallet.address);
+
+    // Check validation block
+    expect(drvc3.validation.v_score).toBe(mockDeltaReceipt.deltaFinal);
+    expect(drvc3.validation.checks.delta_receipt).toEqual(mockDeltaReceipt);
+  });
+
+  it('should produce schema-valid DRVC3 receipt', async () => {
+    const drvc3 = await wrapInDRVC3(mockDeltaReceipt, testWallet, {
+      issuer: 'uvrn',
+      event: 'test'
+    });
+
+    const result = validateDRVC3(drvc3);
+    expect(result.valid).toBe(true);
+    expect(result.errors).toBeUndefined();
+  });
+
+  it('should include optional fields when provided', async () => {
+    const drvc3 = await wrapInDRVC3(mockDeltaReceipt, testWallet, {
+      issuer: 'uvrn',
+      event: 'delta-reconciliation',
+      blockState: 'blocked',
+      certificate: 'DRVC3 v1.1',
+      description: 'Test receipt',
+      tags: ['#uvrn', '#receipt', '#test']
+    });
+
+    expect(drvc3.block_state).toBe('blocked');
+    expect(drvc3.certificate).toBe('DRVC3 v1.1');
+    expect(drvc3.description).toBe('Test receipt');
+    expect(drvc3.tags).toEqual(['#uvrn', '#receipt', '#test']);
+  });
+
+  it('should create verifiable signature', async () => {
+    const drvc3 = await wrapInDRVC3(mockDeltaReceipt, testWallet, {
+      issuer: 'uvrn',
+      event: 'test'
+    });
+
+    // Recover signer from signature
+    const recoveredAddress = recoverSigner(
+      drvc3.integrity.hash,
+      drvc3.integrity.signature
+    );
+
+    expect(recoveredAddress.toLowerCase()).toBe(testWallet.address.toLowerCase());
+  });
+
+  it('should extract original DeltaReceipt from envelope', async () => {
+    const drvc3 = await wrapInDRVC3(mockDeltaReceipt, testWallet, {
+      issuer: 'uvrn',
+      event: 'test'
+    });
+
+    const extracted = extractDeltaReceipt(drvc3);
+    expect(extracted).toEqual(mockDeltaReceipt);
+  });
+});

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": ["ES2020"],
+    "declaration": true,
+    "strict": true,
+    "noImplicitAny": true,
+    "strictNullChecks": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "moduleResolution": "node",
+    "resolveJsonModule": true,
+    "outDir": "./dist",
+    "rootDir": ".",
+    "baseUrl": "."
+  },
+  "include": ["src/**/*", "tests/**/*"],
+  "exclude": ["node_modules", "dist"]
+}