@originals/sdk 1.4.2 → 1.4.3

package/tests/unit/lifecycle/LifecycleManager.keymanagement.test.ts

@@ -1,312 +0,0 @@
-import { expect, describe, test, beforeEach, afterEach } from 'bun:test';
-import { LifecycleManager } from '../../../src/lifecycle/LifecycleManager';
-import { DIDManager } from '../../../src/did/DIDManager';
-import { CredentialManager } from '../../../src/vc/CredentialManager';
-import { KeyManager } from '../../../src/did/KeyManager';
-import { MockKeyStore } from '../../mocks/MockKeyStore';
-import { OriginalsConfig } from '../../../src/types';
-import * as fs from 'fs';
-import * as path from 'path';
-import { tmpdir } from 'os';
-
-const resources = [
-  {
-    id: 'res1',
-    type: 'text',
-    content: 'hello world',
-    contentType: 'text/plain',
-    hash: 'deadbeef'
-  }
-];
-
-const config: OriginalsConfig = {
-  network: 'regtest',
-  defaultKeyType: 'Ed25519', // Use Ed25519 for did:webvh compatibility
-  enableLogging: true
-};
-
-describe('LifecycleManager Key Management', () => {
-  let lifecycleManager: LifecycleManager;
-  let didManager: DIDManager;
-  let credentialManager: CredentialManager;
-  let keyStore: MockKeyStore;
-  let publisherDid: string;
-  let tempDir: string;
-  let publisherKeyPair: any;
-
-  beforeEach(async () => {
-    didManager = new DIDManager(config);
-    credentialManager = new CredentialManager(config, didManager);
-    keyStore = new MockKeyStore();
-    lifecycleManager = new LifecycleManager(config, didManager, credentialManager, undefined, keyStore);
-    
-    // Create a simple mock publisher DID instead of creating a full did:webvh
-    // This avoids the overhead of DID creation for every test
-    publisherDid = 'did:webvh:example.com:user';
-    
-    // Create a key pair for the publisher
-    const keyManager = new KeyManager();
-    publisherKeyPair = await keyManager.generateKeyPair('Ed25519');
-    
-    // Register the publisher's key in keyStore with common VM ID pattern
-    await keyStore.setPrivateKey(`${publisherDid}#key-0`, publisherKeyPair.privateKey);
-  });
-
-  afterEach(async () => {
-    // Clean up temp directory
-    if (tempDir) {
-      try {
-        await fs.promises.rm(tempDir, { recursive: true, force: true });
-      } catch (err) {
-        // Ignore cleanup errors
-      }
-    }
-  });
-
-  describe('registerKey', () => {
-    test('should register a valid private key', async () => {
-      const keyManager = new KeyManager();
-      const keyPair = await keyManager.generateKeyPair('ES256K');
-      const vmId = 'did:peer:test#keys-1';
-
-      await lifecycleManager.registerKey(vmId, keyPair.privateKey);
-
-      const retrievedKey = await keyStore.getPrivateKey(vmId);
-      expect(retrievedKey).toBe(keyPair.privateKey);
-    });
-
-    test('should throw error when keyStore not configured', async () => {
-      const lifecycleWithoutKeyStore = new LifecycleManager(config, didManager, credentialManager);
-      const keyManager = new KeyManager();
-      const keyPair = await keyManager.generateKeyPair('ES256K');
-
-      await expect(
-        lifecycleWithoutKeyStore.registerKey('did:peer:test#keys-1', keyPair.privateKey)
-      ).rejects.toThrow('KeyStore not configured');
-    });
-
-    test('should throw error for invalid verification method ID', async () => {
-      const keyManager = new KeyManager();
-      const keyPair = await keyManager.generateKeyPair('ES256K');
-
-      await expect(
-        lifecycleManager.registerKey('', keyPair.privateKey)
-      ).rejects.toThrow('Invalid verificationMethodId');
-    });
-
-    test('should throw error for invalid private key format', async () => {
-      await expect(
-        lifecycleManager.registerKey('did:peer:test#keys-1', 'invalid-key')
-      ).rejects.toThrow('Invalid privateKey format');
-    });
-
-    test('should throw error for empty private key', async () => {
-      await expect(
-        lifecycleManager.registerKey('did:peer:test#keys-1', '')
-      ).rejects.toThrow('Invalid privateKey');
-    });
-  });
-
-  describe('createAsset with keyStore', () => {
-    test('should automatically register key when keyStore is provided', async () => {
-      const asset = await lifecycleManager.createAsset(resources);
-
-      expect(asset.currentLayer).toBe('did:peer');
-      expect(asset.did.verificationMethod).toBeDefined();
-      expect(asset.did.verificationMethod!.length).toBeGreaterThan(0);
-
-      let vmId = asset.did.verificationMethod![0].id;
-      // Ensure VM ID is absolute
-      if (vmId.startsWith('#')) {
-        vmId = `${asset.did.id}${vmId}`;
-      }
-      
-      const privateKey = await keyStore.getPrivateKey(vmId);
-      expect(privateKey).not.toBeNull();
-      expect(typeof privateKey).toBe('string');
-    });
-
-    test('should create asset without keyStore gracefully', async () => {
-      const lifecycleWithoutKeyStore = new LifecycleManager(config, didManager, credentialManager);
-      const asset = await lifecycleWithoutKeyStore.createAsset(resources);
-
-      expect(asset.currentLayer).toBe('did:peer');
-      expect(asset.did.verificationMethod).toBeDefined();
-    });
-  });
-
-  describe('publishToWeb with DID keys', () => {
-    test('should sign credential with DID document key from keyStore', async () => {
-      const asset = await lifecycleManager.createAsset(resources);
-      
-      // Verify key was stored
-      let vmId = asset.did.verificationMethod![0].id;
-      if (vmId.startsWith('#')) {
-        vmId = `${asset.did.id}${vmId}`;
-      }
-      const storedKey = await keyStore.getPrivateKey(vmId);
-      expect(storedKey).not.toBeNull();
-      
-      const published = await lifecycleManager.publishToWeb(asset, publisherDid);
-
-      expect(published.currentLayer).toBe('did:webvh');
-      expect(published.credentials.length).toBeGreaterThan(0);
-
-      const credential = published.credentials[0];
-      expect(credential.proof).toBeDefined();
-      expect(credential.type).toContain('ResourceMigrated');
-      expect(credential.issuer).toBe(publisherDid); // Publisher DID is the issuer
-      
-      const proof = credential.proof as any;
-      // Verification method should be from the publisher DID, not the asset
-      expect(proof.verificationMethod).toContain(publisherDid);
-    });
-
-    test('should not add credential when keyStore not provided', async () => {
-      const lifecycleWithoutKeyStore = new LifecycleManager(config, didManager, credentialManager);
-      const asset = await lifecycleWithoutKeyStore.createAsset(resources);
-
-      // Publishing should succeed but no credential should be added (best-effort)
-      const published = await lifecycleWithoutKeyStore.publishToWeb(asset, publisherDid);
-      
-      expect(published.currentLayer).toBe('did:webvh');
-      // No credential should be added due to missing keyStore
-      expect(published.credentials.length).toBe(0);
-    });
-
-    test('should not add credential when private key not found in keyStore', async () => {
-      // Create asset without keyStore
-      const lifecycleWithoutKeyStore = new LifecycleManager(config, didManager, credentialManager);
-      const asset = await lifecycleWithoutKeyStore.createAsset(resources);
-
-      // Try to publish with a different lifecycle manager that has keyStore but no keys
-      const emptyKeyStore = new MockKeyStore();
-      const lifecycleWithEmptyKeyStore = new LifecycleManager(
-        config,
-        didManager,
-        credentialManager,
-        undefined,
-        emptyKeyStore
-      );
-
-      // Publishing should succeed but no credential should be added (best-effort)
-      const published = await lifecycleWithEmptyKeyStore.publishToWeb(asset, publisherDid);
-      
-      expect(published.currentLayer).toBe('did:webvh');
-      // No credential should be added due to missing private key
-      expect(published.credentials.length).toBe(0);
-    });
-
-    test('should use keys from keyStore not ephemeral keys', async () => {
-      const asset = await lifecycleManager.createAsset(resources);
-      
-      // Get the stored key
-      let vmId = asset.did.verificationMethod![0].id;
-      if (vmId.startsWith('#')) {
-        vmId = `${asset.did.id}${vmId}`;
-      }
-      const storedKeyBefore = await keyStore.getPrivateKey(vmId);
-      
-      const published = await lifecycleManager.publishToWeb(asset, publisherDid);
-      
-      // Verify the same key is still there (not replaced)
-      const storedKeyAfter = await keyStore.getPrivateKey(vmId);
-      expect(storedKeyAfter).toBe(storedKeyBefore);
-      
-      // Verify credential was created
-      expect(published.credentials.length).toBe(1);
-      const credential = published.credentials[0];
-      const proof = credential.proof as any;
-      // Verification method should be from the publisher DID
-      expect(proof.verificationMethod).toContain(publisherDid);
-    });
-
-    test('should use correct verification method from DID document', async () => {
-      const asset = await lifecycleManager.createAsset(resources);
-      let vmId = asset.did.verificationMethod![0].id;
-      const publicKey = asset.did.verificationMethod![0].publicKeyMultibase;
-
-      // Ensure VM ID is absolute
-      if (vmId.startsWith('#')) {
-        vmId = `${asset.did.id}${vmId}`;
-      }
-
-      const published = await lifecycleManager.publishToWeb(asset, publisherDid);
-      const credential = published.credentials[0];
-      const proof = credential.proof as any;
-
-      // Verify the VM ID references the publisher DID document
-      expect(proof.verificationMethod).toContain(publisherDid);
-      expect(vmId).toContain(asset.id); // Asset's VM ID contains asset ID
-      expect(credential.issuer).toBe(publisherDid); // Publisher is the issuer
-    });
-  });
-
-  describe('Key rotation scenario', () => {
-    test('should allow registering multiple keys for different verification methods', async () => {
-      const keyManager = new KeyManager();
-      const keyPair1 = await keyManager.generateKeyPair('ES256K');
-      const keyPair2 = await keyManager.generateKeyPair('ES256K');
-
-      await lifecycleManager.registerKey('did:peer:test#keys-1', keyPair1.privateKey);
-      await lifecycleManager.registerKey('did:peer:test#keys-2', keyPair2.privateKey);
-
-      const key1 = await keyStore.getPrivateKey('did:peer:test#keys-1');
-      const key2 = await keyStore.getPrivateKey('did:peer:test#keys-2');
-
-      expect(key1).toBe(keyPair1.privateKey);
-      expect(key2).toBe(keyPair2.privateKey);
-      expect(key1).not.toBe(key2);
-    });
-  });
-
-  describe('End-to-end credential management', () => {
-    test('should create signed credentials throughout asset lifecycle', async () => {
-      // Create asset with automatic key registration
-      const asset = await lifecycleManager.createAsset(resources);
-      expect(asset.did.verificationMethod).toBeDefined();
-
-      // Publish to web - should create signed credential
-      const published = await lifecycleManager.publishToWeb(asset, publisherDid);
-      expect(published.credentials.length).toBe(1);
-
-      // Check credential structure
-      const credential = published.credentials[0];
-      expect(credential.issuer).toBe(publisherDid); // Publisher is the issuer
-      expect(credential.type).toContain('ResourceMigrated');
-      expect((credential.credentialSubject as any).fromLayer).toBe('did:peer');
-      expect((credential.credentialSubject as any).toLayer).toBe('did:webvh');
-      
-      // Verify proof is present with publisher's VM
-      expect(credential.proof).toBeDefined();
-      const proof = credential.proof as any;
-      // Verification method should be from publisher DID
-      expect(proof.verificationMethod).toContain(publisherDid);
-    });
-  });
-
-  describe('Error handling', () => {
-    test('should handle missing verification method in DID document gracefully', async () => {
-      const lifecycleWithoutKeyStore = new LifecycleManager(config, didManager, credentialManager);
-      const asset = await lifecycleWithoutKeyStore.createAsset(resources);
-      
-      // Manually remove verification methods to simulate error case
-      (asset.did as any).verificationMethod = [];
-
-      const lifecycleWithKeyStore = new LifecycleManager(
-        config,
-        didManager,
-        credentialManager,
-        undefined,
-        keyStore
-      );
-
-      // Should not throw - credentials can be issued using publisher's keys from keyStore
-      const published = await lifecycleWithKeyStore.publishToWeb(asset, publisherDid);
-      
-      expect(published.currentLayer).toBe('did:webvh');
-      // Credential should be added using publisher's verification method from keyStore
-      expect(published.credentials.length).toBeGreaterThanOrEqual(0); // Best effort - may or may not issue
-    });
-  });
-});

package/tests/unit/lifecycle/LifecycleManager.prov.test.ts

@@ -1,18 +0,0 @@
-import { describe, test, expect } from 'bun:test';
-import { OriginalsSDK } from '../../../src';
-import { MockOrdinalsProvider } from '../../mocks/adapters';
-
-describe('LifecycleManager provenance fallback', () => {
-  test('inscribeOnBitcoin initializes provenance when missing', async () => {
-    const provider = new MockOrdinalsProvider();
-    const sdk = OriginalsSDK.create({ network: 'regtest', ordinalsProvider: provider } as any);
-    const asset = await sdk.lifecycle.createAsset([{ id: 'r', type: 'text', contentType: 'text/plain', hash: 'aa' }]);
-    // ensure provenance exists but is empty (migrations/transfers arrays present)
-    (asset as any).provenance = { createdAt: new Date().toISOString(), creator: asset.id, migrations: [], transfers: [] };
-    const updated = await sdk.lifecycle.inscribeOnBitcoin(asset);
-    const prov = (updated as any).getProvenance();
-    const latest = prov.migrations[prov.migrations.length - 1];
-    expect(latest.transactionId).toBeDefined();
-    expect(latest.feeRate as number).toBeGreaterThan(0);
-  });
-});

package/tests/unit/lifecycle/LifecycleManager.test.ts

@@ -1,213 +0,0 @@
-import { describe, test, expect } from 'bun:test';
-import { OriginalsSDK, OriginalsAsset } from '../../../src';
-import { MockOrdinalsProvider } from '../../mocks/adapters';
-
-const resources = [
-  {
-    id: 'res1',
-    type: 'text',
-    content: 'hello world',
-    contentType: 'text/plain',
-    hash: 'deadbeef'
-  }
-];
-
-describe('LifecycleManager', () => {
-  test('createAsset creates a peer-layer asset', async () => {
-    const sdk = OriginalsSDK.create({ network: 'regtest' });
-    const asset = await sdk.lifecycle.createAsset(resources);
-    expect(asset.currentLayer).toBe('did:peer');
-    expect(asset.id.startsWith('did:peer:')).toBe(true);
-  });
-
-  test('publishToWeb migrates and records binding', async () => {
-    const sdk = OriginalsSDK.create({ network: 'regtest' });
-    const asset = await sdk.lifecycle.createAsset(resources);
-    const published = await sdk.lifecycle.publishToWeb(asset, 'example.com');
-    expect(published.currentLayer).toBe('did:webvh');
-    expect(published.bindings?.['did:webvh']).toContain('example.com');
-  });
-
-  test('inscribeOnBitcoin uses provider details for provenance', async () => {
-    const provider = new MockOrdinalsProvider();
-    const sdk = OriginalsSDK.create({ network: 'regtest', ordinalsProvider: provider } as any);
-    const asset = await sdk.lifecycle.createAsset(resources);
-    await sdk.lifecycle.publishToWeb(asset, 'example.com');
-    const btco = await sdk.lifecycle.inscribeOnBitcoin(asset, 9);
-    expect(btco.currentLayer).toBe('did:btco');
-    const provenance = btco.getProvenance();
-    const latest = provenance.migrations[provenance.migrations.length - 1];
-    expect(latest.inscriptionId).toBe('insc-mock');
-    expect(latest.satoshi).toBe('123');
-    expect(latest.transactionId).toBe('tx-reveal-mock');
-    expect(latest.feeRate).toBe(9);
-    expect(btco.bindings?.['did:btco']).toBe('did:btco:123');
-  });
-
-  test('inscribeOnBitcoin without provider throws error', async () => {
-    const sdk = OriginalsSDK.create({ network: 'regtest' });
-    const asset = await sdk.lifecycle.createAsset(resources);
-    await expect(sdk.lifecycle.inscribeOnBitcoin(asset, 5)).rejects.toThrow('Ordinals provider must be configured');
-  });
-
-  test('inscribeOnBitcoin enforces migration guard', async () => {
-    const sdk = OriginalsSDK.create({ network: 'regtest' });
-    const fakeAsset = { currentLayer: 'did:webvh', migrate: undefined } as unknown as OriginalsAsset;
-    await expect(sdk.lifecycle.inscribeOnBitcoin(fakeAsset, 5)).rejects.toThrow('Not implemented');
-  });
-
-  test('publishToWeb throws Not implemented (coverage for throw)', async () => {
-    const sdk = OriginalsSDK.create({ network: 'regtest' });
-    const fakeAsset: any = { currentLayer: 'did:peer' };
-    await expect(
-      sdk.lifecycle.publishToWeb(fakeAsset, 'example.com')
-    ).rejects.toThrow();
-  });
-
-  test('inscribeOnBitcoin throws Not implemented (coverage for throw)', async () => {
-    const sdk = OriginalsSDK.create({ network: 'regtest' });
-    const fakeAsset: any = { currentLayer: 'did:webvh' };
-    await expect(
-      sdk.lifecycle.inscribeOnBitcoin(fakeAsset, 10)
-    ).rejects.toThrow('Not implemented');
-  });
-
-  test('transferOwnership succeeds when on btco (returns tx)', async () => {
-    const provider = new MockOrdinalsProvider();
-    const sdk = OriginalsSDK.create({ network: 'regtest', ordinalsProvider: provider } as any);
-    const asset = await sdk.lifecycle.createAsset([
-      { id: 'r', type: 'text', contentType: 'text/plain', hash: 'aa' }
-    ]);
-    await asset.migrate('did:btco');
-    const tx = await sdk.lifecycle.transferOwnership(asset as any, 'tb1qw508d6qejxtdg4y5r3zarvary0c5xw7kxpjzsx');
-    expect(typeof tx.txid).toBe('string');
-  });
-
-  test('transferOwnership errors if not on btco layer', async () => {
-    const sdk = OriginalsSDK.create({ network: 'regtest' });
-    // This one should pass given current guard
-    const asset = await (async () => {
-      try {
-        return await sdk.lifecycle.createAsset(resources);
-      } catch (e) {
-        // Fallback mock minimal object to hit the guard branch
-        return { currentLayer: 'did:webvh' } as any;
-      }
-    })();
-    await expect(
-      sdk.lifecycle.transferOwnership(asset as any, 'tb1qw508d6qejxtdg4y5r3zarvary0c5xw7kxpjzsx')
-    ).rejects.toThrow('Asset must be inscribed on Bitcoin before transfer');
-  });
-});
-
-/** Inlined from LifecycleManager.btco.psbt.part.ts */
-import { BroadcastClient } from '../../../src/bitcoin/BroadcastClient';
-import { PSBTBuilder } from '../../../src/bitcoin/PSBTBuilder';
-
-describe('Bitcoin inscription MVP - dry run', () => {
-  test('dry-run using mocked provider and broadcaster', async () => {
-    const provider = new MockOrdinalsProvider();
-    const sdk = OriginalsSDK.create({ network: 'regtest', bitcoinRpcUrl: 'http://ord', ordinalsProvider: provider } as any);
-
-    // Inject mocked dependencies
-    const mockBroadcast = new BroadcastClient(async (_hex) => 'tx-dryrun', async (_txid) => ({ confirmed: true, confirmations: 1 }));
-    const mockPsbt = new PSBTBuilder();
-
-    // @ts-ignore access internals for test injection
-    sdk.lifecycle = new (sdk.lifecycle.constructor as any)(
-      (sdk as any).lifecycle['config'],
-      (sdk as any).lifecycle['didManager'],
-      (sdk as any).lifecycle['credentialManager'],
-      { broadcastClient: mockBroadcast, psbtBuilder: mockPsbt }
-    );
-
-    const asset = await sdk.lifecycle.createAsset([
-      { id: 'r1', type: 'text', contentType: 'text/plain', hash: 'aa' }
-    ]);
-
-    const before = asset.currentLayer;
-    const feeRate = 7;
-    const result = await sdk.lifecycle.inscribeOnBitcoin(asset, feeRate);
-
-    expect(result.currentLayer).toBe('did:btco');
-    const prov = (result as any).getProvenance();
-    const latest = prov.migrations[prov.migrations.length - 1];
-    expect(latest.feeRate).toBe(feeRate);
-    expect(latest.transactionId).toEqual(expect.any(String));
-    expect(before).toBe('did:peer');
-  });
-});
-
-
-
-
-/** Inlined from LifecycleManager.coverage-branches.part.ts */
-import { LifecycleManager } from '../../../src/lifecycle/LifecycleManager';
-import { DIDManager } from '../../../src/did/DIDManager';
-import { CredentialManager } from '../../../src/vc/CredentialManager';
-
-describe('LifecycleManager additional branch coverage', () => {
-  const lm = new LifecycleManager({ network: 'mainnet' } as any, new DIDManager({} as any), new CredentialManager({} as any));
-
-  test('publishToWeb throws when migrate not a function', async () => {
-    const asset: any = { 
-      currentLayer: 'did:peer',
-      id: 'did:peer:test',
-      resources: [{ id: 'r1', type: 'data', contentType: 'text/plain', hash: 'deadbeef', content: 'test' }],
-      migrate: undefined  // This should cause an error when called
-    };
-    await expect(lm.publishToWeb(asset, 'example.com')).rejects.toThrow();
-  });
-});
-
-
-
-
-/** Inlined from LifecycleManager.more.part.ts */
-
-const dummyConfig: any = {};
-const didManager = new DIDManager(dummyConfig as any);
-const credentialManager = new CredentialManager(dummyConfig as any);
-const lm = new LifecycleManager(dummyConfig as any, didManager, credentialManager);
-
-describe('LifecycleManager additional branches', () => {
-  test('publishToWeb throws when currentLayer is not did:peer', async () => {
-    const asset: any = { currentLayer: 'did:webvh', migrate: async () => { } };
-    await expect(lm.publishToWeb(asset, 'example.com')).rejects.toThrow();
-  });
-
-  test('inscribeOnBitcoin throws for invalid layer', async () => {
-    const asset: any = { currentLayer: 'did:wrong', migrate: async () => { } };
-    await expect(lm.inscribeOnBitcoin(asset)).rejects.toThrow('Not implemented');
-  });
-});
-
-
-
-
-/** Inlined from LifecycleManager.no-feeRate.part.ts */
-
-describe('LifecycleManager.inscribeOnBitcoin without explicit feeRate', () => {
-  test('uses provider.estimateFee when feeRate not provided', async () => {
-    const provider = new MockOrdinalsProvider();
-    const sdk = OriginalsSDK.create({ network: 'regtest', bitcoinRpcUrl: 'http://ord', ordinalsProvider: provider } as any);
-    const asset = await sdk.lifecycle.createAsset([{ id: 'r', type: 'text', contentType: 'text/plain', hash: 'aa' }]);
-    const result = await sdk.lifecycle.inscribeOnBitcoin(asset);
-    expect(result.currentLayer).toBe('did:btco');
-    const prov = (result as any).getProvenance();
-    const latest = prov.migrations[prov.migrations.length - 1];
-    expect(latest.feeRate as number).toBeGreaterThan(0);
-  })
-
-  test('transferOwnership uses provenance inscription data', async () => {
-    const provider = new MockOrdinalsProvider();
-    const sdk = OriginalsSDK.create({ network: 'regtest', ordinalsProvider: provider } as any);
-    const asset = await sdk.lifecycle.createAsset(resources);
-    await sdk.lifecycle.publishToWeb(asset, 'example.com');
-    await sdk.lifecycle.inscribeOnBitcoin(asset, 8);
-    const tx = await sdk.lifecycle.transferOwnership(asset, 'tb1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3q0sl5k7');
-    expect(tx.txid).toBe('tx-transfer-mock');
-    const provenance = asset.getProvenance();
-    expect(provenance.transfers[provenance.transfers.length - 1].transactionId).toBe('tx-transfer-mock');
-  });
-});

package/tests/unit/lifecycle/LifecycleManager.transfer.unit.test.ts

@@ -1,30 +0,0 @@
-/* istanbul ignore file */
-import { describe, test, expect } from 'bun:test';
-import { OriginalsSDK, OriginalsAsset } from '../../../src';
-import { MockOrdinalsProvider } from '../../mocks/adapters';
-
-describe('LifecycleManager.transferOwnership unit edge cases', () => {
-  const provider = new MockOrdinalsProvider();
-  const sdk = OriginalsSDK.create({ network: 'regtest', ordinalsProvider: provider } as any);
-
-  test('throws if not on btco layer', async () => {
-    const asset = new OriginalsAsset(
-      [{ id: 'r', type: 'text', contentType: 'text/plain', hash: 'h' }],
-      { '@context': ['https://www.w3.org/ns/did/v1'], id: 'did:webvh:domain:1' } as any,
-      []
-    );
-    await expect(sdk.lifecycle.transferOwnership(asset as any, 'tb1qw508d6qejxtdg4y5r3zarvary0c5xw7kxpjzsx')).rejects.toThrow('Asset must be inscribed on Bitcoin before transfer');
-  });
-
-  test('succeeds and updates provenance when on btco', async () => {
-    const asset = new OriginalsAsset(
-      [{ id: 'r', type: 'text', contentType: 'text/plain', hash: 'h' }],
-      { '@context': ['https://www.w3.org/ns/did/v1'], id: 'did:btco:42' } as any,
-      []
-    );
-    const tx = await sdk.lifecycle.transferOwnership(asset, 'tb1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3q0sl5k7');
-    expect(typeof tx.txid).toBe('string');
-    expect(asset.getProvenance().transfers.length).toBe(1);
-  });
-});
-