@totemsdk/manifest 0.1.0 → 0.1.1

package/src/__tests__/guards.test.ts

@@ -1,140 +0,0 @@
-/**
- * guards.test.ts
- * Type guard tests for all four manifest kinds.
- * Guards must work on both raw manifests and SignedManifest wrappers.
- */
-
-import {
-  isAppManifest,
-  isCapabilityManifest,
-  isDAppManifest,
-  isEdgeServiceManifest,
-} from '../guards.js';
-import type {
-  AppManifest,
-  CapabilityManifest,
-  DAppManifest,
-  EdgeServiceManifest,
-  SignedManifest,
-} from '../types.js';
-
-const APP: AppManifest = {
-  type: 'app',
-  appId: '',
-  name: 'Test',
-  version: '1.0.0',
-  authorAddress: 'MxAPP',
-  pearTopicKey: 'a'.repeat(64),
-  price: '0',
-  category: [],
-  permissions: [],
-  description: '',
-  minTotemVersion: '0.1.0',
-};
-
-const CAP: CapabilityManifest = {
-  type: 'capability',
-  capabilityId: '',
-  capabilityName: 'x',
-  agentAddress: 'MxCAP',
-  agentIdentityKey: 'b'.repeat(64),
-  description: '',
-  inputSchema: {},
-  outputSchema: {},
-  pricePerCall: '1',
-  expiresAt: 0,
-  tags: [],
-};
-
-const DAPP: DAppManifest = {
-  type: 'dapp',
-  dappId: '',
-  name: 'x',
-  version: '1.0.0',
-  authorAddress: 'MxDAPP',
-  contractHash: 'c'.repeat(64),
-  abi: [],
-  price: '0',
-  category: [],
-  description: '',
-};
-
-const EDGE: EdgeServiceManifest = {
-  type: 'edge-service',
-  serviceId: '',
-  name: 'x',
-  version: '1.0.0',
-  operatorAddress: 'MxEDGE',
-  serviceType: 'lookup-provider',
-  description: '',
-  capabilities: [],
-  tags: [],
-};
-
-function mockSigned<T extends { type: string }>(manifest: T): SignedManifest<T extends AppManifest ? AppManifest : T extends CapabilityManifest ? CapabilityManifest : T extends DAppManifest ? DAppManifest : EdgeServiceManifest> {
-  return {
-    manifest: manifest as any,
-    authorAddress: 'MxSIGNER',
-    signerPublicKey: 'aa'.repeat(544),
-    signedAt: Date.now(),
-    signature: 'bb'.repeat(100),
-  };
-}
-
-describe('isAppManifest', () => {
-  it('returns true for raw AppManifest', () => expect(isAppManifest(APP)).toBe(true));
-  it('returns true for SignedManifest<AppManifest>', () => expect(isAppManifest(mockSigned(APP))).toBe(true));
-  it('returns false for CapabilityManifest', () => expect(isAppManifest(CAP)).toBe(false));
-  it('returns false for DAppManifest', () => expect(isAppManifest(DAPP)).toBe(false));
-  it('returns false for EdgeServiceManifest', () => expect(isAppManifest(EDGE)).toBe(false));
-  it('returns false for null', () => expect(isAppManifest(null)).toBe(false));
-  it('returns false for undefined', () => expect(isAppManifest(undefined)).toBe(false));
-  it('returns false for SignedManifest<CapabilityManifest>', () => expect(isAppManifest(mockSigned(CAP))).toBe(false));
-});
-
-describe('isCapabilityManifest', () => {
-  it('returns true for raw CapabilityManifest', () => expect(isCapabilityManifest(CAP)).toBe(true));
-  it('returns true for SignedManifest<CapabilityManifest>', () => expect(isCapabilityManifest(mockSigned(CAP))).toBe(true));
-  it('returns false for AppManifest', () => expect(isCapabilityManifest(APP)).toBe(false));
-  it('returns false for DAppManifest', () => expect(isCapabilityManifest(DAPP)).toBe(false));
-  it('returns false for EdgeServiceManifest', () => expect(isCapabilityManifest(EDGE)).toBe(false));
-  it('returns false for null', () => expect(isCapabilityManifest(null)).toBe(false));
-});
-
-describe('isDAppManifest', () => {
-  it('returns true for raw DAppManifest', () => expect(isDAppManifest(DAPP)).toBe(true));
-  it('returns true for SignedManifest<DAppManifest>', () => expect(isDAppManifest(mockSigned(DAPP))).toBe(true));
-  it('returns false for AppManifest', () => expect(isDAppManifest(APP)).toBe(false));
-  it('returns false for CapabilityManifest', () => expect(isDAppManifest(CAP)).toBe(false));
-  it('returns false for EdgeServiceManifest', () => expect(isDAppManifest(EDGE)).toBe(false));
-  it('returns false for null', () => expect(isDAppManifest(null)).toBe(false));
-});
-
-describe('isEdgeServiceManifest', () => {
-  it('returns true for raw EdgeServiceManifest', () => expect(isEdgeServiceManifest(EDGE)).toBe(true));
-  it('returns true for SignedManifest<EdgeServiceManifest>', () => expect(isEdgeServiceManifest(mockSigned(EDGE))).toBe(true));
-  it('returns false for AppManifest', () => expect(isEdgeServiceManifest(APP)).toBe(false));
-  it('returns false for CapabilityManifest', () => expect(isEdgeServiceManifest(CAP)).toBe(false));
-  it('returns false for DAppManifest', () => expect(isEdgeServiceManifest(DAPP)).toBe(false));
-  it('returns false for null', () => expect(isEdgeServiceManifest(null)).toBe(false));
-});
-
-describe('cross-type guard correctness', () => {
-  const allManifests = [APP, CAP, DAPP, EDGE];
-  const guards = [isAppManifest, isCapabilityManifest, isDAppManifest, isEdgeServiceManifest];
-
-  it('each manifest is identified by exactly one guard', () => {
-    for (const m of allManifests) {
-      const trueCount = guards.filter(g => g(m)).length;
-      expect(trueCount).toBe(1);
-    }
-  });
-
-  it('each signed manifest is identified by exactly one guard', () => {
-    for (const m of allManifests) {
-      const signed = mockSigned(m);
-      const trueCount = guards.filter(g => g(signed)).length;
-      expect(trueCount).toBe(1);
-    }
-  });
-});

package/src/__tests__/id.test.ts

@@ -1,143 +0,0 @@
-/**
- * id.test.ts
- * Stable IDs: same inputs → same ID; version change → same ID; key field change → different ID.
- */
-
-import { computeManifestId } from '../id.js';
-import type {
-  AppManifest,
-  CapabilityManifest,
-  DAppManifest,
-  EdgeServiceManifest,
-} from '../types.js';
-
-const APP: AppManifest = {
-  type: 'app',
-  appId: '',
-  name: 'Test App',
-  version: '1.0.0',
-  authorAddress: 'MxAUTHOR1111',
-  pearTopicKey: 'aaaa1111',
-  price: '0',
-  category: ['finance'],
-  permissions: ['wallet:read-balance'],
-  description: 'Test',
-  minTotemVersion: '0.1.0',
-};
-
-const CAP: CapabilityManifest = {
-  type: 'capability',
-  capabilityId: '',
-  capabilityName: 'invoice-translate',
-  agentAddress: 'MxAGENT2222',
-  agentIdentityKey: 'bbbb2222',
-  description: 'Translates',
-  inputSchema: {},
-  outputSchema: {},
-  pricePerCall: '1',
-  expiresAt: 9999,
-  tags: [],
-};
-
-const DAPP: DAppManifest = {
-  type: 'dapp',
-  dappId: '',
-  name: 'Swap',
-  version: '1.0.0',
-  authorAddress: 'MxAUTHOR3333',
-  contractHash: 'cccc3333',
-  abi: [],
-  price: '0',
-  category: [],
-  description: '',
-};
-
-const EDGE: EdgeServiceManifest = {
-  type: 'edge-service',
-  serviceId: '',
-  name: 'My Sensor',
-  version: '1.0.0',
-  operatorAddress: 'MxOPERATOR4444',
-  serviceType: 'sensor',
-  description: '',
-  capabilities: [],
-  tags: [],
-};
-
-describe('computeManifestId — stable IDs', () => {
-  it('returns the same ID for identical AppManifest inputs', () => {
-    expect(computeManifestId(APP)).toBe(computeManifestId({ ...APP }));
-  });
-
-  it('AppManifest: ID is stable when version changes', () => {
-    expect(computeManifestId(APP)).toBe(computeManifestId({ ...APP, version: '2.0.0' }));
-  });
-
-  it('AppManifest: ID changes when authorAddress changes', () => {
-    expect(computeManifestId(APP)).not.toBe(computeManifestId({ ...APP, authorAddress: 'MxOTHER' }));
-  });
-
-  it('AppManifest: ID changes when pearTopicKey changes', () => {
-    expect(computeManifestId(APP)).not.toBe(computeManifestId({ ...APP, pearTopicKey: 'bbbb' }));
-  });
-
-  it('returns the same ID for identical CapabilityManifest inputs', () => {
-    expect(computeManifestId(CAP)).toBe(computeManifestId({ ...CAP }));
-  });
-
-  it('CapabilityManifest: ID is stable when expiresAt changes', () => {
-    expect(computeManifestId(CAP)).toBe(computeManifestId({ ...CAP, expiresAt: 0 }));
-  });
-
-  it('CapabilityManifest: ID changes when agentAddress changes', () => {
-    expect(computeManifestId(CAP)).not.toBe(computeManifestId({ ...CAP, agentAddress: 'MxOTHER' }));
-  });
-
-  it('CapabilityManifest: ID changes when capabilityName changes', () => {
-    expect(computeManifestId(CAP)).not.toBe(computeManifestId({ ...CAP, capabilityName: 'other-capability' }));
-  });
-
-  it('returns the same ID for identical DAppManifest inputs', () => {
-    expect(computeManifestId(DAPP)).toBe(computeManifestId({ ...DAPP }));
-  });
-
-  it('DAppManifest: ID is stable when version changes', () => {
-    expect(computeManifestId(DAPP)).toBe(computeManifestId({ ...DAPP, version: '9.9.9' }));
-  });
-
-  it('DAppManifest: ID changes when contractHash changes', () => {
-    expect(computeManifestId(DAPP)).not.toBe(computeManifestId({ ...DAPP, contractHash: 'dddd' }));
-  });
-
-  it('returns the same ID for identical EdgeServiceManifest inputs', () => {
-    expect(computeManifestId(EDGE)).toBe(computeManifestId({ ...EDGE }));
-  });
-
-  it('EdgeServiceManifest: ID is stable when version changes', () => {
-    expect(computeManifestId(EDGE)).toBe(computeManifestId({ ...EDGE, version: '9.0.0' }));
-  });
-
-  it('EdgeServiceManifest: ID changes when serviceType changes', () => {
-    expect(computeManifestId(EDGE)).not.toBe(computeManifestId({ ...EDGE, serviceType: 'robot' }));
-  });
-
-  it('EdgeServiceManifest: ID changes when name changes', () => {
-    expect(computeManifestId(EDGE)).not.toBe(computeManifestId({ ...EDGE, name: 'Other Sensor' }));
-  });
-
-  it('IDs are 64-character hex strings (SHA3-256)', () => {
-    const id = computeManifestId(APP);
-    expect(id).toMatch(/^[0-9a-f]{64}$/);
-  });
-
-  it('IDs differ across manifest types', () => {
-    const ids = [
-      computeManifestId(APP),
-      computeManifestId(CAP),
-      computeManifestId(DAPP),
-      computeManifestId(EDGE),
-    ];
-    const unique = new Set(ids);
-    expect(unique.size).toBe(4);
-  });
-});

package/src/__tests__/sign-verify.test.ts

@@ -1,157 +0,0 @@
-/**
- * sign-verify.test.ts
- * Round-trip sign → verify for all four manifest types.
- * Also tests tamper detection.
- */
-
-import { signManifest } from '../sign.js';
-import { verifyManifest } from '../verify.js';
-import type {
-  AppManifest,
-  CapabilityManifest,
-  DAppManifest,
-  EdgeServiceManifest,
-} from '../types.js';
-import { computeManifestId } from '../id.js';
-
-jest.setTimeout(60_000);
-
-const TEST_SEED = new Uint8Array(32).fill(0x42);
-const KEY_INDEX = 0;
-
-const APP: AppManifest = {
-  type: 'app',
-  appId: '',
-  name: 'Test App',
-  version: '1.0.0',
-  authorAddress: 'MxAUTHOR0000000000000000000000000000000000000000',
-  pearTopicKey: 'a'.repeat(64),
-  price: '0',
-  category: ['finance'],
-  permissions: ['wallet:read-balance'],
-  description: 'A test app',
-  minTotemVersion: '0.1.0',
-};
-
-const CAPABILITY: CapabilityManifest = {
-  type: 'capability',
-  capabilityId: '',
-  capabilityName: 'invoice-translate',
-  agentAddress: 'MxAGENT0000000000000000000000000000000000000000',
-  agentIdentityKey: 'b'.repeat(64),
-  description: 'Translates invoices',
-  inputSchema: { type: 'object' },
-  outputSchema: { type: 'object' },
-  pricePerCall: '1',
-  expiresAt: Date.now() + 86_400_000,
-  tags: ['finance'],
-};
-
-const DAPP: DAppManifest = {
-  type: 'dapp',
-  dappId: '',
-  name: 'Test dApp',
-  version: '1.0.0',
-  authorAddress: 'MxAUTHOR0000000000000000000000000000000000000000',
-  contractHash: 'c'.repeat(64),
-  abi: [{ name: 'transfer', description: 'Transfer tokens', params: [{ name: 'amount', type: 'string' }] }],
-  price: '0',
-  category: ['defi'],
-  description: 'A test dApp',
-};
-
-const EDGE: EdgeServiceManifest = {
-  type: 'edge-service',
-  serviceId: '',
-  name: 'Test Sensor',
-  version: '1.0.0',
-  operatorAddress: 'MxOPERATOR000000000000000000000000000000000000',
-  serviceType: 'sensor',
-  description: 'A test sensor node',
-  capabilities: ['temperature'],
-  tags: ['iot'],
-};
-
-function withId<T extends { type: string }>(m: T): T {
-  return m;
-}
-
-describe('signManifest + verifyManifest round-trips', () => {
-  let signedAddress: string;
-
-  beforeAll(async () => {
-    const tmp = await signManifest(APP, TEST_SEED, KEY_INDEX);
-    signedAddress = tmp.authorAddress;
-  });
-
-  it('signs and verifies AppManifest', async () => {
-    const app = { ...APP, authorAddress: signedAddress };
-    const signed = await signManifest(app, TEST_SEED, KEY_INDEX);
-    expect(signed.manifest.type).toBe('app');
-    expect(signed.authorAddress).toBe(signedAddress);
-    expect(signed.signature).toBeTruthy();
-    expect(signed.signerPublicKey).toBeTruthy();
-
-    const result = verifyManifest(signed);
-    expect(result.valid).toBe(true);
-    expect(result.signerAddress).toBe(signedAddress);
-  });
-
-  it('signs and verifies CapabilityManifest', async () => {
-    const cap = { ...CAPABILITY, agentAddress: signedAddress };
-    const signed = await signManifest(cap, TEST_SEED, KEY_INDEX);
-    expect(signed.manifest.type).toBe('capability');
-
-    const result = verifyManifest(signed);
-    expect(result.valid).toBe(true);
-  });
-
-  it('signs and verifies DAppManifest', async () => {
-    const dapp = { ...DAPP, authorAddress: signedAddress };
-    const signed = await signManifest(dapp, TEST_SEED, KEY_INDEX);
-    expect(signed.manifest.type).toBe('dapp');
-
-    const result = verifyManifest(signed);
-    expect(result.valid).toBe(true);
-  });
-
-  it('signs and verifies EdgeServiceManifest', async () => {
-    const edge = { ...EDGE, operatorAddress: signedAddress };
-    const signed = await signManifest(edge, TEST_SEED, KEY_INDEX);
-    expect(signed.manifest.type).toBe('edge-service');
-
-    const result = verifyManifest(signed);
-    expect(result.valid).toBe(true);
-  });
-
-  it('detects manifest tampering — changed name field', async () => {
-    const app = { ...APP, authorAddress: signedAddress };
-    const signed = await signManifest(app, TEST_SEED, KEY_INDEX);
-
-    const tampered = {
-      ...signed,
-      manifest: { ...signed.manifest, name: 'EVIL APP' } as AppManifest,
-    };
-
-    const result = verifyManifest(tampered);
-    expect(result.valid).toBe(false);
-  });
-
-  it('detects tampered authorAddress in SignedManifest wrapper', async () => {
-    const app = { ...APP, authorAddress: signedAddress };
-    const signed = await signManifest(app, TEST_SEED, KEY_INDEX);
-
-    const tampered = { ...signed, authorAddress: 'Mx999999999999999999' };
-    const result = verifyManifest(tampered);
-    expect(result.valid).toBe(false);
-  });
-
-  it('detects corrupted signature bytes', async () => {
-    const app = { ...APP, authorAddress: signedAddress };
-    const signed = await signManifest(app, TEST_SEED, KEY_INDEX);
-
-    const corrupted = { ...signed, signature: 'ff' + signed.signature.slice(2) };
-    const result = verifyManifest(corrupted);
-    expect(result.valid).toBe(false);
-  });
-});

package/src/constants.ts

@@ -1,15 +0,0 @@
-export const MANIFEST_VERSION = 1 as const;
-
-export const MANIFEST_TYPE_BYTE = {
-  app: 0x01,
-  capability: 0x02,
-  dapp: 0x03,
-  'edge-service': 0x04,
-} as const satisfies Record<string, number>;
-
-export const MANIFEST_BYTE_TO_TYPE: Record<number, string> = {
-  0x01: 'app',
-  0x02: 'capability',
-  0x03: 'dapp',
-  0x04: 'edge-service',
-};

package/src/encoding.ts

@@ -1,100 +0,0 @@
-/**
- * Wire encoding/decoding for SignedManifest.
- *
- * Format:
- *   [1 byte  MANIFEST_VERSION ]
- *   [1 byte  type discriminant]  0x01=app 0x02=capability 0x03=dapp 0x04=edge-service
- *   [4 bytes big-endian JSON length]
- *   [N bytes canonical JSON (UTF-8)]
- *   [remaining bytes = WOTS signature]
- *
- * The JSON payload is the full SignedManifest object (manifest + metadata + signature).
- * The trailing WOTS signature bytes are stored separately for easy extraction by
- * the DHT / lookup-protocol layer without needing to parse the JSON.
- */
-
-import { MANIFEST_VERSION, MANIFEST_TYPE_BYTE, MANIFEST_BYTE_TO_TYPE } from './constants.js';
-import type { SignedManifest, Manifest } from './types.js';
-
-function manifestTypeByte(type: Manifest['type']): number {
-  const byte = MANIFEST_TYPE_BYTE[type];
-  if (byte === undefined) {
-    throw new Error(`encodeManifest: unknown manifest type: ${type}`);
-  }
-  return byte;
-}
-
-export function encodeManifest(signed: SignedManifest): Uint8Array {
-  const enc = new TextEncoder();
-  const json = JSON.stringify(signed);
-  const jsonBytes = enc.encode(json);
-  const sigBytes = hexToBytes(signed.signature);
-
-  const len = jsonBytes.length;
-  const out = new Uint8Array(1 + 1 + 4 + len + sigBytes.length);
-  let offset = 0;
-
-  out[offset++] = MANIFEST_VERSION;
-  out[offset++] = manifestTypeByte(signed.manifest.type);
-  out[offset++] = (len >>> 24) & 0xff;
-  out[offset++] = (len >>> 16) & 0xff;
-  out[offset++] = (len >>> 8) & 0xff;
-  out[offset++] = len & 0xff;
-  out.set(jsonBytes, offset);
-  offset += len;
-  out.set(sigBytes, offset);
-
-  return out;
-}
-
-export function decodeManifest(bytes: Uint8Array): SignedManifest {
-  if (bytes.length < 6) {
-    throw new Error('decodeManifest: buffer too short (< 6 bytes)');
-  }
-
-  const version = bytes[0];
-  if (version !== MANIFEST_VERSION) {
-    throw new Error(`decodeManifest: unsupported MANIFEST_VERSION ${version}`);
-  }
-
-  const typeByte = bytes[1];
-  const expectedType = MANIFEST_BYTE_TO_TYPE[typeByte];
-  if (!expectedType) {
-    throw new Error(`decodeManifest: unknown type discriminant 0x${typeByte.toString(16).padStart(2, '0')}`);
-  }
-
-  const jsonLen =
-    (bytes[2] << 24) | (bytes[3] << 16) | (bytes[4] << 8) | bytes[5];
-
-  if (bytes.length < 6 + jsonLen) {
-    throw new Error(`decodeManifest: buffer too short for declared JSON length ${jsonLen}`);
-  }
-
-  const jsonBytes = bytes.slice(6, 6 + jsonLen);
-  const json = new TextDecoder().decode(jsonBytes);
-
-  let signed: SignedManifest;
-  try {
-    signed = JSON.parse(json) as SignedManifest;
-  } catch (e) {
-    throw new Error(`decodeManifest: invalid JSON payload: ${String(e)}`);
-  }
-
-  if (signed.manifest?.type !== expectedType) {
-    throw new Error(
-      `decodeManifest: type discriminant mismatch — wire says '${expectedType}' but JSON manifest.type is '${signed.manifest?.type}'`,
-    );
-  }
-
-  return signed;
-}
-
-function hexToBytes(hex: string): Uint8Array {
-  if (hex.startsWith('0x')) hex = hex.slice(2);
-  if (hex.length % 2 !== 0) throw new Error('hexToBytes: odd-length hex string');
-  const out = new Uint8Array(hex.length / 2);
-  for (let i = 0; i < out.length; i++) {
-    out[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
-  }
-  return out;
-}

package/src/guards.ts

@@ -1,48 +0,0 @@
-/**
- * Type guards for manifest kinds.
- * Each guard accepts a raw Manifest or a SignedManifest.
- */
-
-import type {
-  Manifest,
-  SignedManifest,
-  AppManifest,
-  CapabilityManifest,
-  DAppManifest,
-  EdgeServiceManifest,
-} from './types.js';
-
-type MaybeSignedOrRaw = Manifest | SignedManifest | null | undefined;
-
-function getRawManifest(input: MaybeSignedOrRaw): Manifest | null {
-  if (!input || typeof input !== 'object') return null;
-  if ('manifest' in input && input.manifest && typeof input.manifest === 'object') {
-    return (input as SignedManifest).manifest;
-  }
-  if ('type' in input) return input as Manifest;
-  return null;
-}
-
-export function isAppManifest(
-  input: MaybeSignedOrRaw,
-): input is AppManifest | SignedManifest<AppManifest> {
-  return getRawManifest(input)?.type === 'app';
-}
-
-export function isCapabilityManifest(
-  input: MaybeSignedOrRaw,
-): input is CapabilityManifest | SignedManifest<CapabilityManifest> {
-  return getRawManifest(input)?.type === 'capability';
-}
-
-export function isDAppManifest(
-  input: MaybeSignedOrRaw,
-): input is DAppManifest | SignedManifest<DAppManifest> {
-  return getRawManifest(input)?.type === 'dapp';
-}
-
-export function isEdgeServiceManifest(
-  input: MaybeSignedOrRaw,
-): input is EdgeServiceManifest | SignedManifest<EdgeServiceManifest> {
-  return getRawManifest(input)?.type === 'edge-service';
-}

package/src/id.ts

@@ -1,46 +0,0 @@
-/**
- * computeManifestId — deterministic stable ID for any manifest.
- *
- * The ID is SHA3-256 over a type-specific stable key string.
- * It must be stable across version bumps (version is NOT part of the input).
- *
- * Stable key rules:
- *   AppManifest        → "app"        + authorAddress + pearTopicKey
- *   CapabilityManifest → "capability" + agentAddress  + capabilityName
- *   DAppManifest       → "dapp"       + authorAddress + contractHash
- *   EdgeServiceManifest → "edge-service" + operatorAddress + serviceType + name
- */
-
-import { sha3_256 } from '@noble/hashes/sha3.js';
-import type { Manifest } from './types.js';
-
-function bytesToHex(b: Uint8Array): string {
-  return Array.from(b)
-    .map((x) => x.toString(16).padStart(2, '0'))
-    .join('');
-}
-
-export function computeManifestId(manifest: Manifest): string {
-  let stableKey: string;
-
-  switch (manifest.type) {
-    case 'app':
-      stableKey = `app\0${manifest.authorAddress}\0${manifest.pearTopicKey}`;
-      break;
-    case 'capability':
-      stableKey = `capability\0${manifest.agentAddress}\0${manifest.capabilityName}`;
-      break;
-    case 'dapp':
-      stableKey = `dapp\0${manifest.authorAddress}\0${manifest.contractHash}`;
-      break;
-    case 'edge-service':
-      stableKey = `edge-service\0${manifest.operatorAddress}\0${manifest.serviceType}\0${manifest.name}`;
-      break;
-    default: {
-      const _exhaustive: never = manifest;
-      throw new Error(`computeManifestId: unknown manifest type: ${JSON.stringify(_exhaustive)}`);
-    }
-  }
-
-  return bytesToHex(sha3_256(new TextEncoder().encode(stableKey)));
-}

package/src/index.ts

@@ -1,26 +0,0 @@
-export type {
-  AppManifest,
-  CapabilityManifest,
-  DAppManifest,
-  EdgeServiceManifest,
-  EdgeServiceType,
-  Manifest,
-  SignedManifest,
-  AppPermission,
-  DAppAbiEntry,
-  VerifyResult,
-} from './types.js';
-
-export { MANIFEST_VERSION } from './constants.js';
-
-export { computeManifestId } from './id.js';
-export { signManifest } from './sign.js';
-export { verifyManifest } from './verify.js';
-export { encodeManifest, decodeManifest } from './encoding.js';
-
-export {
-  isAppManifest,
-  isCapabilityManifest,
-  isDAppManifest,
-  isEdgeServiceManifest,
-} from './guards.js';