@originals/sdk 1.1.0

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

@@ -0,0 +1,312 @@
+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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,213 @@
+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

@@ -0,0 +1,30 @@
+/* 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);
+  });
+});
+