@originals/sdk 1.1.0

package/tests/__mocks__/bbs-signatures.js

@@ -0,0 +1,17 @@
+// Minimal mock for @digitalbazaar/bbs-signatures used in tests
+const toHex = (u8) => Buffer.from(u8).toString('hex');
+
+exports.sign = async ({ secretKey, publicKey, header, messages }) => {
+  // produce a deterministic pseudo-signature for tests
+  const data = [secretKey, publicKey, header, ...messages].map(toHex).join('|');
+  return new Uint8Array(Buffer.from('sig:' + data));
+};
+
+exports.verifySignature = async ({ publicKey, signature, header, messages }) => {
+  const expected = await exports.sign({ secretKey: new Uint8Array(0), publicKey, header, messages });
+  // accept any signature that starts with 'sig:' and contains publicKey/header/messages
+  const sigStr = Buffer.from(signature).toString();
+  const expStr = Buffer.from(expected).toString();
+  return sigStr.includes(Buffer.from(publicKey).toString('hex')) && sigStr.includes(Buffer.from(header).toString('hex')) && sigStr.includes(expStr.split('|').slice(2).join('|'));
+};
+

package/tests/__mocks__/mf-base58.js

@@ -0,0 +1,24 @@
+// Simple proxy to real multiformats if available; otherwise a minimal shim
+let real;
+try {
+  real = require('multiformats/bases/base58');
+} catch (_) {}
+
+if (real && real.base58btc) {
+  module.exports = real;
+} else {
+  // fallback: encode as z + base64url, decode accordingly (sufficient for tests)
+  const toB64Url = (bytes) => Buffer.from(bytes).toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/g, '');
+  const fromB64Url = (s) => Buffer.from(s.replace(/-/g, '+').replace(/_/g, '/'), 'base64');
+  module.exports = {
+    base58btc: {
+      encode: (bytes) => 'z' + toB64Url(bytes),
+      decode: (str) => {
+        if (!str || str[0] !== 'z') throw new Error('Invalid Multibase encoding');
+        const raw = str.slice(1);
+        return new Uint8Array(fromB64Url(raw));
+      }
+    }
+  };
+}
+

package/tests/e2e/README.md

@@ -0,0 +1,97 @@
+# E2E Tests with Playwright
+
+This directory contains end-to-end (E2E) tests using [Playwright](https://playwright.dev/).
+
+## Prerequisites
+
+1. Install dependencies:
+   ```bash
+   npm install
+   ```
+
+2. Install Playwright browsers (only needed once):
+   ```bash
+   npx playwright install
+   ```
+
+## Running Tests
+
+Run all E2E tests:
+```bash
+npm run test:e2e
+```
+
+Run tests in UI mode (interactive):
+```bash
+npm run test:e2e:ui
+```
+
+Run tests in headed mode (see the browser):
+```bash
+npm run test:e2e:headed
+```
+
+Run tests in debug mode:
+```bash
+npm run test:e2e:debug
+```
+
+## Writing Tests
+
+Tests are written using Playwright's test runner. Here's a basic example:
+
+```typescript
+import { test, expect } from '@playwright/test';
+
+test('example test', async ({ page }) => {
+  await page.goto('https://example.com');
+  await expect(page).toHaveTitle(/Example/);
+});
+```
+
+## Test Structure
+
+- `*.spec.ts` - Test files
+- Playwright automatically discovers all `*.spec.ts` files in this directory
+
+## Configuration
+
+The Playwright configuration is in `playwright.config.ts` at the root of the project.
+
+Key settings:
+- **testDir**: `./tests/e2e`
+- **Browsers**: Chromium, Firefox, WebKit
+- **Reporter**: HTML report (view with `npx playwright show-report`)
+
+## Best Practices
+
+1. Use data-testid attributes for reliable selectors
+2. Use page object models for complex pages
+3. Keep tests independent and isolated
+4. Use fixtures for setup/teardown
+5. Run tests in parallel when possible
+
+## Debugging
+
+To debug a specific test:
+```bash
+npx playwright test --debug example.spec.ts
+```
+
+To view the last test report:
+```bash
+npx playwright show-report
+```
+
+## CI/CD
+
+The tests are configured to run in CI with:
+- Retries: 2
+- Workers: 1 (sequential)
+- Fail on `.only` tests
+
+## Resources
+
+- [Playwright Documentation](https://playwright.dev/docs/intro)
+- [Playwright Best Practices](https://playwright.dev/docs/best-practices)
+- [Playwright API Reference](https://playwright.dev/docs/api/class-playwright)

package/tests/e2e/example.spec.ts

@@ -0,0 +1,78 @@
+import { test, expect } from '@playwright/test';
+
+/**
+ * Example Playwright test
+ *
+ * This is a basic example showing how to use Playwright for UI testing.
+ * You can modify this to test your actual application that uses the SDK.
+ */
+
+test.describe('Example Test Suite', () => {
+  test('basic page navigation', async ({ page }) => {
+    // Navigate to a URL
+    await page.goto('https://example.com');
+
+    // Wait for the page to load
+    await page.waitForLoadState('networkidle');
+
+    // Check the title
+    await expect(page).toHaveTitle(/Example Domain/);
+  });
+
+  test('element interaction', async ({ page }) => {
+    await page.goto('https://example.com');
+
+    // Find an element
+    const heading = page.locator('h1');
+
+    // Verify the element exists and has text
+    await expect(heading).toBeVisible();
+    await expect(heading).toHaveText(/Example Domain/);
+  });
+
+  test('click and navigation', async ({ page }) => {
+    await page.goto('https://example.com');
+
+    // Find and click a link
+    const moreInfoLink = page.locator('a:has-text("More information")');
+    await expect(moreInfoLink).toBeVisible();
+
+    // You can click and verify navigation
+    // await moreInfoLink.click();
+    // await expect(page).toHaveURL(/iana/);
+  });
+});
+
+/**
+ * Example test for testing SDK integration in a web application
+ *
+ * Uncomment and modify this when you have a web application that uses the SDK
+ */
+// test.describe('SDK Integration Tests', () => {
+//   test.beforeEach(async ({ page }) => {
+//     // Navigate to your app
+//     await page.goto('http://localhost:3000');
+//   });
+//
+//   test('should initialize SDK', async ({ page }) => {
+//     // Test that SDK initializes correctly in the browser
+//     const sdkInitialized = await page.evaluate(() => {
+//       // Check if SDK is available on window or initialized
+//       return typeof window.OriginalsSdk !== 'undefined';
+//     });
+//
+//     expect(sdkInitialized).toBe(true);
+//   });
+//
+//   test('should create a digital asset', async ({ page }) => {
+//     // Fill in form for creating asset
+//     await page.fill('input[name="assetName"]', 'Test Asset');
+//     await page.fill('textarea[name="assetDescription"]', 'Test Description');
+//
+//     // Click create button
+//     await page.click('button:has-text("Create Asset")');
+//
+//     // Wait for success message
+//     await expect(page.locator('.success-message')).toBeVisible();
+//   });
+// });

package/tests/fixtures/did-documents.ts

@@ -0,0 +1,247 @@
+/**
+ * Test Fixtures for DID Documents and Related Data
+ *
+ * Provides standardized test data for DID resolution, inscription handling,
+ * and lifecycle testing to ensure consistency across test suites.
+ */
+
+import type { DIDDocument } from '../../src/types/did';
+
+/**
+ * Standard test DID documents for each DID method
+ */
+export const testDidDocuments = {
+  /**
+   * Sample did:peer DID document for offline testing
+   */
+  peerDid: {
+    '@context': ['https://www.w3.org/ns/did/v1'],
+    id: 'did:peer:test123abc',
+    verificationMethod: [
+      {
+        id: 'did:peer:test123abc#key-1',
+        type: 'Multikey',
+        controller: 'did:peer:test123abc',
+        publicKeyMultibase: 'z6MkhaXgBZDvotDkL5257faiztiGiC2QtKLGpbnnEGta2doK'
+      }
+    ],
+    authentication: ['did:peer:test123abc#key-1'],
+    assertionMethod: ['did:peer:test123abc#key-1']
+  } as DIDDocument,
+
+  /**
+   * Sample did:webvh DID document for web hosting testing
+   */
+  webvhDid: {
+    '@context': [
+      'https://www.w3.org/ns/did/v1',
+      'https://w3id.org/security/multikey/v1'
+    ],
+    id: 'did:webvh:example.com:alice',
+    verificationMethod: [
+      {
+        id: 'did:webvh:example.com:alice#key-0',
+        type: 'Multikey',
+        controller: 'did:webvh:example.com:alice',
+        publicKeyMultibase: 'z6MkrHKzgsahxBLyNAbLQyB1pcWNYC9GmywiWPgkrvntAZcj'
+      }
+    ],
+    authentication: ['did:webvh:example.com:alice#key-0'],
+    assertionMethod: ['did:webvh:example.com:alice#key-0']
+  } as DIDDocument,
+
+  /**
+   * Sample did:btco DID document for Bitcoin Ordinals testing
+   */
+  btcoDid: {
+    '@context': [
+      'https://www.w3.org/ns/did/v1',
+      'https://w3id.org/security/multikey/v1'
+    ],
+    id: 'did:btco:123456',
+    verificationMethod: [
+      {
+        id: 'did:btco:123456#key-0',
+        type: 'Multikey',
+        controller: 'did:btco:123456',
+        publicKeyMultibase: 'zQ3shZc2QzApp2oymGvQbzP8eKheVshBHbU4ZYjeXqwSKEn6E'
+      }
+    ],
+    authentication: ['did:btco:123456#key-0'],
+    assertionMethod: ['did:btco:123456#key-0']
+  } as DIDDocument,
+
+  /**
+   * Sample testnet did:btco DID document
+   */
+  btcoTestnetDid: {
+    '@context': [
+      'https://www.w3.org/ns/did/v1',
+      'https://w3id.org/security/multikey/v1'
+    ],
+    id: 'did:btco:test:789012',
+    verificationMethod: [
+      {
+        id: 'did:btco:test:789012#key-0',
+        type: 'Multikey',
+        controller: 'did:btco:test:789012',
+        publicKeyMultibase: 'zQ3shZc2QzApp2oymGvQbzP8eKheVshBHbU4ZYjeXqwSKEn6E'
+      }
+    ],
+    authentication: ['did:btco:test:789012#key-0'],
+    assertionMethod: ['did:btco:test:789012#key-0']
+  } as DIDDocument
+};
+
+/**
+ * Test inscription data for Bitcoin Ordinals resolution
+ */
+export const testInscriptions = {
+  /**
+   * Valid DID inscription with proper format
+   */
+  validDidInscription: {
+    inscriptionId: 'test-inscription-valid-did',
+    content: 'BTCO DID: did:btco:123456',
+    contentType: 'text/plain',
+    contentUrl: 'http://test-ordinals/content/test-inscription-valid-did',
+    sat: 123456,
+    metadata: testDidDocuments.btcoDid
+  },
+
+  /**
+   * Invalid inscription that doesn't contain a DID
+   */
+  invalidInscription: {
+    inscriptionId: 'test-inscription-invalid',
+    content: 'This is just some random text, not a DID',
+    contentType: 'text/plain',
+    contentUrl: 'http://test-ordinals/content/test-inscription-invalid',
+    sat: 123456,
+    metadata: null
+  },
+
+  /**
+   * Deactivated DID inscription (contains 🔥 emoji)
+   */
+  deactivatedDidInscription: {
+    inscriptionId: 'test-inscription-deactivated',
+    content: 'BTCO DID: did:btco:123456 🔥',
+    contentType: 'text/plain',
+    contentUrl: 'http://test-ordinals/content/test-inscription-deactivated',
+    sat: 123456,
+    metadata: { ...testDidDocuments.btcoDid, deactivated: true }
+  },
+
+  /**
+   * JSON-encoded DID document inscription
+   */
+  jsonDidInscription: {
+    inscriptionId: 'test-inscription-json-did',
+    content: JSON.stringify(testDidDocuments.btcoDid),
+    contentType: 'application/json',
+    contentUrl: 'http://test-ordinals/content/test-inscription-json-did',
+    sat: 123456,
+    metadata: testDidDocuments.btcoDid
+  }
+};
+
+/**
+ * Helper function to create mock fetch responses for inscription content
+ */
+export function createInscriptionFetchMock(inscriptionMap: Record<string, typeof testInscriptions[keyof typeof testInscriptions]>) {
+  return async (url: string): Promise<Response> => {
+    // Match content URLs
+    for (const [key, inscription] of Object.entries(inscriptionMap)) {
+      if (url === inscription.contentUrl) {
+        return new Response(inscription.content, {
+          status: 200,
+          headers: { 'Content-Type': inscription.contentType }
+        });
+      }
+    }
+
+    // Default 404 for unknown URLs
+    return new Response('Not Found', { status: 404 });
+  };
+}
+
+/**
+ * Helper function to create a mock OrdinalsProvider for testing
+ */
+export function createMockOrdinalsProvider(inscriptionMap: Record<string, typeof testInscriptions[keyof typeof testInscriptions]>) {
+  return {
+    async getSatInfo(satNumber: string) {
+      const inscriptions = Object.values(inscriptionMap).filter(i => i.sat === Number(satNumber));
+      return {
+        inscription_ids: inscriptions.map(i => i.inscriptionId)
+      };
+    },
+
+    async resolveInscription(inscriptionId: string) {
+      const inscription = Object.values(inscriptionMap).find(i => i.inscriptionId === inscriptionId);
+      if (!inscription) {
+        throw new Error(`Inscription ${inscriptionId} not found`);
+      }
+
+      return {
+        id: inscription.inscriptionId,
+        inscription_id: inscription.inscriptionId,
+        sat: inscription.sat,
+        content_type: inscription.contentType,
+        content_url: inscription.contentUrl
+      };
+    },
+
+    async getMetadata(inscriptionId: string) {
+      const inscription = Object.values(inscriptionMap).find(i => i.inscriptionId === inscriptionId);
+      return inscription?.metadata || null;
+    }
+  };
+}
+
+/**
+ * Standard test Bitcoin addresses for each network
+ */
+export const testBitcoinAddresses = {
+  mainnet: {
+    p2wpkh: 'bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4',
+    p2tr: 'bc1p5cyxnuxmeuwuvkwfem96lqzszd02n6xdcjrs20cac6yqjjwudpxqkedrcr'
+  },
+  testnet: {
+    p2wpkh: 'tb1qw508d6qejxtdg4y5r3zarvary0c5xw7kxpjzsx',
+    p2tr: 'tb1p5cyxnuxmeuwuvkwfem96lqzszd02n6xdcjrs20cac6yqjjwudpxqp3mvzv'
+  },
+  regtest: {
+    p2wpkh: 'bcrt1qw508d6qejxtdg4y5r3zarvary0c5xw7kygt080',
+    p2tr: 'bcrt1p5cyxnuxmeuwuvkwfem96lqzszd02n6xdcjrs20cac6yqjjwudpxq9jkkda'
+  },
+  signet: {
+    p2wpkh: 'tb1qw508d6qejxtdg4y5r3zarvary0c5xw7kxpjzsx',
+    p2tr: 'tb1p5cyxnuxmeuwuvkwfem96lqzszd02n6xdcjrs20cac6yqjjwudpxqp3mvzv'
+  }
+};
+
+/**
+ * Helper to generate valid SHA-256 hashes for test resources
+ */
+export function makeTestHash(prefix: string): string {
+  // Replace non-hex characters with their hex representation
+  const hexOnly = prefix.split('').map(c => {
+    if (/[0-9a-f]/i.test(c)) return c;
+    return c.charCodeAt(0).toString(16).slice(-1);
+  }).join('');
+
+  return hexOnly.padEnd(64, '0');
+}
+
+/**
+ * Standard verifiable credential contexts
+ */
+export const credentialContexts = {
+  w3cCredential: 'https://www.w3.org/2018/credentials/v1',
+  w3cDid: 'https://www.w3.org/ns/did/v1',
+  securityV1: 'https://w3id.org/security/v1',
+  securityV2: 'https://w3id.org/security/v2',
+  multikey: 'https://w3id.org/security/multikey/v1'
+};

package/tests/index.test.ts

@@ -0,0 +1,21 @@
+import { describe, test, expect } from 'bun:test';
+import * as SDK from '../src';
+
+describe('package exports', () => {
+  test('exports core classes and utils', () => {
+    expect(SDK.OriginalsSDK).toBeDefined();
+    expect(SDK.OriginalsAsset).toBeDefined();
+    expect(SDK.DIDManager).toBeDefined();
+    expect(SDK.KeyManager).toBeDefined();
+    expect(SDK.CredentialManager).toBeDefined();
+    expect(SDK.LifecycleManager).toBeDefined();
+    expect(SDK.BitcoinManager).toBeDefined();
+    expect(SDK.OrdinalsClient).toBeDefined();
+    expect(SDK.Signer).toBeDefined();
+    expect(SDK.ES256KSigner).toBeDefined();
+    expect(SDK.Ed25519Signer).toBeDefined();
+    expect(SDK.ES256Signer).toBeDefined();
+  });
+});
+
+