@originals/sdk 1.4.2 → 1.4.5

package/dist/adapters/FeeOracleMock.d.ts

@@ -0,0 +1,6 @@
+import { FeeOracleAdapter } from './types';
+export declare class FeeOracleMock implements FeeOracleAdapter {
+    private feeRate;
+    constructor(feeRate?: number);
+    estimateFeeRate(targetBlocks?: number): Promise<number>;
+}

package/dist/adapters/FeeOracleMock.js

@@ -0,0 +1,8 @@
+export class FeeOracleMock {
+    constructor(feeRate = 7) {
+        this.feeRate = feeRate;
+    }
+    async estimateFeeRate(targetBlocks = 1) {
+        return Math.max(1, this.feeRate - (targetBlocks - 1));
+    }
+}

package/{src/adapters/index.ts → dist/adapters/index.d.ts}

@@ -2,4 +2,3 @@ export * from './types';
 export * from './FeeOracleMock';
 export * from './providers/OrdMockProvider';
 export * from './providers/OrdHttpProvider';
-

package/dist/adapters/index.js

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

package/dist/adapters/providers/OrdHttpProvider.d.ts

@@ -0,0 +1,56 @@
+import type { OrdinalsProvider } from '../types';
+interface HttpProviderOptions {
+    baseUrl: string;
+}
+export declare class OrdHttpProvider implements OrdinalsProvider {
+    private readonly baseUrl;
+    constructor(options: HttpProviderOptions);
+    getInscriptionById(id: string): Promise<{
+        inscriptionId: any;
+        content: any;
+        contentType: any;
+        txid: any;
+        vout: any;
+        satoshi: string;
+        blockHeight: any;
+    } | null>;
+    getInscriptionsBySatoshi(satoshi: string): Promise<{
+        inscriptionId: string;
+    }[]>;
+    broadcastTransaction(_txHexOrObj: unknown): Promise<string>;
+    getTransactionStatus(_txid: string): Promise<{
+        confirmed: boolean;
+    }>;
+    estimateFee(blocks?: number): Promise<number>;
+    createInscription(params: {
+        data: any;
+        contentType: string;
+        feeRate?: number;
+    }): Promise<{
+        inscriptionId: string;
+        revealTxId: string;
+        txid: string;
+        vout: number;
+        blockHeight: undefined;
+        content: any;
+        contentType: string;
+        feeRate: number | undefined;
+    }>;
+    transferInscription(inscriptionId: string, _toAddress: string, _options?: {
+        feeRate?: number;
+    }): Promise<{
+        txid: string;
+        vin: {
+            txid: string;
+            vout: number;
+        }[];
+        vout: {
+            value: number;
+            scriptPubKey: string;
+        }[];
+        fee: number;
+        confirmations: number;
+    }>;
+}
+export declare function createOrdinalsProviderFromEnv(): Promise<OrdinalsProvider>;
+export {};

package/dist/adapters/providers/OrdHttpProvider.js

@@ -0,0 +1,110 @@
+function buildUrl(baseUrl, path) {
+    const base = baseUrl.replace(/\/$/, '');
+    return `${base}${path.startsWith('/') ? '' : '/'}${path}`;
+}
+async function fetchJson(url) {
+    const res = await globalThis.fetch(url, {
+        headers: {
+            'Accept': 'application/json'
+        }
+    });
+    if (!res.ok)
+        return null;
+    return (await res.json());
+}
+export class OrdHttpProvider {
+    constructor(options) {
+        if (!options?.baseUrl) {
+            throw new Error('OrdHttpProvider requires baseUrl');
+        }
+        this.baseUrl = options.baseUrl;
+    }
+    async getInscriptionById(id) {
+        if (!id)
+            return null;
+        const data = await fetchJson(buildUrl(this.baseUrl, `/inscription/${id}`));
+        if (!data)
+            return null;
+        // Expecting a shape similar to Ordinals indexers; adapt minimally
+        const ownerOutput = 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.fetch(contentUrl);
+        if (!contentRes.ok)
+            return null;
+        const buf = globalThis.Buffer
+            ? globalThis.Buffer.from(new Uint8Array(await contentRes.arrayBuffer()))
+            : new Uint8Array(await contentRes.arrayBuffer());
+        return {
+            inscriptionId: data.inscription_id || id,
+            content: buf,
+            contentType,
+            txid,
+            vout,
+            satoshi: String(data.sat ?? ''),
+            blockHeight: data.block_height
+        };
+    }
+    async getInscriptionsBySatoshi(satoshi) {
+        if (!satoshi)
+            return [];
+        const data = await fetchJson(buildUrl(this.baseUrl, `/sat/${satoshi}`));
+        const ids = Array.isArray(data?.inscription_ids) ? data.inscription_ids : [];
+        return ids.map((inscriptionId) => ({ inscriptionId }));
+    }
+    async broadcastTransaction(_txHexOrObj) {
+        // For example purposes only, return a placeholder
+        return 'broadcast-txid';
+    }
+    async getTransactionStatus(_txid) {
+        return { confirmed: false };
+    }
+    async estimateFee(blocks = 1) {
+        // Basic fallback: some providers expose fee estimates; for example purposes, return linear estimate
+        return 5 * Math.max(1, blocks);
+    }
+    async createInscription(params) {
+        // 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, _toAddress, _options) {
+        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() {
+    const useLive = String((globalThis.process?.env?.USE_LIVE_ORD_PROVIDER) || '').toLowerCase() === 'true';
+    if (useLive) {
+        const baseUrl = (globalThis.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/dist/adapters/providers/OrdMockProvider.d.ts

@@ -0,0 +1,70 @@
+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 declare class OrdMockProvider implements OrdinalsProvider {
+    private state;
+    constructor(state?: Partial<OrdMockState>);
+    getInscriptionById(id: string): Promise<{
+        inscriptionId: string;
+        content: Buffer;
+        contentType: string;
+        txid: string;
+        vout: number;
+        satoshi?: string;
+        blockHeight?: number;
+    } | null>;
+    getInscriptionsBySatoshi(satoshi: string): Promise<{
+        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: undefined;
+        satoshi: string;
+        txid: string;
+        vout: number;
+        blockHeight: number;
+        content: Buffer<ArrayBufferLike>;
+        contentType: string;
+        feeRate: number | undefined;
+    }>;
+    transferInscription(inscriptionId: string, _toAddress: string, _options?: {
+        feeRate?: number;
+    }): Promise<{
+        txid: string;
+        vin: {
+            txid: string;
+            vout: number;
+        }[];
+        vout: {
+            value: number;
+            scriptPubKey: string;
+        }[];
+        fee: number;
+        blockHeight: number;
+        confirmations: number;
+        satoshi: string | undefined;
+    }>;
+}

package/dist/adapters/providers/OrdMockProvider.js

@@ -0,0 +1,75 @@
+export class OrdMockProvider {
+    constructor(state) {
+        this.state = {
+            inscriptionsById: new Map(),
+            inscriptionsBySatoshi: new Map(),
+            feeRate: 5,
+            ...state
+        };
+    }
+    async getInscriptionById(id) {
+        const rec = this.state.inscriptionsById.get(id);
+        return rec ? { ...rec } : null;
+    }
+    async getInscriptionsBySatoshi(satoshi) {
+        const list = this.state.inscriptionsBySatoshi.get(satoshi) || [];
+        return list.map((inscriptionId) => ({ inscriptionId }));
+    }
+    async broadcastTransaction(_txHexOrObj) {
+        return 'mock-broadcast-txid';
+    }
+    async getTransactionStatus(txid) {
+        return { confirmed: true, blockHeight: 1, confirmations: 1 };
+    }
+    async estimateFee(blocks = 1) {
+        return Math.max(1, this.state.feeRate - (blocks - 1));
+    }
+    async createInscription(params) {
+        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, _toAddress, _options) {
+        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/dist/adapters/types.d.ts

@@ -0,0 +1,71 @@
+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 {
+    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;
+    }>;
+}

package/dist/adapters/types.js

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

package/dist/bitcoin/BitcoinManager.d.ts

@@ -0,0 +1,15 @@
+import { OriginalsConfig, OrdinalsInscription, BitcoinTransaction } from '../types';
+export declare class BitcoinManager {
+    private config;
+    private readonly feeOracle?;
+    private readonly ord?;
+    constructor(config: OriginalsConfig);
+    private resolveFeeRate;
+    inscribeData(data: any, contentType: string, feeRate?: number): Promise<OrdinalsInscription>;
+    trackInscription(inscriptionId: string): Promise<OrdinalsInscription | null>;
+    transferInscription(inscription: OrdinalsInscription, toAddress: string): Promise<BitcoinTransaction>;
+    preventFrontRunning(satoshi: string): Promise<boolean>;
+    getSatoshiFromInscription(inscriptionId: string): Promise<string | null>;
+    validateBTCODID(didId: string): Promise<boolean>;
+    private extractSatoshiFromBTCODID;
+}