@originals/sdk 1.2.0 → 1.4.2

package/dist/bitcoin/OrdinalsClient.d.ts

@@ -1,21 +0,0 @@
-import { OrdinalsInscription, BitcoinTransaction } from '../types';
-export declare class OrdinalsClient {
-    private rpcUrl;
-    private network;
-    constructor(rpcUrl: string, network: 'mainnet' | 'regtest' | 'signet');
-    getInscriptionById(id: string): Promise<OrdinalsInscription | null>;
-    getInscriptionsBySatoshi(satoshi: string): Promise<OrdinalsInscription[]>;
-    broadcastTransaction(tx: BitcoinTransaction): Promise<string>;
-    getTransactionStatus(txid: string): Promise<{
-        confirmed: boolean;
-        blockHeight?: number;
-        confirmations?: number;
-    }>;
-    estimateFee(blocks?: number): Promise<number>;
-    getSatInfo(satoshi: string): Promise<{
-        inscription_ids: string[];
-    }>;
-    resolveInscription(identifier: string): Promise<OrdinalsInscription | null>;
-    getMetadata(inscriptionId: string): Promise<Record<string, unknown> | null>;
-    private fetchJson;
-}

package/dist/bitcoin/OrdinalsClient.js

@@ -1,105 +0,0 @@
-import { decode as decodeCbor } from '../utils/cbor';
-import { hexToBytes } from '../utils/encoding';
-export class OrdinalsClient {
-    constructor(rpcUrl, network) {
-        this.rpcUrl = rpcUrl;
-        this.network = network;
-    }
-    async getInscriptionById(id) {
-        if (!id)
-            return null;
-        return this.resolveInscription(id);
-    }
-    async getInscriptionsBySatoshi(satoshi) {
-        const info = await this.getSatInfo(satoshi);
-        if (!info.inscription_ids.length)
-            return [];
-        const inscriptions = await Promise.all(info.inscription_ids.map(id => this.resolveInscription(id)));
-        return inscriptions.filter((x) => x !== null);
-    }
-    async broadcastTransaction(tx) {
-        return tx.txid || 'txid';
-    }
-    async getTransactionStatus(txid) {
-        return { confirmed: false };
-    }
-    async estimateFee(blocks = 1) {
-        return Math.max(1, blocks) * 10;
-    }
-    // Added provider-like helper methods commonly expected by higher-level resolvers
-    // Minimal placeholder implementations suitable for unit testing
-    async getSatInfo(satoshi) {
-        const data = await this.fetchJson(`/sat/${satoshi}`);
-        if (!data)
-            return { inscription_ids: [] };
-        // Support both {inscription_ids: []} and {data: {inscription_ids: []}} shapes via fetchJson
-        const inscriptionIds = Array.isArray(data.inscription_ids) ? data.inscription_ids : [];
-        return { inscription_ids: inscriptionIds };
-    }
-    async resolveInscription(identifier) {
-        if (!identifier)
-            return null;
-        const info = await this.fetchJson(`/inscription/${identifier}`);
-        if (!info)
-            return null;
-        // Fetch content bytes
-        const contentUrl = info.content_url || `${this.rpcUrl}/content/${identifier}`;
-        const contentRes = await fetch(contentUrl);
-        if (!contentRes.ok)
-            throw new Error(`Failed to fetch inscription content: ${contentRes.status}`);
-        const contentArrayBuf = await contentRes.arrayBuffer();
-        const content = Buffer.from(new Uint8Array(contentArrayBuf));
-        // owner_output may be 'txid:vout'
-        let txid = 'unknown';
-        let vout = 0;
-        if (typeof info.owner_output === 'string' && info.owner_output.includes(':')) {
-            const [tid, v] = info.owner_output.split(':');
-            txid = tid;
-            vout = Number(v) || 0;
-        }
-        // sat number provided as number or string
-        const satoshi = String(info.sat ?? '');
-        const inscription = {
-            satoshi,
-            inscriptionId: info.inscription_id || identifier,
-            content,
-            contentType: info.content_type || 'application/octet-stream',
-            txid,
-            vout,
-            blockHeight: info.block_height
-        };
-        return inscription;
-    }
-    async getMetadata(inscriptionId) {
-        if (!inscriptionId)
-            return null;
-        const base = this.rpcUrl.replace(/\/$/, '');
-        const res = await fetch(`${base}/r/metadata/${inscriptionId}`, { headers: { 'Accept': 'application/json' } });
-        if (!res.ok) {
-            return null;
-        }
-        let text = (await res.text()).trim();
-        if (text.startsWith('"') && text.endsWith('"')) {
-            try {
-                text = JSON.parse(text);
-            }
-            catch (_) { }
-        }
-        try {
-            const bytes = hexToBytes(text);
-            return decodeCbor(bytes);
-        }
-        catch (_) {
-            return null;
-        }
-    }
-    async fetchJson(path) {
-        const url = `${this.rpcUrl.replace(/\/$/, '')}${path}`;
-        const res = await fetch(url, { headers: { 'Accept': 'application/json' } });
-        if (!res.ok)
-            return null;
-        const body = await res.json();
-        // Accept { data: T } or T
-        return (body && typeof body === 'object' && 'data' in body) ? body.data : body;
-    }
-}

package/dist/bitcoin/PSBTBuilder.d.ts

@@ -1,24 +0,0 @@
-import type { Utxo } from '../types/bitcoin';
-export interface PsbtOutput {
-    address: string;
-    value: number;
-}
-export interface BuildPsbtParams {
-    utxos: Utxo[];
-    outputs: PsbtOutput[];
-    changeAddress: string;
-    feeRate: number;
-    network: 'mainnet' | 'testnet' | 'regtest' | 'signet';
-    dustLimit?: number;
-}
-export interface BuildPsbtResult {
-    psbtBase64: string;
-    selectedUtxos: Utxo[];
-    fee: number;
-    changeOutput?: PsbtOutput;
-}
-export declare class PSBTBuilder {
-    private readonly dustLimit;
-    constructor(dustLimit?: number);
-    build(params: BuildPsbtParams): BuildPsbtResult;
-}

package/dist/bitcoin/PSBTBuilder.js

@@ -1,80 +0,0 @@
-function estimateVBytes(inputs, outputs) {
-    const overhead = 10; // base tx overhead
-    const inSize = 68; // rough P2WPKH/any-segwit input size
-    const outSize = 31; // P2WPKH output size
-    return Math.ceil(overhead + inputs * inSize + outputs * outSize);
-}
-export class PSBTBuilder {
-    constructor(dustLimit = 546) {
-        this.dustLimit = dustLimit;
-    }
-    build(params) {
-        const { utxos, outputs, changeAddress, feeRate } = params;
-        if (!utxos || utxos.length === 0)
-            throw new Error('No UTXOs');
-        if (!outputs || outputs.length === 0)
-            throw new Error('No outputs');
-        // Sort UTXOs ascending by value for simple greedy selection
-        const sorted = [...utxos].sort((a, b) => a.value - b.value);
-        // Start with smallest set to cover target + estimated fee; refine iteratively
-        const targetValue = outputs.reduce((s, o) => s + o.value, 0);
-        let selected = [];
-        let total = 0;
-        const pick = () => {
-            selected = [];
-            total = 0;
-            for (const u of sorted) {
-                selected.push(u);
-                total += u.value;
-                const vbytes = estimateVBytes(selected.length, outputs.length + 1); // +1 potential change
-                const fee = Math.ceil(vbytes * feeRate);
-                if (total >= targetValue + fee)
-                    break;
-            }
-            if (total < targetValue)
-                throw new Error('Insufficient funds');
-        };
-        pick();
-        const initialVBytes = estimateVBytes(selected.length, outputs.length + 1);
-        let fee = Math.ceil(initialVBytes * feeRate);
-        let change = total - targetValue - fee;
-        let includeChange = change >= this.dustLimit;
-        // Re-estimate once we know whether change is included
-        const finalVBytes = estimateVBytes(selected.length, outputs.length + (includeChange ? 1 : 0));
-        fee = Math.ceil(finalVBytes * feeRate);
-        change = total - targetValue - fee;
-        includeChange = change >= this.dustLimit;
-        let changeOutput;
-        if (!includeChange) {
-            // Add dust to fee
-            fee = total - targetValue;
-        }
-        else {
-            changeOutput = { address: changeAddress, value: change };
-        }
-        // Construct a minimal PSBT-like payload for dry-run/testing. We intentionally avoid
-        // bringing heavy bitcoin libraries here; this builder focuses on deterministic
-        // selection, fee estimation, and change handling.
-        const payload = {
-            version: 0,
-            inputs: selected.map(u => ({ txid: u.txid, vout: u.vout })),
-            outputs: [
-                ...outputs.map(o => ({ address: o.address, value: o.value })),
-                ...(changeOutput ? [changeOutput] : [])
-            ],
-            fee
-        };
-        // Base64 encode via Node when available; fallback to btoa if present
-        const json = JSON.stringify(payload);
-        let psbtBase64;
-        try {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const B = global.Buffer;
-            psbtBase64 = B ? B.from(json, 'utf8').toString('base64') : global.btoa(json);
-        }
-        catch {
-            psbtBase64 = `psbt:${json}`;
-        }
-        return { psbtBase64, selectedUtxos: selected, fee, changeOutput };
-    }
-}

package/dist/bitcoin/fee-calculation.d.ts

@@ -1,14 +0,0 @@
-/**
- * Bitcoin Transaction Fee Calculation
- *
- * Utilities for calculating transaction fees based on size and fee rate.
- * Ported from legacy ordinalsplus transaction infrastructure.
- */
-/**
- * Calculate transaction fee based on vbytes and fee rate, ensuring minimum relay fee.
- *
- * @param vbytes - The virtual size of the transaction.
- * @param feeRate - The desired fee rate in sats/vbyte.
- * @returns The calculated fee in satoshis (bigint).
- */
-export declare const calculateFee: (vbytes: number, feeRate: number) => bigint;

package/dist/bitcoin/fee-calculation.js

@@ -1,31 +0,0 @@
-/**
- * Bitcoin Transaction Fee Calculation
- *
- * Utilities for calculating transaction fees based on size and fee rate.
- * Ported from legacy ordinalsplus transaction infrastructure.
- */
-// Define minimum relay fee rate (sats/vB)
-// Increased slightly from Bitcoin Core default of 1.0 for safety
-const MIN_RELAY_FEE_RATE = 1.1;
-/**
- * Calculate transaction fee based on vbytes and fee rate, ensuring minimum relay fee.
- *
- * @param vbytes - The virtual size of the transaction.
- * @param feeRate - The desired fee rate in sats/vbyte.
- * @returns The calculated fee in satoshis (bigint).
- */
-export const calculateFee = (vbytes, feeRate) => {
-    // Ensure inputs are valid numbers
-    if (isNaN(vbytes) || vbytes <= 0 || isNaN(feeRate) || feeRate <= 0) {
-        console.warn(`[calculateFee] Invalid input: vbytes=${vbytes}, feeRate=${feeRate}. Returning 0.`);
-        return 0n;
-    }
-    // Calculate fee based on the desired fee rate
-    const calculatedFee = Math.ceil(vbytes * feeRate);
-    // Calculate the minimum fee required for relay
-    const minimumFee = Math.ceil(vbytes * MIN_RELAY_FEE_RATE);
-    // Return the higher of the calculated fee or minimum relay fee
-    // Ensure the result is a positive integer (minimum 1 sat)
-    const finalFee = BigInt(Math.max(1, calculatedFee, minimumFee));
-    return finalFee;
-};

package/dist/bitcoin/providers/OrdNodeProvider.d.ts

@@ -1,38 +0,0 @@
-import type { ResourceProvider, LinkedResource, ResourceInfo, Inscription, ResourceCrawlOptions } from './types';
-export interface OrdNodeProviderOptions {
-    nodeUrl: string;
-    timeout?: number;
-    network?: 'mainnet' | 'testnet' | 'signet';
-}
-export declare class OrdNodeProvider implements ResourceProvider {
-    private readonly nodeUrl;
-    private readonly timeout;
-    private readonly network;
-    constructor(options: OrdNodeProviderOptions);
-    resolve(resourceId: string): Promise<LinkedResource>;
-    resolveInscription(inscriptionId: string): Promise<Inscription>;
-    resolveInfo(resourceId: string): Promise<ResourceInfo>;
-    resolveCollection(did: string, _options?: {
-        type?: string;
-        limit?: number;
-        offset?: number;
-    }): Promise<LinkedResource[]>;
-    getSatInfo(_satNumber: string): Promise<{
-        inscription_ids: string[];
-    }>;
-    getMetadata(_inscriptionId: string): Promise<any>;
-    getAllResources(_options?: ResourceCrawlOptions): AsyncGenerator<LinkedResource[]>;
-    getAllResourcesChronological(_options?: ResourceCrawlOptions): AsyncGenerator<LinkedResource[]>;
-    getInscriptionLocationsByAddress(_address: string): Promise<{
-        id: string;
-        location: string;
-    }[]>;
-    getInscriptionByNumber(_inscriptionNumber: number): Promise<Inscription>;
-    getAddressOutputs(_address: string): Promise<string[]>;
-    getOutputDetails(_outpoint: string): Promise<{
-        value: number;
-        script_pubkey: string;
-        spent: boolean;
-        inscriptions: string[];
-    }>;
-}

package/dist/bitcoin/providers/OrdNodeProvider.js

@@ -1,67 +0,0 @@
-export class OrdNodeProvider {
-    constructor(options) {
-        this.nodeUrl = options.nodeUrl;
-        this.timeout = options.timeout || 5000;
-        this.network = options.network || 'mainnet';
-    }
-    async resolve(resourceId) {
-        return {
-            id: resourceId,
-            type: 'Unknown',
-            contentType: 'application/octet-stream',
-            content_url: `${this.nodeUrl}/content/${resourceId}`
-        };
-    }
-    async resolveInscription(inscriptionId) {
-        return {
-            id: inscriptionId,
-            sat: 0,
-            content_type: 'text/plain',
-            content_url: `${this.nodeUrl}/content/${inscriptionId}`
-        };
-    }
-    async resolveInfo(resourceId) {
-        return {
-            id: resourceId,
-            type: 'Unknown',
-            contentType: 'application/octet-stream',
-            createdAt: new Date().toISOString(),
-            updatedAt: new Date().toISOString(),
-            content_url: `${this.nodeUrl}/content/${resourceId}`
-        };
-    }
-    async resolveCollection(did, _options = {}) {
-        return [];
-    }
-    async getSatInfo(_satNumber) {
-        return { inscription_ids: [] };
-    }
-    async getMetadata(_inscriptionId) {
-        return null;
-    }
-    async *getAllResources(_options = {}) {
-        // no-op generator yields nothing
-        return;
-    }
-    async *getAllResourcesChronological(_options = {}) {
-        // no-op generator yields nothing
-        return;
-    }
-    async getInscriptionLocationsByAddress(_address) {
-        return [];
-    }
-    async getInscriptionByNumber(_inscriptionNumber) {
-        return {
-            id: '0',
-            sat: 0,
-            content_type: 'text/plain',
-            content_url: `${this.nodeUrl}/content/0`
-        };
-    }
-    async getAddressOutputs(_address) {
-        return [];
-    }
-    async getOutputDetails(_outpoint) {
-        return { value: 0, script_pubkey: '', spent: false, inscriptions: [] };
-    }
-}

package/dist/bitcoin/providers/OrdinalsProvider.d.ts

@@ -1,33 +0,0 @@
-import { OrdinalsClient } from '../OrdinalsClient';
-export interface OrdinalsProvider {
-    getSatInfo(satNumber: string): Promise<{
-        inscription_ids: string[];
-    }>;
-    resolveInscription(inscriptionId: string): Promise<{
-        id: string;
-        sat: number;
-        content_type: string;
-        content_url: string;
-    }>;
-    getMetadata(inscriptionId: string): Promise<any>;
-    estimateFee(blocks?: number): Promise<number>;
-}
-export declare class OrdinalsClientProvider implements OrdinalsProvider {
-    private client;
-    private options?;
-    constructor(client: OrdinalsClient, options?: {
-        retries?: number;
-        baseUrl?: string;
-    } | undefined);
-    getSatInfo(satNumber: string): Promise<{
-        inscription_ids: string[];
-    }>;
-    resolveInscription(inscriptionId: string): Promise<{
-        id: string;
-        sat: number;
-        content_type: string;
-        content_url: string;
-    }>;
-    getMetadata(inscriptionId: string): Promise<any>;
-    estimateFee(blocks?: number): Promise<number>;
-}

package/dist/bitcoin/providers/OrdinalsProvider.js

@@ -1,50 +0,0 @@
-import { withRetry } from '../../utils/retry';
-export class OrdinalsClientProvider {
-    constructor(client, options) {
-        this.client = client;
-        this.options = options;
-    }
-    async getSatInfo(satNumber) {
-        return withRetry(() => this.client.getSatInfo(satNumber), {
-            maxRetries: this.options?.retries ?? 2,
-            isRetriable: () => true
-        });
-    }
-    async resolveInscription(inscriptionId) {
-        return withRetry(async () => {
-            const res = await this.client.getInscriptionById(inscriptionId);
-            if (!res)
-                throw new Error('Inscription not found');
-            if (!res.satoshi)
-                throw new Error('Inscription missing satoshi');
-            const sat = Number(String(res.satoshi));
-            if (Number.isNaN(sat))
-                throw new Error('Invalid satoshi value');
-            if (!res.contentType)
-                throw new Error('Inscription missing contentType');
-            const base = (this.options?.baseUrl || '').replace(/\/$/, '');
-            if (!base)
-                throw new Error('baseUrl is required to construct content_url');
-            const id = res.inscriptionId;
-            const content_url = `${base}/content/${id}`;
-            return {
-                id,
-                sat,
-                content_type: res.contentType,
-                content_url
-            };
-        }, { maxRetries: this.options?.retries ?? 2, isRetriable: () => true });
-    }
-    async getMetadata(inscriptionId) {
-        return withRetry(() => this.client.getMetadata(inscriptionId), {
-            maxRetries: this.options?.retries ?? 2,
-            isRetriable: () => true
-        });
-    }
-    async estimateFee(blocks) {
-        return withRetry(() => this.client.estimateFee(blocks), {
-            maxRetries: this.options?.retries ?? 2,
-            isRetriable: () => true
-        });
-    }
-}

package/dist/bitcoin/providers/types.d.ts

@@ -1,63 +0,0 @@
-export interface LinkedResource {
-    id: string;
-    type: string;
-    contentType: string;
-    content_url: string;
-}
-export interface Inscription {
-    id: string;
-    sat: number;
-    content_type: string;
-    content_url: string;
-    number?: number;
-    height?: number;
-    timestamp?: number;
-}
-export interface ResourceInfo {
-    id: string;
-    type: string;
-    contentType: string;
-    createdAt?: string;
-    updatedAt?: string;
-    content_url: string;
-}
-export interface ResourceProvider {
-    resolve(resourceId: string): Promise<LinkedResource>;
-    resolveInscription(inscriptionId: string): Promise<Inscription>;
-    resolveInfo(resourceId: string): Promise<ResourceInfo>;
-    resolveCollection(did: string, options: {
-        type?: string;
-        limit?: number;
-        offset?: number;
-    }): Promise<LinkedResource[]>;
-    getSatInfo(satNumber: string): Promise<{
-        inscription_ids: string[];
-    }>;
-    getMetadata(inscriptionId: string): Promise<any>;
-    getAllResources(options?: ResourceCrawlOptions): AsyncGenerator<LinkedResource[]>;
-    getAllResourcesChronological(options?: ResourceCrawlOptions): AsyncGenerator<LinkedResource[]>;
-    getInscriptionLocationsByAddress(address: string): Promise<InscriptionRefWithLocation[]>;
-    getInscriptionByNumber(inscriptionNumber: number): Promise<Inscription>;
-    getAddressOutputs(address: string): Promise<string[]>;
-    getOutputDetails(outpoint: string): Promise<{
-        value: number;
-        script_pubkey: string;
-        spent: boolean;
-        inscriptions: string[];
-    }>;
-}
-export interface ResourceCrawlOptions {
-    batchSize?: number;
-    startFrom?: number;
-    maxResources?: number;
-    filter?: (resource: LinkedResource) => boolean;
-}
-export interface ResourceBatch {
-    resources: LinkedResource[];
-    nextCursor?: number;
-    hasMore: boolean;
-}
-export interface InscriptionRefWithLocation {
-    id: string;
-    location: string;
-}

package/dist/bitcoin/providers/types.js

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

package/dist/bitcoin/transactions/commit.d.ts

@@ -1,89 +0,0 @@
-/**
- * Commit Transaction Processing for Ordinals
- *
- * This module implements the commit transaction process for ordinals inscriptions.
- * It handles the generation of the commit address and preparation of the commit transaction.
- *
- * Ported from legacy ordinalsplus transaction infrastructure.
- */
-import * as btc from '@scure/btc-signer';
-import { Utxo } from '../../types/bitcoin.js';
-/**
- * Bitcoin network type for @scure/btc-signer
- */
-type BitcoinNetwork = 'mainnet' | 'testnet' | 'regtest' | 'signet';
-/**
- * Parameters for creating a commit transaction
- */
-export interface CommitTransactionParams {
-    /** Inscription content as Buffer */
-    content: Buffer;
-    /** MIME type of the content (e.g., 'text/plain', 'image/png') */
-    contentType: string;
-    /** Available UTXOs to fund the transaction */
-    utxos: Utxo[];
-    /** Address to send change back to */
-    changeAddress: string;
-    /** Fee rate in sats/vB */
-    feeRate: number;
-    /** Bitcoin network configuration */
-    network: BitcoinNetwork;
-    /** Optional minimum amount for the commit output */
-    minimumCommitAmount?: number;
-    /** Optional metadata for the inscription */
-    metadata?: Record<string, unknown>;
-    /** Optional pointer to target specific satoshi */
-    pointer?: number;
-}
-/**
- * Result of the commit transaction creation
- */
-export interface CommitTransactionResult {
-    /** P2TR address for the commit output */
-    commitAddress: string;
-    /** Base64-encoded PSBT for the commit transaction */
-    commitPsbtBase64: string;
-    /** Raw PSBT object for commit transaction (for direct manipulation) */
-    commitPsbt: btc.Transaction;
-    /** The exact amount sent to the commit output */
-    commitAmount: number;
-    /** Selected UTXOs for the transaction */
-    selectedUtxos: Utxo[];
-    /** Fee information */
-    fees: {
-        /** Fee for the commit transaction in satoshis */
-        commit: number;
-    };
-    /** Reveal private key (hex string) - needed for reveal transaction */
-    revealPrivateKey: string;
-    /** Reveal public key (hex string) */
-    revealPublicKey: string;
-    /** Inscription script for reveal transaction */
-    inscriptionScript: {
-        script: Uint8Array;
-        controlBlock: Uint8Array;
-        leafVersion: number;
-    };
-}
-/**
- * Creates a commit transaction for an ordinals inscription
- *
- * This function:
- * 1. Validates and filters UTXOs to ensure they are spendable
- * 2. Creates an inscription with the provided content
- * 3. Generates a reveal keypair and script
- * 4. Creates a P2TR commit address
- * 5. Selects UTXOs to fund the transaction (with iterative reselection if needed)
- * 6. Builds a PSBT with commit output and change
- *
- * The function ensures that:
- * - All selected UTXOs have valid scriptPubKey fields
- * - Total input value always covers output value + fees
- * - UTXO selection is re-run if fee increases after accurate calculation
- *
- * @param params - Parameters for the commit transaction
- * @returns Complete information for the prepared commit transaction
- * @throws Error if no valid UTXOs are available or insufficient funds
- */
-export declare function createCommitTransaction(params: CommitTransactionParams): Promise<CommitTransactionResult>;
-export {};