@originals/sdk 1.5.0 → 1.6.1

package/dist/vc/CredentialManager.d.ts

@@ -124,7 +124,7 @@ export declare class CredentialManager {
     private config;
     private didManager?;
     constructor(config: OriginalsConfig, didManager?: DIDManager | undefined);
-    createResourceCredential(type: 'ResourceCreated' | 'ResourceUpdated' | 'ResourceMigrated', subject: CredentialSubject, issuer: string): Promise<VerifiableCredential>;
+    createResourceCredential(type: 'ResourceCreated' | 'ResourceUpdated' | 'ResourceMigrated', subject: CredentialSubject, issuer: string): VerifiableCredential;
     signCredential(credential: VerifiableCredential, privateKeyMultibase: string, verificationMethod: string): Promise<VerifiableCredential>;
     /**
      * Sign a credential using an external signer (e.g., hardware wallet, Turnkey)
@@ -134,7 +134,7 @@ export declare class CredentialManager {
      */
     signCredentialWithExternalSigner(credential: VerifiableCredential, signer: ExternalSigner): Promise<VerifiableCredential>;
     verifyCredential(credential: VerifiableCredential): Promise<boolean>;
-    createPresentation(credentials: VerifiableCredential[], holder: string): Promise<VerifiablePresentation>;
+    createPresentation(credentials: VerifiableCredential[], holder: string): VerifiablePresentation;
     private generateProofValue;
     private getSigner;
     private resolveVerificationMethodMultibase;
@@ -159,7 +159,7 @@ export declare class CredentialManager {
      * const signed = await credentialManager.signCredential(credential, privateKey, vmId);
      * ```
      */
-    issueResourceCredential(resource: AssetResource, assetDid: string, creatorDid: string, chainOptions?: CredentialChainOptions): Promise<VerifiableCredential>;
+    issueResourceCredential(resource: AssetResource, assetDid: string, creatorDid: string, chainOptions?: CredentialChainOptions): VerifiableCredential;
     /**
      * Issue a ResourceUpdated credential for a resource version update
      *
@@ -188,7 +188,7 @@ export declare class CredentialManager {
      * );
      * ```
      */
-    issueResourceUpdateCredential(resourceId: string, assetDid: string, previousHash: string, newHash: string, fromVersion: number, toVersion: number, updaterDid: string, updateReason?: string, chainOptions?: CredentialChainOptions): Promise<VerifiableCredential>;
+    issueResourceUpdateCredential(resourceId: string, assetDid: string, previousHash: string, newHash: string, fromVersion: number, toVersion: number, updaterDid: string, updateReason?: string, chainOptions?: CredentialChainOptions): VerifiableCredential;
     /**
      * Issue a MigrationCompleted credential for layer migrations
      *
@@ -219,7 +219,7 @@ export declare class CredentialManager {
         inscriptionId?: string;
         satoshi?: string;
         migrationReason?: string;
-    }, chainOptions?: CredentialChainOptions): Promise<VerifiableCredential>;
+    }, chainOptions?: CredentialChainOptions): VerifiableCredential;
     /**
      * Issue an OwnershipTransferred credential for Bitcoin-anchored asset transfers
      *
@@ -248,7 +248,7 @@ export declare class CredentialManager {
     issueOwnershipCredential(assetDid: string, previousOwner: string, newOwner: string, transactionId: string, issuerDid: string, details?: {
         satoshi?: string;
         transferReason?: string;
-    }, chainOptions?: CredentialChainOptions): Promise<VerifiableCredential>;
+    }, chainOptions?: CredentialChainOptions): VerifiableCredential;
     /**
      * Create a credential with optional chaining to a previous credential
      *
@@ -313,7 +313,7 @@ export declare class CredentialManager {
      * @param presentationHeader - Optional presentation-specific data
      * @returns The credential with derived proof
      */
-    deriveSelectiveProof(credential: VerifiableCredential, fieldsToDisclose: string[], presentationHeader?: Uint8Array): Promise<DerivedProofResult>;
+    deriveSelectiveProof(credential: VerifiableCredential, fieldsToDisclose: string[], _presentationHeader?: Uint8Array): Promise<DerivedProofResult>;
     /**
      * Extract all field paths from a credential as JSON Pointers
      */
@@ -325,5 +325,5 @@ export declare class CredentialManager {
      * @param pointer - JSON Pointer path (e.g., /credentialSubject/name)
      * @returns The value at the pointer path, or undefined if not found
      */
-    getFieldByPointer(credential: VerifiableCredential, pointer: string): any;
+    getFieldByPointer(credential: VerifiableCredential, pointer: string): unknown;
 }

package/dist/vc/CredentialManager.js

@@ -11,7 +11,7 @@ export class CredentialManager {
         this.config = config;
         this.didManager = didManager;
     }
-    async createResourceCredential(type, subject, issuer) {
+    createResourceCredential(type, subject, issuer) {
         return {
             '@context': ['https://www.w3.org/2018/credentials/v1'],
             type: ['VerifiableCredential', type],
@@ -25,13 +25,14 @@ export class CredentialManager {
             try {
                 const loader = createDocumentLoader(this.didManager);
                 const { document } = await loader(verificationMethod);
-                if (document && document.publicKeyMultibase) {
+                const docWithKey = document;
+                if (docWithKey && docWithKey.publicKeyMultibase) {
                     const vm = {
                         id: verificationMethod,
-                        controller: typeof credential.issuer === 'string' ? credential.issuer : credential.issuer?.id,
-                        publicKeyMultibase: document.publicKeyMultibase,
+                        controller: typeof credential.issuer === 'string' ? credential.issuer : credential.issuer?.id ?? '',
+                        publicKeyMultibase: docWithKey.publicKeyMultibase,
                         secretKeyMultibase: privateKeyMultibase,
-                        type: document.type || 'Multikey'
+                        type: docWithKey.type || 'Multikey'
                     };
                     const issuer = new Issuer(this.didManager, vm);
                     const unsigned = { ...credential };
@@ -63,7 +64,7 @@ export class CredentialManager {
      * @returns Signed verifiable credential
      */
     async signCredentialWithExternalSigner(credential, signer) {
-        const verificationMethodId = await signer.getVerificationMethodId();
+        const verificationMethodId = signer.getVerificationMethodId();
         // Create proof structure
         const proofBase = {
             type: 'DataIntegrityProof',
@@ -91,11 +92,17 @@ export class CredentialManager {
     }
     async verifyCredential(credential) {
         if (this.didManager) {
-            const proofAny = credential.proof;
-            if (proofAny && (proofAny.cryptosuite || (Array.isArray(proofAny) && proofAny[0]?.cryptosuite))) {
-                const verifier = new Verifier(this.didManager);
-                const res = await verifier.verifyCredential(credential);
-                return res.verified;
+            const proofValue = credential.proof;
+            const proofWithSuite = proofValue;
+            if (proofWithSuite) {
+                const hasCryptosuite = Array.isArray(proofWithSuite)
+                    ? proofWithSuite[0]?.cryptosuite
+                    : proofWithSuite.cryptosuite;
+                if (hasCryptosuite) {
+                    const verifier = new Verifier(this.didManager);
+                    const res = await verifier.verifyCredential(credential);
+                    return res.verified;
+                }
             }
         }
         const proof = credential.proof;
@@ -124,7 +131,8 @@ export class CredentialManager {
         const digest = Buffer.concat([hProof, hCred]);
         const signer = this.getSigner();
         try {
-            const resolvedKey = proof.publicKeyMultibase
+            const proofWithKey = proof;
+            const resolvedKey = proofWithKey.publicKeyMultibase
                 || await this.resolveVerificationMethodMultibase(verificationMethod);
             if (!resolvedKey) {
                 return false;
@@ -135,7 +143,7 @@ export class CredentialManager {
             return false;
         }
     }
-    async createPresentation(credentials, holder) {
+    createPresentation(credentials, holder) {
         return {
             '@context': ['https://www.w3.org/2018/credentials/v1'],
             type: ['VerifiablePresentation'],
@@ -185,8 +193,9 @@ export class CredentialManager {
         const loader = createDocumentLoader(this.didManager);
         try {
             const { document } = await loader(verificationMethod);
-            if (document && typeof document.publicKeyMultibase === 'string') {
-                return document.publicKeyMultibase;
+            const docWithKey = document;
+            if (docWithKey && typeof docWithKey.publicKeyMultibase === 'string') {
+                return docWithKey.publicKeyMultibase;
             }
         }
         catch (err) {
@@ -201,7 +210,8 @@ export class CredentialManager {
                 return null;
             }
             const didDoc = await this.didManager.resolveDID(did);
-            const vms = didDoc?.verificationMethod;
+            const docWithVMs = didDoc;
+            const vms = docWithVMs?.verificationMethod;
             if (Array.isArray(vms)) {
                 const vm = vms.find((m) => m?.id === verificationMethod);
                 if (vm && typeof vm.publicKeyMultibase === 'string') {
@@ -246,7 +256,7 @@ export class CredentialManager {
      * const signed = await credentialManager.signCredential(credential, privateKey, vmId);
      * ```
      */
-    async issueResourceCredential(resource, assetDid, creatorDid, chainOptions) {
+    issueResourceCredential(resource, assetDid, creatorDid, chainOptions) {
         const subject = {
             id: assetDid,
             resourceId: resource.id,
@@ -256,7 +266,7 @@ export class CredentialManager {
             creator: creatorDid,
             createdAt: resource.createdAt || new Date().toISOString()
         };
-        const credential = await this.createCredentialWithChain('ResourceCreated', subject, creatorDid, chainOptions);
+        const credential = this.createCredentialWithChain('ResourceCreated', subject, creatorDid, chainOptions);
         return credential;
     }
     /**
@@ -287,7 +297,7 @@ export class CredentialManager {
      * );
      * ```
      */
-    async issueResourceUpdateCredential(resourceId, assetDid, previousHash, newHash, fromVersion, toVersion, updaterDid, updateReason, chainOptions) {
+    issueResourceUpdateCredential(resourceId, assetDid, previousHash, newHash, fromVersion, toVersion, updaterDid, updateReason, chainOptions) {
         const subject = {
             id: assetDid,
             resourceId,
@@ -298,7 +308,7 @@ export class CredentialManager {
             updatedAt: new Date().toISOString(),
             ...(updateReason && { updateReason })
         };
-        const credential = await this.createCredentialWithChain('ResourceUpdated', subject, updaterDid, chainOptions);
+        const credential = this.createCredentialWithChain('ResourceUpdated', subject, updaterDid, chainOptions);
         return credential;
     }
     /**
@@ -326,7 +336,7 @@ export class CredentialManager {
      * );
      * ```
      */
-    async issueMigrationCredential(sourceDid, targetDid, fromLayer, toLayer, issuerDid, details, chainOptions) {
+    issueMigrationCredential(sourceDid, targetDid, fromLayer, toLayer, issuerDid, details, chainOptions) {
         const subject = {
             id: targetDid || sourceDid,
             sourceDid,
@@ -339,7 +349,7 @@ export class CredentialManager {
             ...(details?.satoshi && { satoshi: details.satoshi }),
             ...(details?.migrationReason && { migrationReason: details.migrationReason })
         };
-        const credential = await this.createCredentialWithChain('MigrationCompleted', subject, issuerDid, chainOptions);
+        const credential = this.createCredentialWithChain('MigrationCompleted', subject, issuerDid, chainOptions);
         return credential;
     }
     /**
@@ -367,7 +377,7 @@ export class CredentialManager {
      * );
      * ```
      */
-    async issueOwnershipCredential(assetDid, previousOwner, newOwner, transactionId, issuerDid, details, chainOptions) {
+    issueOwnershipCredential(assetDid, previousOwner, newOwner, transactionId, issuerDid, details, chainOptions) {
         const subject = {
             id: assetDid,
             previousOwner,
@@ -377,7 +387,7 @@ export class CredentialManager {
             ...(details?.satoshi && { satoshi: details.satoshi }),
             ...(details?.transferReason && { transferReason: details.transferReason })
         };
-        const credential = await this.createCredentialWithChain('OwnershipTransferred', subject, issuerDid, chainOptions);
+        const credential = this.createCredentialWithChain('OwnershipTransferred', subject, issuerDid, chainOptions);
         return credential;
     }
     /**
@@ -392,7 +402,7 @@ export class CredentialManager {
      * @param chainOptions - Optional chaining options
      * @returns Unsigned verifiable credential with chain metadata
      */
-    async createCredentialWithChain(type, subject, issuer, chainOptions) {
+    createCredentialWithChain(type, subject, issuer, chainOptions) {
         const credential = {
             '@context': [
                 'https://www.w3.org/2018/credentials/v1',
@@ -414,7 +424,8 @@ export class CredentialManager {
         }
         // Add chaining metadata if provided
         if (chainOptions?.previousCredentialId || chainOptions?.previousCredentialHash) {
-            credential.credentialSubject.previousCredential = {
+            const subjectWithPrev = credential.credentialSubject;
+            subjectWithPrev.previousCredential = {
                 ...(chainOptions.previousCredentialId && { id: chainOptions.previousCredentialId }),
                 ...(chainOptions.previousCredentialHash && { hash: chainOptions.previousCredentialHash })
             };
@@ -472,7 +483,8 @@ export class CredentialManager {
         for (let i = 1; i < credentials.length; i++) {
             const current = credentials[i];
             const previous = credentials[i - 1];
-            const previousCredRef = current.credentialSubject?.previousCredential;
+            const currentSubject = current.credentialSubject;
+            const previousCredRef = currentSubject?.previousCredential;
             if (previousCredRef) {
                 // Verify ID link
                 if (previousCredRef.id && previousCredRef.id !== previous.id) {
@@ -530,11 +542,11 @@ export class CredentialManager {
             // Store pointers in credential for later derivation
             // In a full implementation, this would involve creating a BBS+ base proof
         };
-        return {
+        return await Promise.resolve({
             credential: enhancedCredential,
             mandatoryPointers: options.mandatoryPointers,
             selectivePointers
-        };
+        });
     }
     /**
      * Create a derived proof with selective disclosure
@@ -547,7 +559,7 @@ export class CredentialManager {
      * @param presentationHeader - Optional presentation-specific data
      * @returns The credential with derived proof
      */
-    async deriveSelectiveProof(credential, fieldsToDisclose, presentationHeader) {
+    async deriveSelectiveProof(credential, fieldsToDisclose, _presentationHeader) {
         // Validate that all disclosed fields are valid JSON pointers
         for (const field of fieldsToDisclose) {
             if (!field.startsWith('/')) {
@@ -563,14 +575,14 @@ export class CredentialManager {
         // 2. Create selective indexes from fieldsToDisclose
         // 3. Generate the derived BBS+ proof
         // For now, we return a structure showing what would be disclosed
-        return {
+        return await Promise.resolve({
             credential: {
                 ...credential,
                 // A real implementation would have a derived proof here
             },
             disclosedFields: fieldsToDisclose,
             hiddenFields
-        };
+        });
     }
     /**
      * Extract all field paths from a credential as JSON Pointers
@@ -608,7 +620,8 @@ export class CredentialManager {
             }
             // Handle escaped characters in JSON Pointer
             const unescaped = part.replace(/~1/g, '/').replace(/~0/g, '~');
-            current = current[unescaped];
+            const currentObj = current;
+            current = currentObj[unescaped];
         }
         return current;
     }

package/dist/vc/Issuer.d.ts

@@ -3,7 +3,7 @@ import { DIDManager } from '../did/DIDManager';
 export interface IssueOptions {
     proofPurpose: 'assertionMethod' | 'authentication';
     documentLoader?: (iri: string) => Promise<{
-        document: any;
+        document: unknown;
         documentUrl: string;
         contextUrl: string | null;
     }>;
@@ -15,7 +15,7 @@ export type VerificationMethodLike = {
     controller: string;
     publicKeyMultibase: string;
     secretKeyMultibase?: string;
-    type?: 'Multikey' | string;
+    type?: string;
 };
 export declare class Issuer {
     private didManager;

package/dist/vc/Issuer.js

@@ -51,7 +51,11 @@ export class Issuer {
         if (keyType !== 'Ed25519') {
             throw new Error('Only Ed25519 supported for eddsa-rdfc-2022');
         }
-        const proof = await DataIntegrityProofManager.createProof({ ...presentation, '@context': ['https://www.w3.org/ns/credentials/v2'] }, {
+        const presentationWithContext = {
+            ...presentation,
+            '@context': ['https://www.w3.org/ns/credentials/v2']
+        };
+        const proof = await DataIntegrityProofManager.createProof(presentationWithContext, {
             verificationMethod: this.verificationMethod.id,
             proofPurpose: options.proofPurpose,
             cryptosuite: 'eddsa-rdfc-2022',

package/dist/vc/Verifier.d.ts

@@ -8,9 +8,9 @@ export declare class Verifier {
     private didManager;
     constructor(didManager: DIDManager);
     verifyCredential(vc: VerifiableCredential, options?: {
-        documentLoader?: (iri: string) => Promise<any>;
+        documentLoader?: (iri: string) => Promise<unknown>;
     }): Promise<VerificationResult>;
     verifyPresentation(vp: VerifiablePresentation, options?: {
-        documentLoader?: (iri: string) => Promise<any>;
+        documentLoader?: (iri: string) => Promise<unknown>;
     }): Promise<VerificationResult>;
 }

package/dist/vc/Verifier.js

@@ -11,15 +11,18 @@ export class Verifier {
             if (!vc.proof)
                 throw new Error('Credential has no proof');
             const loader = options.documentLoader || createDocumentLoader(this.didManager);
-            const ctxs = Array.isArray(vc['@context']) ? vc['@context'] : [vc['@context']];
+            const vcContext = vc['@context'];
+            const ctxs = Array.isArray(vcContext) ? vcContext.filter((c) => typeof c === 'string') : [String(vcContext)];
             for (const c of ctxs)
                 await loader(c);
-            const proof = Array.isArray(vc.proof) ? vc.proof[0] : vc.proof;
+            const proofValue = vc.proof;
+            const proof = Array.isArray(proofValue) ? proofValue[0] : proofValue;
             const result = await DataIntegrityProofManager.verifyProof(vc, proof, { documentLoader: loader });
             return result.verified ? { verified: true, errors: [] } : { verified: false, errors: result.errors ?? ['Verification failed'] };
         }
         catch (e) {
-            return { verified: false, errors: [e?.message ?? 'Unknown error in verifyCredential'] };
+            const error = e;
+            return { verified: false, errors: [error?.message ?? 'Unknown error in verifyCredential'] };
         }
     }
     async verifyPresentation(vp, options = {}) {
@@ -29,7 +32,8 @@ export class Verifier {
             if (!vp.proof)
                 throw new Error('Presentation has no proof');
             const loader = options.documentLoader || createDocumentLoader(this.didManager);
-            const ctxs = Array.isArray(vp['@context']) ? vp['@context'] : [vp['@context']];
+            const vpContext = vp['@context'];
+            const ctxs = Array.isArray(vpContext) ? vpContext.filter((c) => typeof c === 'string') : [String(vpContext)];
             for (const c of ctxs)
                 await loader(c);
             if (vp.verifiableCredential) {
@@ -39,12 +43,14 @@ export class Verifier {
                         return res;
                 }
             }
-            const proof = Array.isArray(vp.proof) ? vp.proof[0] : vp.proof;
+            const proofValue = vp.proof;
+            const proof = Array.isArray(proofValue) ? proofValue[0] : proofValue;
             const result = await DataIntegrityProofManager.verifyProof(vp, proof, { documentLoader: loader });
             return result.verified ? { verified: true, errors: [] } : { verified: false, errors: result.errors ?? ['Verification failed'] };
         }
         catch (e) {
-            return { verified: false, errors: [e?.message ?? 'Unknown error in verifyPresentation'] };
+            const error = e;
+            return { verified: false, errors: [error?.message ?? 'Unknown error in verifyPresentation'] };
         }
     }
 }

package/dist/vc/documentLoader.d.ts

@@ -1,6 +1,6 @@
 import { DIDManager } from '../did/DIDManager';
 type LoadedDocument = {
-    document: any;
+    document: unknown;
     documentUrl: string;
     contextUrl: string | null;
 };
@@ -11,6 +11,8 @@ export declare class DocumentLoader {
     private resolveDID;
 }
 export declare const createDocumentLoader: (didManager: DIDManager) => (iri: string) => Promise<LoadedDocument>;
-export declare const verificationMethodRegistry: Map<string, any>;
-export declare function registerVerificationMethod(vm: any): void;
+export declare const verificationMethodRegistry: Map<string, Record<string, unknown>>;
+export declare function registerVerificationMethod(vm: Record<string, unknown> & {
+    id?: string;
+}): void;
 export {};

package/dist/vc/documentLoader.js

@@ -23,27 +23,28 @@ export class DocumentLoader {
         if (!didDoc) {
             throw new Error(`DID not resolved: ${did}`);
         }
+        const didDocTyped = didDoc;
         if (fragment) {
             // If a VM was registered explicitly, prefer it
             const cached = verificationMethodRegistry.get(didUrl);
             if (cached) {
                 return {
-                    document: { '@context': didDoc['@context'], ...cached },
+                    document: { '@context': didDocTyped['@context'], ...cached },
                     documentUrl: didUrl,
                     contextUrl: null
                 };
             }
-            const vms = didDoc.verificationMethod;
+            const vms = didDocTyped.verificationMethod;
             const vm = vms?.find((m) => m.id === didUrl);
             if (vm) {
                 return {
-                    document: { '@context': didDoc['@context'], ...vm },
+                    document: { '@context': didDocTyped['@context'], ...vm },
                     documentUrl: didUrl,
                     contextUrl: null
                 };
             }
             return {
-                document: { '@context': didDoc['@context'], id: didUrl },
+                document: { '@context': didDocTyped['@context'], id: didUrl },
                 documentUrl: didUrl,
                 contextUrl: null
             };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@originals/sdk",
-  "version": "1.5.0",
+  "version": "1.6.1",
   "description": "TypeScript SDK for the Originals Protocol - creating, discovering, and transferring digital assets with cryptographically verifiable provenance",
   "type": "module",
   "main": "dist/index.js",
@@ -8,6 +8,9 @@
   "files": [
     "dist"
   ],
+  "bin": {
+    "originals-cel": "./dist/cel/cli/index.js"
+  },
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",