@originals/sdk 1.1.0 → 1.4.2

package/dist/examples/basic-usage.js

@@ -1,62 +0,0 @@
-import { OriginalsSDK } from '../index';
-async function basicExample() {
-    const sdk = OriginalsSDK.create({
-        network: 'regtest',
-        enableLogging: true,
-        // Example uses defaults; provide adapters in your app or tests
-        telemetry: {
-            onEvent: (e) => console.log('[telemetry]', e.name, e.attributes || {}),
-            onError: (err) => console.warn('[error]', err.code, err.message)
-        }
-    });
-    // Create new digital asset
-    const resources = [{
-            id: 'image-1',
-            type: 'image',
-            content: 'base64-encoded-image-data',
-            contentType: 'image/png',
-            hash: 'sha256-hash'
-        }];
-    try {
-        // Create asset in did:peer layer (private, offline)
-        const asset = await sdk.lifecycle.createAsset(resources);
-        console.log('Created asset:', asset.id);
-        console.log('Current layer:', asset.currentLayer); // 'did:peer'
-        // Publish to web for discovery (did:webvh layer)
-        await sdk.lifecycle.publishToWeb(asset, 'example.com');
-        console.log('Published to web, current layer:', asset.currentLayer); // 'did:webvh'
-        // Inscribe on Bitcoin for permanent ownership (did:btco layer)
-        await sdk.lifecycle.inscribeOnBitcoin(asset);
-        console.log('Inscribed on Bitcoin, current layer:', asset.currentLayer); // 'did:btco'
-        // Get full provenance chain
-        const provenance = asset.getProvenance();
-        console.log('Provenance:', provenance);
-        // Verify asset integrity
-        const isValid = await asset.verify();
-        console.log('Asset is valid:', isValid);
-    }
-    catch (error) {
-        console.error('Error:', error);
-    }
-}
-async function digitalArtExample() {
-    const sdk = OriginalsSDK.create();
-    // Artist creates digital artwork
-    const artwork = [{
-            id: 'artwork-001',
-            type: 'image',
-            url: 'https://artist-site.com/my-artwork.jpg',
-            contentType: 'image/jpeg',
-            hash: 'abcd1234...' // SHA-256 hash of image
-        }];
-    // Create private version for experimentation
-    const asset = await sdk.lifecycle.createAsset(artwork);
-    // Make discoverable when ready
-    await sdk.lifecycle.publishToWeb(asset, 'artist-gallery.com');
-    // Inscribe on Bitcoin when sold
-    await sdk.lifecycle.inscribeOnBitcoin(asset);
-    // Transfer to buyer
-    await sdk.lifecycle.transferOwnership(asset, 'buyer-address');
-}
-// Export examples
-export { basicExample, digitalArtExample };

package/dist/examples/run.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/examples/run.js

@@ -1,4 +0,0 @@
-import { basicExample } from './basic-usage';
-import { digitalArtExample } from './basic-usage';
-basicExample();
-digitalArtExample();

package/dist/index.d.ts

@@ -1,39 +0,0 @@
-import './crypto/noble-init.js';
-import { OriginalsSDK } from './core/OriginalsSDK.js';
-export { OriginalsSDK } from './core/OriginalsSDK.js';
-export type { OriginalsSDKOptions, OriginalResult, CreateOriginalOptions, UpdateOriginalOptions, CreateDIDOriginalOptions, UpdateDIDOriginalOptions } from './core/OriginalsSDK.js';
-export { OriginalsAsset } from './lifecycle/OriginalsAsset.js';
-export type { ProvenanceChain } from './lifecycle/OriginalsAsset.js';
-export * from './types/index.js';
-export { DIDManager, type CreateWebVHOptions, type CreateWebVHResult } from './did/DIDManager.js';
-export { KeyManager } from './did/KeyManager.js';
-export { Ed25519Verifier } from './did/Ed25519Verifier.js';
-export * as encoding from './utils/encoding.js';
-export { CredentialManager } from './vc/CredentialManager.js';
-export { LifecycleManager } from './lifecycle/LifecycleManager.js';
-export { BitcoinManager } from './bitcoin/BitcoinManager.js';
-export { OrdinalsClient } from './bitcoin/OrdinalsClient.js';
-export { buildTransferTransaction } from './bitcoin/transfer.js';
-export { selectUtxos, UtxoSelectionError, estimateFeeSats } from './bitcoin/utxo.js';
-export { selectUtxos as selectUtxosSimple, selectResourceUtxos, selectUtxosForPayment, tagResourceUtxos, estimateTransactionSize } from './bitcoin/utxo-selection.js';
-export { calculateFee } from './bitcoin/fee-calculation.js';
-export { BBSCryptosuiteUtils } from './vc/cryptosuites/bbs.js';
-export { BbsSimple } from './vc/cryptosuites/bbsSimple.js';
-export * from './storage/index.js';
-export { Signer, ES256KSigner, Ed25519Signer, ES256Signer, Bls12381G2Signer } from './crypto/Signer.js';
-export { multikey } from './crypto/Multikey.js';
-export type { MultikeyType } from './crypto/Multikey.js';
-export * from './events/index.js';
-export { MigrationManager } from './migration/index.js';
-export * from './migration/types.js';
-export { BatchOperationExecutor, BatchValidator, BatchError, type BatchResult, type BatchOperationOptions, type BatchInscriptionOptions, type BatchInscriptionResult, type ValidationResult } from './lifecycle/BatchOperations.js';
-export * from './utils/validation.js';
-export * from './utils/satoshi-validation.js';
-export * from './utils/serialization.js';
-export * from './utils/retry.js';
-export * from './utils/telemetry.js';
-export { sha256Bytes } from './utils/hash.js';
-export { OrdMockProvider } from './adapters/providers/OrdMockProvider.js';
-export { FeeOracleMock } from './adapters/FeeOracleMock.js';
-export type { OrdinalsProvider, FeeOracleAdapter, StorageAdapter } from './adapters/types.js';
-export default OriginalsSDK;

package/dist/index.js

@@ -1,47 +0,0 @@
-/* istanbul ignore file */
-// Initialize noble crypto libraries first (must run before any crypto operations)
-import './crypto/noble-init.js';
-import { OriginalsSDK } from './core/OriginalsSDK.js';
-// Main exports
-export { OriginalsSDK } from './core/OriginalsSDK.js';
-export { OriginalsAsset } from './lifecycle/OriginalsAsset.js';
-// Type exports
-export * from './types/index.js';
-// Manager exports
-export { DIDManager } from './did/DIDManager.js';
-export { KeyManager } from './did/KeyManager.js';
-export { Ed25519Verifier } from './did/Ed25519Verifier.js';
-export * as encoding from './utils/encoding.js';
-export { CredentialManager } from './vc/CredentialManager.js';
-export { LifecycleManager } from './lifecycle/LifecycleManager.js';
-export { BitcoinManager } from './bitcoin/BitcoinManager.js';
-export { OrdinalsClient } from './bitcoin/OrdinalsClient.js';
-export { buildTransferTransaction } from './bitcoin/transfer.js';
-export { selectUtxos, UtxoSelectionError, estimateFeeSats } from './bitcoin/utxo.js';
-export { selectUtxos as selectUtxosSimple, selectResourceUtxos, selectUtxosForPayment, tagResourceUtxos, estimateTransactionSize } from './bitcoin/utxo-selection.js';
-export { calculateFee } from './bitcoin/fee-calculation.js';
-export { BBSCryptosuiteUtils } from './vc/cryptosuites/bbs.js';
-export { BbsSimple } from './vc/cryptosuites/bbsSimple.js';
-export * from './storage/index.js';
-// Crypto exports
-export { Signer, ES256KSigner, Ed25519Signer, ES256Signer, Bls12381G2Signer } from './crypto/Signer.js';
-export { multikey } from './crypto/Multikey.js';
-// Event system exports
-export * from './events/index.js';
-// Migration system exports
-export { MigrationManager } from './migration/index.js';
-export * from './migration/types.js';
-// Batch operations exports
-export { BatchOperationExecutor, BatchValidator, BatchError } from './lifecycle/BatchOperations.js';
-// Utility exports
-export * from './utils/validation.js';
-export * from './utils/satoshi-validation.js';
-export * from './utils/serialization.js';
-export * from './utils/retry.js';
-export * from './utils/telemetry.js';
-export { sha256Bytes } from './utils/hash.js';
-// Adapter exports (for testing and custom integrations)
-export { OrdMockProvider } from './adapters/providers/OrdMockProvider.js';
-export { FeeOracleMock } from './adapters/FeeOracleMock.js';
-// Default export
-export default OriginalsSDK;

package/dist/lifecycle/BatchOperations.d.ts

@@ -1,147 +0,0 @@
-/**
- * Batch Operations for Originals SDK
- *
- * Enables efficient processing of multiple assets with:
- * - Configurable concurrency
- * - Retry logic with exponential backoff
- * - Fail-fast vs continue-on-error modes
- * - Pre-validation of all items
- * - Detailed timing and error tracking
- */
-/**
- * Result of a batch operation containing successful and failed items
- */
-export interface BatchResult<T> {
-    successful: Array<{
-        index: number;
-        result: T;
-        duration: number;
-    }>;
-    failed: Array<{
-        index: number;
-        error: Error;
-        duration: number;
-        retryAttempts?: number;
-    }>;
-    totalProcessed: number;
-    totalDuration: number;
-    batchId: string;
-    startedAt: string;
-    completedAt: string;
-}
-/**
- * Options for configuring batch operation execution
- */
-export interface BatchOperationOptions {
-    continueOnError?: boolean;
-    maxConcurrent?: number;
-    retryCount?: number;
-    retryDelay?: number;
-    timeoutMs?: number;
-    validateFirst?: boolean;
-}
-/**
- * Options for batch inscription operations with Bitcoin-specific settings
- */
-export interface BatchInscriptionOptions extends BatchOperationOptions {
-    singleTransaction?: boolean;
-    feeRate?: number;
-}
-/**
- * Error thrown when a batch operation fails
- */
-export declare class BatchError extends Error {
-    batchId: string;
-    operation: string;
-    partialResults: {
-        successful: number;
-        failed: number;
-    };
-    constructor(batchId: string, operation: string, partialResults: {
-        successful: number;
-        failed: number;
-    }, message: string);
-}
-/**
- * Result of a single-transaction batch inscription with cost analysis
- */
-export interface BatchInscriptionResult<T> {
-    batchTransactionId: string;
-    individualInscriptionIds: string[];
-    assets: T[];
-    totalFee: number;
-    feePerAsset: number[];
-    feeSavings: {
-        batchFee: number;
-        individualFees: number;
-        savings: number;
-        savingsPercentage: number;
-    };
-    batchId: string;
-    processingTime: number;
-}
-/**
- * Executor for batch operations with configurable options
- */
-export declare class BatchOperationExecutor {
-    private defaultOptions;
-    constructor(defaultOptions?: BatchOperationOptions);
-    /**
-     * Execute a batch operation on multiple items
-     *
-     * @param items - Array of items to process
-     * @param operation - Function to execute on each item
-     * @param options - Batch operation options
-     * @param predeterminedBatchId - Optional pre-generated batch ID for event correlation
-     * @returns BatchResult with successful and failed operations
-     */
-    execute<T, R>(items: T[], operation: (item: T, index: number) => Promise<R>, options?: BatchOperationOptions, predeterminedBatchId?: string): Promise<BatchResult<R>>;
-    /**
-     * Generate unique batch ID
-     */
-    generateBatchId(): string;
-    /**
-     * Calculate retry delay with exponential backoff
-     */
-    private calculateRetryDelay;
-    /**
-     * Execute operation with timeout
-     */
-    private executeWithTimeout;
-    /**
-     * Sleep for specified milliseconds
-     */
-    private sleep;
-    /**
-     * Chunk array into smaller arrays of specified size
-     */
-    private chunkArray;
-}
-/**
- * Validation result for batch operations
- */
-export interface ValidationResult {
-    isValid: boolean;
-    errors: string[];
-    warnings?: string[];
-}
-/**
- * Validator for batch operations
- */
-export declare class BatchValidator {
-    /**
-     * Validate batch of resources for asset creation
-     */
-    validateBatchCreate(resourcesList: any[][]): ValidationResult[];
-    /**
-     * Validate batch of assets for inscription
-     */
-    validateBatchInscription(assets: any[]): ValidationResult[];
-    /**
-     * Validate batch of transfer operations
-     */
-    validateBatchTransfer(transfers: Array<{
-        asset: any;
-        to: string;
-    }>): ValidationResult[];
-}

package/dist/lifecycle/BatchOperations.js

@@ -1,251 +0,0 @@
-/**
- * Batch Operations for Originals SDK
- *
- * Enables efficient processing of multiple assets with:
- * - Configurable concurrency
- * - Retry logic with exponential backoff
- * - Fail-fast vs continue-on-error modes
- * - Pre-validation of all items
- * - Detailed timing and error tracking
- */
-import { randomBytes, bytesToHex } from '@noble/hashes/utils.js';
-/**
- * Error thrown when a batch operation fails
- */
-export class BatchError extends Error {
-    constructor(batchId, operation, partialResults, message) {
-        super(message);
-        this.batchId = batchId;
-        this.operation = operation;
-        this.partialResults = partialResults;
-        this.name = 'BatchError';
-    }
-}
-/**
- * Executor for batch operations with configurable options
- */
-export class BatchOperationExecutor {
-    constructor(defaultOptions = {}) {
-        this.defaultOptions = defaultOptions;
-    }
-    /**
-     * Execute a batch operation on multiple items
-     *
-     * @param items - Array of items to process
-     * @param operation - Function to execute on each item
-     * @param options - Batch operation options
-     * @param predeterminedBatchId - Optional pre-generated batch ID for event correlation
-     * @returns BatchResult with successful and failed operations
-     */
-    async execute(items, operation, options, predeterminedBatchId) {
-        const opts = { ...this.defaultOptions, ...options };
-        const { continueOnError = false, maxConcurrent = 1, retryCount = 0, retryDelay = 1000, timeoutMs = 30000 } = opts;
-        const batchId = predeterminedBatchId || this.generateBatchId();
-        const startedAt = new Date().toISOString();
-        const startTime = Date.now();
-        const successful = [];
-        const failed = [];
-        // Process items with concurrency control
-        const processItem = async (item, index) => {
-            const itemStartTime = Date.now();
-            let lastError = null;
-            let attempts = 0;
-            for (let attempt = 0; attempt <= retryCount; attempt++) {
-                attempts = attempt + 1;
-                try {
-                    // Execute with timeout
-                    const result = await this.executeWithTimeout(() => operation(item, index), timeoutMs);
-                    const duration = Date.now() - itemStartTime;
-                    successful.push({ index, result, duration });
-                    return;
-                }
-                catch (error) {
-                    lastError = error instanceof Error ? error : new Error(String(error));
-                    // If not last attempt, wait with exponential backoff
-                    if (attempt < retryCount) {
-                        const delay = this.calculateRetryDelay(attempt, retryDelay);
-                        await this.sleep(delay);
-                    }
-                }
-            }
-            // All retries failed
-            const duration = Date.now() - itemStartTime;
-            failed.push({
-                index,
-                error: lastError,
-                duration,
-                retryAttempts: attempts - 1
-            });
-            // If fail-fast mode, throw error
-            if (!continueOnError) {
-                throw lastError;
-            }
-        };
-        // Process items in batches based on maxConcurrent
-        try {
-            if (maxConcurrent === 1) {
-                // Sequential processing
-                for (let i = 0; i < items.length; i++) {
-                    await processItem(items[i], i);
-                }
-            }
-            else {
-                // Concurrent processing with limit
-                const chunks = this.chunkArray(items, maxConcurrent);
-                for (const chunk of chunks) {
-                    await Promise.all(chunk.map((item, chunkIndex) => {
-                        const globalIndex = chunks.slice(0, chunks.indexOf(chunk))
-                            .reduce((acc, c) => acc + c.length, 0) + chunkIndex;
-                        return processItem(item, globalIndex);
-                    }));
-                }
-            }
-        }
-        catch (error) {
-            // In fail-fast mode, re-throw the error so callers can handle it
-            if (!continueOnError) {
-                throw error instanceof Error ? error : new Error(String(error));
-            }
-            // In continue-on-error mode, the error was already logged in processItem
-            // and we'll return the partial results below
-        }
-        const totalDuration = Date.now() - startTime;
-        const completedAt = new Date().toISOString();
-        return {
-            successful,
-            failed,
-            totalProcessed: successful.length + failed.length,
-            totalDuration,
-            batchId,
-            startedAt,
-            completedAt
-        };
-    }
-    /**
-     * Generate unique batch ID
-     */
-    generateBatchId() {
-        return `batch_${Date.now()}_${bytesToHex(randomBytes(8))}`;
-    }
-    /**
-     * Calculate retry delay with exponential backoff
-     */
-    calculateRetryDelay(attempt, baseDelay) {
-        // Exponential backoff: baseDelay * 2^attempt
-        return baseDelay * Math.pow(2, attempt);
-    }
-    /**
-     * Execute operation with timeout
-     */
-    async executeWithTimeout(operation, timeoutMs) {
-        return Promise.race([
-            operation(),
-            new Promise((_, reject) => setTimeout(() => reject(new Error(`Operation timeout after ${timeoutMs}ms`)), timeoutMs))
-        ]);
-    }
-    /**
-     * Sleep for specified milliseconds
-     */
-    sleep(ms) {
-        return new Promise(resolve => setTimeout(resolve, ms));
-    }
-    /**
-     * Chunk array into smaller arrays of specified size
-     */
-    chunkArray(array, size) {
-        const chunks = [];
-        for (let i = 0; i < array.length; i += size) {
-            chunks.push(array.slice(i, i + size));
-        }
-        return chunks;
-    }
-}
-/**
- * Validator for batch operations
- */
-export class BatchValidator {
-    /**
-     * Validate batch of resources for asset creation
-     */
-    validateBatchCreate(resourcesList) {
-        return resourcesList.map((resources, index) => {
-            const errors = [];
-            if (!Array.isArray(resources)) {
-                errors.push(`Item ${index}: Resources must be an array`);
-                return { isValid: false, errors };
-            }
-            if (resources.length === 0) {
-                errors.push(`Item ${index}: At least one resource is required`);
-                return { isValid: false, errors };
-            }
-            // Validate each resource
-            for (let i = 0; i < resources.length; i++) {
-                const resource = resources[i];
-                if (!resource || typeof resource !== 'object') {
-                    errors.push(`Item ${index}, resource ${i}: Invalid resource object`);
-                    continue;
-                }
-                if (!resource.id || typeof resource.id !== 'string') {
-                    errors.push(`Item ${index}, resource ${i}: Missing or invalid id`);
-                }
-                if (!resource.type || typeof resource.type !== 'string') {
-                    errors.push(`Item ${index}, resource ${i}: Missing or invalid type`);
-                }
-                if (!resource.contentType || typeof resource.contentType !== 'string') {
-                    errors.push(`Item ${index}, resource ${i}: Missing or invalid contentType`);
-                }
-                if (!resource.hash || typeof resource.hash !== 'string' || !/^[0-9a-fA-F]+$/.test(resource.hash)) {
-                    errors.push(`Item ${index}, resource ${i}: Missing or invalid hash`);
-                }
-            }
-            return { isValid: errors.length === 0, errors };
-        });
-    }
-    /**
-     * Validate batch of assets for inscription
-     */
-    validateBatchInscription(assets) {
-        return assets.map((asset, index) => {
-            const errors = [];
-            if (!asset || typeof asset !== 'object') {
-                errors.push(`Item ${index}: Invalid asset object`);
-                return { isValid: false, errors };
-            }
-            if (!asset.id || typeof asset.id !== 'string') {
-                errors.push(`Item ${index}: Missing or invalid asset id`);
-            }
-            if (!asset.currentLayer) {
-                errors.push(`Item ${index}: Missing currentLayer`);
-            }
-            else if (asset.currentLayer === 'did:btco') {
-                errors.push(`Item ${index}: Asset already inscribed on Bitcoin`);
-            }
-            if (!asset.resources || !Array.isArray(asset.resources) || asset.resources.length === 0) {
-                errors.push(`Item ${index}: Asset must have at least one resource`);
-            }
-            return { isValid: errors.length === 0, errors };
-        });
-    }
-    /**
-     * Validate batch of transfer operations
-     */
-    validateBatchTransfer(transfers) {
-        return transfers.map((transfer, index) => {
-            const errors = [];
-            if (!transfer || typeof transfer !== 'object') {
-                errors.push(`Item ${index}: Invalid transfer object`);
-                return { isValid: false, errors };
-            }
-            if (!transfer.asset || typeof transfer.asset !== 'object') {
-                errors.push(`Item ${index}: Invalid asset`);
-            }
-            else if (transfer.asset.currentLayer !== 'did:btco') {
-                errors.push(`Item ${index}: Asset must be inscribed on Bitcoin before transfer`);
-            }
-            if (!transfer.to || typeof transfer.to !== 'string') {
-                errors.push(`Item ${index}: Invalid destination address`);
-            }
-            return { isValid: errors.length === 0, errors };
-        });
-    }
-}

package/dist/lifecycle/LifecycleManager.d.ts

@@ -1,116 +0,0 @@
-import { OriginalsConfig, AssetResource, BitcoinTransaction, KeyStore, ExternalSigner } from '../types';
-import { BitcoinManager } from '../bitcoin/BitcoinManager';
-import { DIDManager } from '../did/DIDManager';
-import { CredentialManager } from '../vc/CredentialManager';
-import { OriginalsAsset } from './OriginalsAsset';
-import type { EventHandler, EventTypeMap } from '../events/types';
-import { type BatchResult, type BatchOperationOptions, type BatchInscriptionOptions } from './BatchOperations';
-export declare class LifecycleManager {
-    private config;
-    private didManager;
-    private credentialManager;
-    private deps?;
-    private keyStore?;
-    private eventEmitter;
-    private batchExecutor;
-    private batchValidator;
-    private logger;
-    private metrics;
-    constructor(config: OriginalsConfig, didManager: DIDManager, credentialManager: CredentialManager, deps?: {
-        bitcoinManager?: BitcoinManager;
-    } | undefined, keyStore?: KeyStore | undefined);
-    /**
-     * Subscribe to a lifecycle event
-     * @param eventType - The type of event to subscribe to
-     * @param handler - The handler function to call when the event is emitted
-     * @returns A function to unsubscribe from the event
-     */
-    on<K extends keyof EventTypeMap>(eventType: K, handler: EventHandler<EventTypeMap[K]>): () => void;
-    /**
-     * Subscribe to a lifecycle event once
-     * @param eventType - The type of event to subscribe to
-     * @param handler - The handler function to call when the event is emitted (will only fire once)
-     * @returns A function to unsubscribe from the event
-     */
-    once<K extends keyof EventTypeMap>(eventType: K, handler: EventHandler<EventTypeMap[K]>): () => void;
-    /**
-     * Unsubscribe from a lifecycle event
-     * @param eventType - The type of event to unsubscribe from
-     * @param handler - The handler function to remove
-     */
-    off<K extends keyof EventTypeMap>(eventType: K, handler: EventHandler<EventTypeMap[K]>): void;
-    registerKey(verificationMethodId: string, privateKey: string): Promise<void>;
-    createAsset(resources: AssetResource[]): Promise<OriginalsAsset>;
-    publishToWeb(asset: OriginalsAsset, publisherDidOrSigner: string | ExternalSigner): Promise<OriginalsAsset>;
-    private extractPublisherInfo;
-    private parseWebVHDid;
-    private publishResources;
-    private emitResourcePublishedEvent;
-    private issuePublicationCredential;
-    private signWithKeyStore;
-    inscribeOnBitcoin(asset: OriginalsAsset, feeRate?: number): Promise<OriginalsAsset>;
-    transferOwnership(asset: OriginalsAsset, newOwner: string): Promise<BitcoinTransaction>;
-    /**
-     * Create multiple assets in batch
-     *
-     * @param resourcesList - Array of resource arrays, one per asset to create
-     * @param options - Batch operation options
-     * @returns BatchResult with created assets
-     */
-    batchCreateAssets(resourcesList: AssetResource[][], options?: BatchOperationOptions): Promise<BatchResult<OriginalsAsset>>;
-    /**
-     * Publish multiple assets to web storage in batch
-     *
-     * @param assets - Array of assets to publish
-     * @param domain - Domain to publish to
-     * @param options - Batch operation options
-     * @returns BatchResult with published assets
-     */
-    batchPublishToWeb(assets: OriginalsAsset[], domain: string, options?: BatchOperationOptions): Promise<BatchResult<OriginalsAsset>>;
-    /**
-     * Inscribe multiple assets on Bitcoin with cost optimization
-     * KEY FEATURE: singleTransaction option for 30%+ cost savings
-     *
-     * @param assets - Array of assets to inscribe
-     * @param options - Batch inscription options
-     * @returns BatchResult with inscribed assets
-     */
-    batchInscribeOnBitcoin(assets: OriginalsAsset[], options?: BatchInscriptionOptions): Promise<BatchResult<OriginalsAsset>>;
-    /**
-     * CORE INNOVATION: Single-transaction batch inscription
-     * Combines multiple assets into one Bitcoin transaction for 30%+ cost savings
-     *
-     * @param assets - Array of assets to inscribe
-     * @param options - Batch inscription options
-     * @returns BatchResult with inscribed assets and cost savings data
-     */
-    private batchInscribeSingleTransaction;
-    /**
-     * Individual transaction batch inscription (fallback mode)
-     * Each asset is inscribed in its own transaction
-     *
-     * @param assets - Array of assets to inscribe
-     * @param options - Batch inscription options
-     * @returns BatchResult with inscribed assets
-     */
-    private batchInscribeIndividualTransactions;
-    /**
-     * Transfer ownership of multiple assets in batch
-     *
-     * @param transfers - Array of transfer operations
-     * @param options - Batch operation options
-     * @returns BatchResult with transaction results
-     */
-    batchTransferOwnership(transfers: Array<{
-        asset: OriginalsAsset;
-        to: string;
-    }>, options?: BatchOperationOptions): Promise<BatchResult<BitcoinTransaction>>;
-    /**
-     * Calculate total data size for all assets in a batch
-     */
-    private calculateTotalDataSize;
-    /**
-     * Estimate cost savings from batch inscription vs individual inscriptions
-     */
-    private estimateBatchSavings;
-}