@originals/sdk 1.2.0 → 1.4.3

package/dist/vc/cryptosuites/eddsa.d.ts

@@ -1,30 +0,0 @@
-export interface DataIntegrityProof {
-    type: 'DataIntegrityProof';
-    cryptosuite: string;
-    created?: string;
-    verificationMethod: string;
-    proofPurpose: string;
-    proofValue: string;
-    id?: string;
-    previousProof?: string | string[];
-}
-export interface VerificationResult {
-    verified: boolean;
-    errors?: string[];
-}
-export declare class EdDSACryptosuiteManager {
-    static createProof(document: any, options: any): Promise<DataIntegrityProof>;
-    static verifyProof(document: any, proof: DataIntegrityProof, options: any): Promise<VerificationResult>;
-    private static createProofConfiguration;
-    private static transform;
-    private static hash;
-    static sign({ data, privateKey }: {
-        data: Uint8Array;
-        privateKey: Uint8Array;
-    }): Promise<Uint8Array>;
-    static verify({ data, signature, publicKey }: {
-        data: Uint8Array;
-        signature: Uint8Array;
-        publicKey: Uint8Array;
-    }): Promise<boolean>;
-}

package/dist/vc/cryptosuites/eddsa.js

@@ -1,81 +0,0 @@
-import { base58 } from '@scure/base';
-import * as ed25519 from '@noble/ed25519';
-import { canonize, canonizeProof } from '../utils/jsonld';
-import { multikey } from '../../crypto/Multikey';
-import { sha256Bytes } from '../../utils/hash';
-export class EdDSACryptosuiteManager {
-    static async createProof(document, options) {
-        const proofConfig = await this.createProofConfiguration(options);
-        const transformedData = await this.transform(document, options);
-        const hashData = await this.hash(transformedData, proofConfig, options);
-        let privateKey;
-        if (typeof options.privateKey === 'string') {
-            const dec = multikey.decodePrivateKey(options.privateKey);
-            if (dec.type !== 'Ed25519')
-                throw new Error('Invalid key type for EdDSA');
-            privateKey = dec.key;
-        }
-        else if (options.privateKey instanceof Uint8Array) {
-            privateKey = options.privateKey;
-        }
-        else {
-            throw new Error('Invalid private key format');
-        }
-        const proofValueBytes = await this.sign({ data: hashData, privateKey });
-        delete proofConfig['@context'];
-        return { ...proofConfig, proofValue: base58.encode(proofValueBytes) };
-    }
-    static async verifyProof(document, proof, options) {
-        try {
-            const documentToVerify = { ...document };
-            delete documentToVerify.proof;
-            const transformedData = await this.transform(documentToVerify, options);
-            const hashData = await this.hash(transformedData, { '@context': document['@context'], ...proof }, options);
-            const vmDoc = await options.documentLoader(proof.verificationMethod);
-            const pk = vmDoc.document.publicKeyMultibase;
-            const dec = multikey.decodePublicKey(pk);
-            if (dec.type !== 'Ed25519')
-                throw new Error('Invalid key type for EdDSA');
-            const signature = base58.decode(proof.proofValue);
-            const verified = await this.verify({ data: hashData, signature, publicKey: dec.key });
-            return verified ? { verified: true } : { verified: false, errors: ['Proof verification failed'] };
-        }
-        catch (e) {
-            return { verified: false, errors: [e?.message ?? 'Unknown verification error'] };
-        }
-    }
-    static async createProofConfiguration(options) {
-        return {
-            '@context': 'https://w3id.org/security/data-integrity/v2',
-            type: 'DataIntegrityProof',
-            cryptosuite: 'eddsa-rdfc-2022',
-            created: new Date().toISOString(),
-            verificationMethod: options.verificationMethod,
-            proofPurpose: options.proofPurpose || 'assertionMethod',
-            ...(options.challenge && { challenge: options.challenge }),
-            ...(options.domain && { domain: options.domain })
-        };
-    }
-    static async transform(document, options) {
-        return await canonize(document, { documentLoader: options.documentLoader });
-    }
-    static async hash(transformedData, proofConfig, options) {
-        const canonicalProofConfig = await canonizeProof(proofConfig, { documentLoader: options.documentLoader });
-        const proofConfigHash = await sha256Bytes(canonicalProofConfig);
-        const documentHash = await sha256Bytes(transformedData);
-        return new Uint8Array([...proofConfigHash, ...documentHash]);
-    }
-    static async sign({ data, privateKey }) {
-        if (privateKey.length !== 32) {
-            if (privateKey.length === 64)
-                privateKey = privateKey.slice(32);
-            else
-                throw new Error('Invalid private key length');
-        }
-        const signature = await ed25519.signAsync(Buffer.from(data).toString('hex'), Buffer.from(privateKey).toString('hex'));
-        return signature;
-    }
-    static async verify({ data, signature, publicKey }) {
-        return await ed25519.verifyAsync(Buffer.from(signature).toString('hex'), Buffer.from(data).toString('hex'), Buffer.from(publicKey).toString('hex'));
-    }
-}

package/dist/vc/documentLoader.d.ts

@@ -1,16 +0,0 @@
-import { DIDManager } from '../did/DIDManager';
-type LoadedDocument = {
-    document: any;
-    documentUrl: string;
-    contextUrl: string | null;
-};
-export declare class DocumentLoader {
-    private didManager;
-    constructor(didManager: DIDManager);
-    load(iri: string): Promise<LoadedDocument>;
-    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 {};

package/dist/vc/documentLoader.js

@@ -1,59 +0,0 @@
-const CONTEXTS = {
-    // Provide 1.1-compatible stubs for jsonld canonize
-    'https://www.w3.org/ns/credentials/v2': { '@context': { '@version': 1.1 } },
-    'https://w3id.org/security/data-integrity/v2': { '@context': { '@version': 1.1 } }
-};
-export class DocumentLoader {
-    constructor(didManager) {
-        this.didManager = didManager;
-    }
-    async load(iri) {
-        if (iri.startsWith('did:')) {
-            return this.resolveDID(iri);
-        }
-        const doc = CONTEXTS[iri];
-        if (doc) {
-            return { document: doc, documentUrl: iri, contextUrl: null };
-        }
-        throw new Error(`Document not found: ${iri}`);
-    }
-    async resolveDID(didUrl) {
-        const [did, fragment] = didUrl.split('#');
-        const didDoc = await this.didManager.resolveDID(did);
-        if (!didDoc) {
-            throw new Error(`DID not resolved: ${did}`);
-        }
-        if (fragment) {
-            // If a VM was registered explicitly, prefer it
-            const cached = verificationMethodRegistry.get(didUrl);
-            if (cached) {
-                return {
-                    document: { '@context': didDoc['@context'], ...cached },
-                    documentUrl: didUrl,
-                    contextUrl: null
-                };
-            }
-            const vms = didDoc.verificationMethod;
-            const vm = vms?.find((m) => m.id === didUrl);
-            if (vm) {
-                return {
-                    document: { '@context': didDoc['@context'], ...vm },
-                    documentUrl: didUrl,
-                    contextUrl: null
-                };
-            }
-            return {
-                document: { '@context': didDoc['@context'], id: didUrl },
-                documentUrl: didUrl,
-                contextUrl: null
-            };
-        }
-        return { document: didDoc, documentUrl: didUrl, contextUrl: null };
-    }
-}
-export const createDocumentLoader = (didManager) => (iri) => new DocumentLoader(didManager).load(iri);
-export const verificationMethodRegistry = new Map();
-export function registerVerificationMethod(vm) {
-    if (vm?.id)
-        verificationMethodRegistry.set(vm.id, vm);
-}

package/dist/vc/proofs/data-integrity.d.ts

@@ -1,21 +0,0 @@
-import { type DataIntegrityProof } from '../cryptosuites/eddsa';
-export interface VerificationResult {
-    verified: boolean;
-    errors?: string[];
-}
-export interface ProofOptions {
-    verificationMethod: string;
-    proofPurpose: string;
-    privateKey?: Uint8Array | string;
-    type: 'DataIntegrityProof';
-    created?: string;
-    cryptosuite: string;
-    documentLoader?: (url: string) => Promise<any>;
-    previousProof?: string | string[];
-    challenge?: string;
-    domain?: string;
-}
-export declare class DataIntegrityProofManager {
-    static createProof(document: any, options: ProofOptions): Promise<DataIntegrityProof>;
-    static verifyProof(document: any, proof: DataIntegrityProof, options: any): Promise<VerificationResult>;
-}

package/dist/vc/proofs/data-integrity.js

@@ -1,15 +0,0 @@
-import { EdDSACryptosuiteManager } from '../cryptosuites/eddsa';
-export class DataIntegrityProofManager {
-    static async createProof(document, options) {
-        if (options.cryptosuite !== 'eddsa-rdfc-2022') {
-            throw new Error(`Unsupported cryptosuite: ${options.cryptosuite}`);
-        }
-        return await EdDSACryptosuiteManager.createProof(document, options);
-    }
-    static async verifyProof(document, proof, options) {
-        if (proof.cryptosuite !== 'eddsa-rdfc-2022') {
-            return { verified: false, errors: [`Unsupported cryptosuite: ${proof.cryptosuite}`] };
-        }
-        return await EdDSACryptosuiteManager.verifyProof(document, proof, options);
-    }
-}

package/dist/vc/utils/jsonld.d.ts

@@ -1,2 +0,0 @@
-export declare function canonize(input: any, { documentLoader }: any): Promise<string>;
-export declare function canonizeProof(proof: any, { documentLoader }: any): Promise<string>;

package/dist/vc/utils/jsonld.js

@@ -1,15 +0,0 @@
-import jsonld from 'jsonld';
-export async function canonize(input, { documentLoader }) {
-    return await jsonld.canonize(input, {
-        algorithm: 'URDNA2015',
-        format: 'application/n-quads',
-        documentLoader,
-        safe: false,
-        useNative: false,
-        rdfDirection: 'i18n-datatype'
-    });
-}
-export async function canonizeProof(proof, { documentLoader }) {
-    const { jws, signatureValue, proofValue, ...rest } = proof;
-    return await canonize(rest, { documentLoader });
-}

package/src/adapters/FeeOracleMock.ts

@@ -1,9 +0,0 @@
-import { FeeOracleAdapter } from './types';
-
-export class FeeOracleMock implements FeeOracleAdapter {
-  constructor(private feeRate = 7) {}
-  async estimateFeeRate(targetBlocks = 1): Promise<number> {
-    return Math.max(1, this.feeRate - (targetBlocks - 1));
-  }
-}
-

package/src/adapters/index.ts

@@ -1,5 +0,0 @@
-export * from './types';
-export * from './FeeOracleMock';
-export * from './providers/OrdMockProvider';
-export * from './providers/OrdHttpProvider';
-

package/src/adapters/providers/OrdHttpProvider.ts

@@ -1,126 +0,0 @@
-/* istanbul ignore file */
-import type { OrdinalsProvider } from '../types';
-
-interface HttpProviderOptions {
-  baseUrl: string;
-}
-
-function buildUrl(baseUrl: string, path: string): string {
-  const base = baseUrl.replace(/\/$/, '');
-  return `${base}${path.startsWith('/') ? '' : '/'}${path}`;
-}
-
-async function fetchJson<T>(url: string): Promise<T | null> {
-  const res = await (globalThis as any).fetch(url, {
-    headers: {
-      'Accept': 'application/json'
-    }
-  });
-  if (!res.ok) return null;
-  return (await res.json()) as T;
-}
-
-export class OrdHttpProvider implements OrdinalsProvider {
-  private readonly baseUrl: string;
-
-  constructor(options: HttpProviderOptions) {
-    if (!options?.baseUrl) {
-      throw new Error('OrdHttpProvider requires baseUrl');
-    }
-    this.baseUrl = options.baseUrl;
-  }
-
-  async getInscriptionById(id: string) {
-    if (!id) return null;
-    const data = await fetchJson<any>(buildUrl(this.baseUrl, `/inscription/${id}`));
-    if (!data) return null;
-    // Expecting a shape similar to Ordinals indexers; adapt minimally
-    const ownerOutput: string | undefined = data.owner_output;
-    let txid = data.txid || 'unknown';
-    let vout = typeof data.vout === 'number' ? data.vout : 0;
-    if (ownerOutput && ownerOutput.includes(':')) {
-      const [tid, v] = ownerOutput.split(':');
-      txid = tid;
-      vout = Number(v) || 0;
-    }
-
-    const contentType = data.content_type || 'application/octet-stream';
-    const contentUrl = data.content_url || buildUrl(this.baseUrl, `/content/${id}`);
-    const contentRes = await (globalThis as any).fetch(contentUrl);
-    if (!contentRes.ok) return null;
-    const buf = (globalThis as any).Buffer
-      ? (globalThis as any).Buffer.from(new Uint8Array(await contentRes.arrayBuffer()))
-      : new Uint8Array(await contentRes.arrayBuffer()) as any;
-
-    return {
-      inscriptionId: data.inscription_id || id,
-      content: buf,
-      contentType,
-      txid,
-      vout,
-      satoshi: String(data.sat ?? ''),
-      blockHeight: data.block_height
-    };
-  }
-
-  async getInscriptionsBySatoshi(satoshi: string) {
-    if (!satoshi) return [];
-    const data = await fetchJson<any>(buildUrl(this.baseUrl, `/sat/${satoshi}`));
-    const ids: string[] = Array.isArray(data?.inscription_ids) ? data.inscription_ids : [];
-    return ids.map((inscriptionId) => ({ inscriptionId }));
-  }
-
-  async broadcastTransaction(_txHexOrObj: unknown): Promise<string> {
-    // For example purposes only, return a placeholder
-    return 'broadcast-txid';
-  }
-
-  async getTransactionStatus(_txid: string) {
-    return { confirmed: false };
-  }
-
-  async estimateFee(blocks: number = 1): Promise<number> {
-    // Basic fallback: some providers expose fee estimates; for example purposes, return linear estimate
-    return 5 * Math.max(1, blocks);
-  }
-
-  async createInscription(params: { data: any; contentType: string; feeRate?: number; }) {
-    // Example placeholder: a real implementation would POST to a service
-    // Here we return a deterministic mock-like result to avoid network coupling in code
-    const inscriptionId = `insc-${Math.random().toString(36).slice(2)}`;
-    const txid = `tx-${Math.random().toString(36).slice(2)}`;
-    return {
-      inscriptionId,
-      revealTxId: txid,
-      txid,
-      vout: 0,
-      blockHeight: undefined,
-      content: params.data,
-      contentType: params.contentType,
-      feeRate: params.feeRate
-    };
-  }
-
-  async transferInscription(inscriptionId: string, _toAddress: string, _options?: { feeRate?: number }) {
-    if (!inscriptionId) throw new Error('inscriptionId required');
-    const txid = `tx-${Math.random().toString(36).slice(2)}`;
-    return {
-      txid,
-      vin: [{ txid: 'prev', vout: 0 }],
-      vout: [{ value: 546, scriptPubKey: 'script' }],
-      fee: 100,
-      confirmations: 0
-    };
-  }
-}
-
-export async function createOrdinalsProviderFromEnv(): Promise<OrdinalsProvider> {
-  const useLive = String(((globalThis as any).process?.env?.USE_LIVE_ORD_PROVIDER) || '').toLowerCase() === 'true';
-  if (useLive) {
-    const baseUrl = ((globalThis as any).process?.env?.ORD_PROVIDER_BASE_URL) || 'https://ord.example.com/api';
-    return new OrdHttpProvider({ baseUrl });
-  }
-  const mod = await import('./OrdMockProvider');
-  return new mod.OrdMockProvider();
-}
-

package/src/adapters/providers/OrdMockProvider.ts

@@ -1,101 +0,0 @@
-import { OrdinalsProvider } from '../types';
-
-export interface OrdMockState {
-  inscriptionsById: Map<string, {
-    inscriptionId: string;
-    content: Buffer;
-    contentType: string;
-    txid: string;
-    vout: number;
-    satoshi?: string;
-    blockHeight?: number;
-  }>;
-  inscriptionsBySatoshi: Map<string, string[]>;
-  feeRate: number;
-}
-
-export class OrdMockProvider implements OrdinalsProvider {
-  private state: OrdMockState;
-
-  constructor(state?: Partial<OrdMockState>) {
-    this.state = {
-      inscriptionsById: new Map(),
-      inscriptionsBySatoshi: new Map(),
-      feeRate: 5,
-      ...state
-    } as OrdMockState;
-  }
-
-  async getInscriptionById(id: string) {
-    const rec = this.state.inscriptionsById.get(id);
-    return rec ? { ...rec } : null;
-  }
-
-  async getInscriptionsBySatoshi(satoshi: string) {
-    const list = this.state.inscriptionsBySatoshi.get(satoshi) || [];
-    return list.map((inscriptionId) => ({ inscriptionId }));
-  }
-
-  async broadcastTransaction(_txHexOrObj: unknown): Promise<string> {
-    return 'mock-broadcast-txid';
-  }
-
-  async getTransactionStatus(txid: string) {
-    return { confirmed: true, blockHeight: 1, confirmations: 1 };
-  }
-
-  async estimateFee(blocks = 1): Promise<number> {
-    return Math.max(1, this.state.feeRate - (blocks - 1));
-  }
-
-  async createInscription(params: { data: Buffer; contentType: string; feeRate?: number; }) {
-    const inscriptionId = `insc-${Math.random().toString(36).slice(2)}`;
-    const txid = `tx-${Math.random().toString(36).slice(2)}`;
-    // Generate a valid numeric satoshi identifier (not sat-123 format)
-    const satoshi = `${Math.floor(Math.random() * 1e12)}`;
-    const vout = 0;
-    const record = {
-      inscriptionId,
-      content: params.data,
-      contentType: params.contentType,
-      txid,
-      vout,
-      satoshi,
-      blockHeight: 1
-    };
-    this.state.inscriptionsById.set(inscriptionId, record);
-    const list = this.state.inscriptionsBySatoshi.get(satoshi) || [];
-    list.push(inscriptionId);
-    this.state.inscriptionsBySatoshi.set(satoshi, list);
-    return {
-      inscriptionId,
-      revealTxId: txid,
-      commitTxId: undefined,
-      satoshi,
-      txid,
-      vout,
-      blockHeight: 1,
-      content: params.data,
-      contentType: params.contentType,
-      feeRate: params.feeRate
-    };
-  }
-
-  async transferInscription(inscriptionId: string, _toAddress: string, _options?: { feeRate?: number }) {
-    const rec = this.state.inscriptionsById.get(inscriptionId);
-    if (!rec) {
-      return Promise.reject(new Error('inscription not found'));
-    }
-    const txid = `tx-${Math.random().toString(36).slice(2)}`;
-    return {
-      txid,
-      vin: [{ txid: rec.txid, vout: rec.vout }],
-      vout: [{ value: 546, scriptPubKey: 'script' }],
-      fee: 100,
-      blockHeight: 1,
-      confirmations: 0,
-      satoshi: rec.satoshi
-    };
-  }
-}
-

package/src/adapters/types.ts

@@ -1,66 +0,0 @@
-export interface StoragePutOptions {
-  contentType?: string;
-  cacheControl?: string;
-}
-
-export interface StorageGetResult {
-  content: Buffer;
-  contentType: string;
-}
-
-export interface StorageAdapter {
-  put(objectKey: string, data: Buffer | string, options?: StoragePutOptions): Promise<string>;
-  get(objectKey: string): Promise<StorageGetResult | null>;
-  delete?(objectKey: string): Promise<boolean>;
-}
-
-export interface FeeOracleAdapter {
-  // Returns sats/vB (or feerate unit appropriate to the network) for the given target blocks
-  estimateFeeRate(targetBlocks?: number): Promise<number>;
-}
-
-export interface OrdinalsProvider {
-  getInscriptionById(id: string): Promise<{
-    inscriptionId: string;
-    content: Buffer;
-    contentType: string;
-    txid: string;
-    vout: number;
-    satoshi?: string;
-    blockHeight?: number;
-  } | null>;
-  getInscriptionsBySatoshi(satoshi: string): Promise<Array<{ inscriptionId: string }>>;
-  broadcastTransaction(txHexOrObj: unknown): Promise<string>;
-  getTransactionStatus(txid: string): Promise<{ confirmed: boolean; blockHeight?: number; confirmations?: number }>;
-  estimateFee(blocks?: number): Promise<number>;
-  createInscription(params: {
-    data: Buffer;
-    contentType: string;
-    feeRate?: number;
-  }): Promise<{
-    inscriptionId: string;
-    revealTxId: string;
-    commitTxId?: string;
-    satoshi?: string;
-    txid?: string;
-    vout?: number;
-    blockHeight?: number;
-    content?: Buffer;
-    contentType?: string;
-    feeRate?: number;
-  }>;
-  transferInscription(
-    inscriptionId: string,
-    toAddress: string,
-    options?: { feeRate?: number }
-  ): Promise<{
-    txid: string;
-    vin: Array<{ txid: string; vout: number }>;
-    vout: Array<{ value: number; scriptPubKey: string; address?: string }>;
-    fee: number;
-    blockHeight?: number;
-    confirmations?: number;
-    satoshi?: string;
-  }>;
-}
-