@decentrl/sdk 0.0.1

package/src/direct-transport.test.ts

@@ -0,0 +1,460 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { DirectTransport } from './direct-transport.js';
+import { makeContract } from './test-helpers.js';
+
+describe('DirectTransport', () => {
+	describe('processContractCleanup', () => {
+		let transport: DirectTransport;
+
+		beforeEach(() => {
+			transport = new DirectTransport({
+				httpPost: vi.fn(async () => ({ data: { type: 'SUCCESS' } })),
+			});
+		});
+
+		it('does nothing when only one contract per participant', () => {
+			const now = Math.floor(Date.now() / 1000);
+			const contract = makeContract({
+				id: 'only-one',
+				participantDid: 'did:decentrl:bob',
+				expiresAt: now + 3600,
+				timestamp: now,
+			});
+
+			// Inject contracts via the internal array
+			(transport as any).activeContracts = [contract];
+
+			transport.processContractCleanup();
+
+			expect(transport.getActiveContracts()).toHaveLength(1);
+		});
+
+		it('marks superseded contracts and purges on counterparty confirmation', () => {
+			const now = Math.floor(Date.now() / 1000);
+
+			const oldContract = makeContract({
+				id: 'old',
+				participantDid: 'did:decentrl:bob',
+				expiresAt: now + 3600,
+				timestamp: now,
+			});
+
+			const newContract = makeContract({
+				id: 'new',
+				participantDid: 'did:decentrl:bob',
+				expiresAt: now + 7200,
+				timestamp: now + 100,
+			});
+
+			(transport as any).activeContracts = [oldContract, newContract];
+
+			// First cleanup: mark as superseded, but don't purge yet
+			transport.processContractCleanup();
+			expect(transport.getActiveContracts()).toHaveLength(2);
+
+			// Simulate counterparty confirmation
+			(transport as any).confirmedNewContracts.add('new');
+
+			// Second cleanup: should purge old
+			transport.processContractCleanup();
+			expect(transport.getActiveContracts()).toHaveLength(1);
+			expect(transport.getActiveContracts()[0].id).toBe('new');
+		});
+
+		it('purges superseded contracts after 7-day timeout', () => {
+			const now = Math.floor(Date.now() / 1000);
+
+			const oldContract = makeContract({
+				id: 'old',
+				participantDid: 'did:decentrl:bob',
+				expiresAt: now + 3600,
+				timestamp: now,
+			});
+
+			const newContract = makeContract({
+				id: 'new',
+				participantDid: 'did:decentrl:bob',
+				expiresAt: now + 7200,
+				timestamp: now + 100,
+			});
+
+			(transport as any).activeContracts = [oldContract, newContract];
+
+			// First cleanup: mark as superseded
+			transport.processContractCleanup();
+			expect(transport.getActiveContracts()).toHaveLength(2);
+
+			// Advance time past 7 days
+			const sevenDaysMs = 7 * 24 * 60 * 60 * 1000;
+			vi.spyOn(Date, 'now').mockReturnValue(Date.now() + sevenDaysMs);
+
+			transport.processContractCleanup();
+			expect(transport.getActiveContracts()).toHaveLength(1);
+			expect(transport.getActiveContracts()[0].id).toBe('new');
+
+			vi.restoreAllMocks();
+		});
+
+		it('does not purge before timeout without confirmation', () => {
+			const now = Math.floor(Date.now() / 1000);
+
+			const oldContract = makeContract({
+				id: 'old',
+				participantDid: 'did:decentrl:bob',
+				expiresAt: now + 3600,
+				timestamp: now,
+			});
+
+			const newContract = makeContract({
+				id: 'new',
+				participantDid: 'did:decentrl:bob',
+				expiresAt: now + 7200,
+				timestamp: now + 100,
+			});
+
+			(transport as any).activeContracts = [oldContract, newContract];
+
+			// First cleanup: mark as superseded
+			transport.processContractCleanup();
+
+			// Advance time by 3 days (less than 7)
+			const threeDaysMs = 3 * 24 * 60 * 60 * 1000;
+			vi.spyOn(Date, 'now').mockReturnValue(Date.now() + threeDaysMs);
+
+			// Second cleanup: should NOT purge yet
+			transport.processContractCleanup();
+			expect(transport.getActiveContracts()).toHaveLength(2);
+
+			vi.restoreAllMocks();
+		});
+
+		it('handles multiple participants independently', () => {
+			const now = Math.floor(Date.now() / 1000);
+
+			const bobOld = makeContract({
+				id: 'bob-old',
+				participantDid: 'did:decentrl:bob',
+				expiresAt: now + 3600,
+				timestamp: now,
+			});
+
+			const bobNew = makeContract({
+				id: 'bob-new',
+				participantDid: 'did:decentrl:bob',
+				expiresAt: now + 7200,
+				timestamp: now + 100,
+			});
+
+			const carolOnly = makeContract({
+				id: 'carol-only',
+				participantDid: 'did:decentrl:carol',
+				expiresAt: now + 3600,
+				timestamp: now,
+			});
+
+			(transport as any).activeContracts = [bobOld, bobNew, carolOnly];
+
+			// Mark as superseded
+			transport.processContractCleanup();
+
+			// Confirm bob's new contract
+			(transport as any).confirmedNewContracts.add('bob-new');
+
+			transport.processContractCleanup();
+
+			const active = transport.getActiveContracts();
+			expect(active).toHaveLength(2);
+			expect(active.map((c) => c.id).sort()).toEqual(['bob-new', 'carol-only']);
+		});
+	});
+
+	describe('processAutoRenewals', () => {
+		let transport: DirectTransport;
+		let httpPost: ReturnType<typeof vi.fn>;
+
+		beforeEach(() => {
+			httpPost = vi.fn(async () => ({ data: { type: 'SUCCESS' } }));
+			transport = new DirectTransport({ httpPost });
+		});
+
+		it('initiates renewal when contract is near expiry and DID sorts lower', async () => {
+			const now = Date.now();
+			const nowSec = Math.floor(now / 1000);
+			const lifetime = 3600;
+			const timestamp = nowSec - lifetime * 0.9; // 90% elapsed
+
+			// "alice" < "bob" alphabetically, so alice initiates
+			const contract = makeContract({
+				id: 'c1',
+				participantDid: 'did:decentrl:bob',
+				expiresAt: timestamp + lifetime,
+				timestamp,
+			});
+			contract.signedCommunicationContract.communication_contract.requestor_did =
+				'did:decentrl:alice';
+
+			// Set up identity
+			(transport as any).identity = {
+				did: 'did:decentrl:alice',
+				mediatorDid: 'did:web:mediator',
+				mediatorEndpoint: 'http://mediator',
+				keys: {
+					signing: {
+						privateKey: new Uint8Array(32),
+						publicKey: new Uint8Array(32),
+					},
+					encryption: {
+						privateKey: new Uint8Array(32),
+						publicKey: new Uint8Array(32),
+					},
+					storageKey: new Uint8Array(32),
+				},
+			};
+			(transport as any).activeContracts = [contract];
+
+			const requestSpy = vi.spyOn(transport, 'requestContract').mockResolvedValue();
+
+			await transport.processAutoRenewals(0.2);
+
+			expect(requestSpy).toHaveBeenCalledWith('did:decentrl:bob', lifetime);
+		});
+
+		it('does NOT initiate when DID sorts higher than participant', async () => {
+			const now = Date.now();
+			const nowSec = Math.floor(now / 1000);
+			const lifetime = 3600;
+			const timestamp = nowSec - lifetime * 0.9;
+
+			const contract = makeContract({
+				id: 'c1',
+				participantDid: 'did:decentrl:aaa', // alice > aaa
+				expiresAt: timestamp + lifetime,
+				timestamp,
+			});
+
+			(transport as any).identity = {
+				did: 'did:decentrl:alice',
+				mediatorDid: 'did:web:mediator',
+				mediatorEndpoint: 'http://mediator',
+				keys: {
+					signing: {
+						privateKey: new Uint8Array(32),
+						publicKey: new Uint8Array(32),
+					},
+					encryption: {
+						privateKey: new Uint8Array(32),
+						publicKey: new Uint8Array(32),
+					},
+					storageKey: new Uint8Array(32),
+				},
+			};
+			(transport as any).activeContracts = [contract];
+
+			const requestSpy = vi.spyOn(transport, 'requestContract').mockResolvedValue();
+
+			await transport.processAutoRenewals(0.2);
+
+			expect(requestSpy).not.toHaveBeenCalled();
+		});
+
+		it('does NOT initiate when contract is not near expiry', async () => {
+			const nowSec = Math.floor(Date.now() / 1000);
+			const lifetime = 3600;
+			const timestamp = nowSec - lifetime * 0.1; // Only 10% elapsed
+
+			const contract = makeContract({
+				id: 'c1',
+				participantDid: 'did:decentrl:bob',
+				expiresAt: timestamp + lifetime,
+				timestamp,
+			});
+
+			(transport as any).identity = {
+				did: 'did:decentrl:alice',
+				mediatorDid: 'did:web:mediator',
+				mediatorEndpoint: 'http://mediator',
+				keys: {
+					signing: {
+						privateKey: new Uint8Array(32),
+						publicKey: new Uint8Array(32),
+					},
+					encryption: {
+						privateKey: new Uint8Array(32),
+						publicKey: new Uint8Array(32),
+					},
+					storageKey: new Uint8Array(32),
+				},
+			};
+			(transport as any).activeContracts = [contract];
+
+			const requestSpy = vi.spyOn(transport, 'requestContract').mockResolvedValue();
+
+			await transport.processAutoRenewals(0.2);
+
+			expect(requestSpy).not.toHaveBeenCalled();
+		});
+
+		it('prevents duplicate in-flight renewals for the same DID', async () => {
+			const nowSec = Math.floor(Date.now() / 1000);
+			const lifetime = 3600;
+			const timestamp = nowSec - lifetime * 0.9;
+
+			const contract = makeContract({
+				id: 'c1',
+				participantDid: 'did:decentrl:bob',
+				expiresAt: timestamp + lifetime,
+				timestamp,
+			});
+
+			(transport as any).identity = {
+				did: 'did:decentrl:alice',
+				mediatorDid: 'did:web:mediator',
+				mediatorEndpoint: 'http://mediator',
+				keys: {
+					signing: {
+						privateKey: new Uint8Array(32),
+						publicKey: new Uint8Array(32),
+					},
+					encryption: {
+						privateKey: new Uint8Array(32),
+						publicKey: new Uint8Array(32),
+					},
+					storageKey: new Uint8Array(32),
+				},
+			};
+			(transport as any).activeContracts = [contract];
+
+			let resolveRequest: () => void;
+			const blockingPromise = new Promise<void>((resolve) => {
+				resolveRequest = resolve;
+			});
+
+			const requestSpy = vi.spyOn(transport, 'requestContract').mockReturnValue(blockingPromise);
+
+			// Start first renewal (will block)
+			const renewal1 = transport.processAutoRenewals(0.2);
+
+			// Start second renewal while first is in-flight
+			const renewal2 = transport.processAutoRenewals(0.2);
+
+			resolveRequest!();
+			await renewal1;
+			await renewal2;
+
+			// Should only request once
+			expect(requestSpy).toHaveBeenCalledTimes(1);
+		});
+
+		it('clears in-flight flag even when request fails', async () => {
+			const nowSec = Math.floor(Date.now() / 1000);
+			const lifetime = 3600;
+			const timestamp = nowSec - lifetime * 0.9;
+
+			const contract = makeContract({
+				id: 'c1',
+				participantDid: 'did:decentrl:bob',
+				expiresAt: timestamp + lifetime,
+				timestamp,
+			});
+
+			(transport as any).identity = {
+				did: 'did:decentrl:alice',
+				mediatorDid: 'did:web:mediator',
+				mediatorEndpoint: 'http://mediator',
+				keys: {
+					signing: {
+						privateKey: new Uint8Array(32),
+						publicKey: new Uint8Array(32),
+					},
+					encryption: {
+						privateKey: new Uint8Array(32),
+						publicKey: new Uint8Array(32),
+					},
+					storageKey: new Uint8Array(32),
+				},
+			};
+			(transport as any).activeContracts = [contract];
+
+			const requestSpy = vi
+				.spyOn(transport, 'requestContract')
+				.mockRejectedValueOnce(new Error('network error'))
+				.mockResolvedValueOnce();
+
+			await transport.processAutoRenewals(0.2);
+
+			// First call fails, but in-flight flag should be cleared
+			expect(requestSpy).toHaveBeenCalledTimes(1);
+
+			// Second call should work
+			await transport.processAutoRenewals(0.2);
+			expect(requestSpy).toHaveBeenCalledTimes(2);
+		});
+	});
+
+	describe('refreshContracts', () => {
+		it('filters out purged contracts', async () => {
+			const now = Math.floor(Date.now() / 1000);
+
+			const httpPost = vi.fn(async () => ({
+				data: {
+					type: 'SUCCESS',
+					payload: {
+						communication_contracts: [
+							{
+								signed_communication_contract: {
+									communication_contract: {
+										requestor_did: 'did:decentrl:alice',
+										recipient_did: 'did:decentrl:bob',
+										requestor_signing_key_id: 'did:decentrl:alice#signing',
+										recipient_signing_key_id: 'did:decentrl:bob#signing',
+										requestor_encryption_public_key: 'key-a',
+										recipient_encryption_public_key: 'key-b',
+										expires_at: now + 3600,
+										timestamp: now,
+									},
+									requestor_signature: 'sig-a',
+									recipient_signature: 'sig-b',
+								},
+							},
+						],
+					},
+				},
+			}));
+
+			const transport = new DirectTransport({ httpPost });
+
+			(transport as any).identity = {
+				did: 'did:decentrl:alice',
+				mediatorDid: 'did:web:mediator',
+				mediatorEndpoint: 'http://mediator',
+				keys: {
+					signing: {
+						privateKey: new Uint8Array(32),
+						publicKey: new Uint8Array(32),
+					},
+					encryption: {
+						privateKey: new Uint8Array(32),
+						publicKey: new Uint8Array(32),
+					},
+					storageKey: new Uint8Array(32),
+				},
+			};
+
+			// Refresh to get the contract
+			const contracts = await transport.refreshContracts();
+			expect(contracts).toHaveLength(1);
+
+			const contractId = contracts[0].id;
+
+			// Add to purged set
+			(transport as any).purgedContractIds.add(contractId);
+
+			// Refresh again — purged contract should be filtered out
+			await transport.refreshContracts();
+			expect(transport.getActiveContracts()).toHaveLength(0);
+
+			// purgedContractIds should be cleared after refresh
+			expect((transport as any).purgedContractIds.size).toBe(0);
+		});
+	});
+});