@originals/sdk 1.2.0 → 1.4.3

package/dist/bitcoin/BitcoinManager.js

@@ -1,262 +0,0 @@
-import { DUST_LIMIT_SATS } from '../types';
-import { emitTelemetry, StructuredError } from '../utils/telemetry';
-import { validateBitcoinAddress } from '../utils/bitcoin-address';
-import { validateSatoshiNumber } from '../utils/satoshi-validation';
-export class BitcoinManager {
-    constructor(config) {
-        this.config = config;
-        this.feeOracle = config.feeOracle;
-        this.ord = config.ordinalsProvider;
-    }
-    async resolveFeeRate(targetBlocks = 1, provided) {
-        // 1) Prefer external fee oracle
-        if (this.feeOracle) {
-            try {
-                const estimated = await this.feeOracle.estimateFeeRate(targetBlocks);
-                if (typeof estimated === 'number' && Number.isFinite(estimated) && estimated > 0) {
-                    emitTelemetry(this.config.telemetry, {
-                        name: 'bitcoin.fee.estimated',
-                        attributes: { feeRate: estimated, source: 'feeOracle' }
-                    });
-                    return estimated;
-                }
-            }
-            catch (error) {
-                emitTelemetry(this.config.telemetry, {
-                    name: 'bitcoin.fee.error',
-                    level: 'warn',
-                    attributes: { error: String(error), source: 'feeOracle' }
-                });
-            }
-        }
-        // 2) Fallback to ordinals provider if present
-        if (this.ord) {
-            try {
-                const estimated = await this.ord.estimateFee(targetBlocks);
-                if (typeof estimated === 'number' && Number.isFinite(estimated) && estimated > 0) {
-                    emitTelemetry(this.config.telemetry, {
-                        name: 'bitcoin.fee.estimated',
-                        attributes: { feeRate: estimated, source: 'ordinalsProvider' }
-                    });
-                    return estimated;
-                }
-            }
-            catch (error) {
-                emitTelemetry(this.config.telemetry, {
-                    name: 'bitcoin.fee.error',
-                    level: 'warn',
-                    attributes: { error: String(error), source: 'ordinalsProvider' }
-                });
-            }
-        }
-        // 3) If caller provided a valid non-zero fee rate, use it as last resort
-        if (typeof provided === 'number' && Number.isFinite(provided) && provided > 0) {
-            return provided;
-        }
-        return undefined;
-    }
-    async inscribeData(data, contentType, feeRate) {
-        // Input validation
-        if (!data) {
-            throw new StructuredError('INVALID_INPUT', 'Data to inscribe cannot be null or undefined');
-        }
-        if (!contentType || typeof contentType !== 'string') {
-            throw new StructuredError('INVALID_INPUT', 'Content type must be a non-empty string');
-        }
-        // Validate contentType is a valid MIME type
-        if (!/^[a-zA-Z0-9][a-zA-Z0-9!#$&^_.+-]{0,126}\/[a-zA-Z0-9][a-zA-Z0-9!#$&^_.+-]{0,126}$/.test(contentType)) {
-            throw new StructuredError('INVALID_INPUT', `Invalid MIME type format: ${contentType}`);
-        }
-        if (feeRate !== undefined && (typeof feeRate !== 'number' || feeRate <= 0 || !Number.isFinite(feeRate))) {
-            throw new StructuredError('INVALID_INPUT', 'Fee rate must be a positive number');
-        }
-        // Security: Reject extremely high fee rates to prevent accidental fund drainage
-        const MAX_REASONABLE_FEE_RATE = 10000; // sat/vB
-        if (feeRate !== undefined && feeRate > MAX_REASONABLE_FEE_RATE) {
-            throw new StructuredError('INVALID_INPUT', `Fee rate ${feeRate} exceeds maximum reasonable fee rate of ${MAX_REASONABLE_FEE_RATE} sat/vB`);
-        }
-        const effectiveFeeRate = await this.resolveFeeRate(1, feeRate);
-        if (!this.ord) {
-            throw new StructuredError('ORD_PROVIDER_REQUIRED', 'Ordinals provider must be configured to inscribe data on Bitcoin. ' +
-                'Please provide an ordinalsProvider in your SDK configuration. ' +
-                'For testing, use: import { OrdMockProvider } from \'@originals/sdk\';');
-        }
-        if (typeof this.ord.createInscription !== 'function') {
-            throw new StructuredError('ORD_PROVIDER_UNSUPPORTED', 'Configured ordinals provider does not support inscription creation');
-        }
-        const creation = await this.ord.createInscription({ data, contentType, feeRate: effectiveFeeRate });
-        const txid = creation.txid ?? creation.revealTxId;
-        if (!creation.inscriptionId || !txid) {
-            throw new StructuredError('ORD_PROVIDER_INVALID_RESPONSE', 'Ordinals provider did not return a valid inscription identifier or transaction id');
-        }
-        let satoshi = creation.satoshi ?? '';
-        if (!satoshi) {
-            satoshi = (await this.getSatoshiFromInscription(creation.inscriptionId)) ?? '';
-        }
-        // Validate satoshi before using it
-        if (satoshi) {
-            const validation = validateSatoshiNumber(satoshi);
-            if (!validation.valid) {
-                throw new StructuredError('INVALID_SATOSHI', `Ordinals provider returned invalid satoshi identifier: ${validation.error}`);
-            }
-        }
-        let recordedFeeRate;
-        if (this.feeOracle) {
-            recordedFeeRate = effectiveFeeRate;
-        }
-        else if (typeof feeRate === 'number' && Number.isFinite(feeRate) && feeRate > 0) {
-            recordedFeeRate = feeRate;
-        }
-        else {
-            recordedFeeRate = creation.feeRate ?? effectiveFeeRate;
-        }
-        const inscription = {
-            satoshi,
-            inscriptionId: creation.inscriptionId,
-            content: creation.content ?? data,
-            contentType: creation.contentType ?? contentType,
-            txid,
-            vout: typeof creation.vout === 'number' ? creation.vout : 0,
-            blockHeight: creation.blockHeight,
-            revealTxId: creation.revealTxId,
-            commitTxId: creation.commitTxId,
-            feeRate: recordedFeeRate
-        };
-        return inscription;
-    }
-    async trackInscription(inscriptionId) {
-        if (this.ord) {
-            const info = await this.ord.getInscriptionById(inscriptionId);
-            if (!info)
-                return null;
-            return {
-                satoshi: info.satoshi ?? '',
-                inscriptionId: info.inscriptionId,
-                content: info.content,
-                contentType: info.contentType,
-                txid: info.txid,
-                vout: info.vout,
-                blockHeight: info.blockHeight
-            };
-        }
-        return null;
-    }
-    async transferInscription(inscription, toAddress) {
-        // Input validation
-        if (!inscription || typeof inscription !== 'object') {
-            throw new StructuredError('INVALID_INPUT', 'Inscription must be a valid OrdinalsInscription object');
-        }
-        if (!inscription.inscriptionId || typeof inscription.inscriptionId !== 'string') {
-            throw new StructuredError('INVALID_INPUT', 'Inscription must have a valid inscriptionId');
-        }
-        if (!toAddress || typeof toAddress !== 'string') {
-            throw new StructuredError('INVALID_INPUT', 'Destination address must be a non-empty string');
-        }
-        // Validate Bitcoin address format and checksum
-        try {
-            validateBitcoinAddress(toAddress, this.config.network);
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : 'Invalid Bitcoin address';
-            throw new StructuredError('INVALID_ADDRESS', message);
-        }
-        const effectiveFeeRate = await this.resolveFeeRate(1);
-        if (!this.ord) {
-            throw new StructuredError('ORD_PROVIDER_REQUIRED', 'Ordinals provider must be configured to transfer inscriptions on Bitcoin. ' +
-                'Please provide an ordinalsProvider in your SDK configuration. ' +
-                'For testing, use: import { OrdMockProvider } from \'@originals/sdk\';');
-        }
-        if (typeof this.ord.transferInscription !== 'function') {
-            throw new StructuredError('ORD_PROVIDER_UNSUPPORTED', 'Configured ordinals provider does not support inscription transfers');
-        }
-        const response = await this.ord.transferInscription(inscription.inscriptionId, toAddress, {
-            feeRate: effectiveFeeRate
-        });
-        if (!response || !response.txid) {
-            throw new StructuredError('ORD_PROVIDER_INVALID_RESPONSE', 'Ordinals provider did not return a valid transfer transaction');
-        }
-        if (response.satoshi) {
-            inscription.satoshi = response.satoshi;
-        }
-        return {
-            txid: response.txid,
-            vin: response.vin ?? [{ txid: inscription.txid, vout: inscription.vout }],
-            vout: response.vout?.length
-                ? response.vout
-                : [{ value: DUST_LIMIT_SATS, scriptPubKey: 'script', address: toAddress }],
-            fee: response.fee,
-            blockHeight: response.blockHeight,
-            confirmations: response.confirmations
-        };
-    }
-    async preventFrontRunning(satoshi) {
-        if (!satoshi)
-            throw new StructuredError('SATOSHI_REQUIRED', 'Satoshi identifier is required');
-        // Naive implementation: check for multiple inscriptions on same satoshi via provider
-        if (this.ord) {
-            const list = await this.ord.getInscriptionsBySatoshi(satoshi);
-            return list.length <= 1;
-        }
-        return true;
-    }
-    async getSatoshiFromInscription(inscriptionId) {
-        if (this.ord) {
-            const info = await this.ord.getInscriptionById(inscriptionId);
-            const satoshi = info?.satoshi;
-            // Validate satoshi before returning
-            if (satoshi) {
-                const validation = validateSatoshiNumber(satoshi);
-                if (!validation.valid) {
-                    // Return null if validation fails (don't return empty or invalid string)
-                    return null;
-                }
-                return satoshi;
-            }
-            return null;
-        }
-        return null;
-    }
-    async validateBTCODID(didId) {
-        // Validate that a did:btco DID exists on Bitcoin
-        const satoshi = this.extractSatoshiFromBTCODID(didId);
-        if (!satoshi)
-            return false;
-        // Validate the extracted satoshi number
-        const validation = validateSatoshiNumber(satoshi);
-        if (!validation.valid)
-            return false;
-        if (!this.ord)
-            return false;
-        const inscriptions = await this.ord.getInscriptionsBySatoshi(satoshi);
-        return inscriptions.length > 0;
-    }
-    extractSatoshiFromBTCODID(didId) {
-        // Extract satoshi identifier from did:btco DID
-        if (!didId.startsWith('did:btco:'))
-            return null;
-        const parts = didId.split(':');
-        let satoshi = null;
-        // Handle different network prefixes:
-        // did:btco:123456 (mainnet) - 3 parts
-        // did:btco:test:123456 or did:btco:sig:123456 - 4 parts
-        if (parts.length === 3) {
-            satoshi = parts[2];
-        }
-        else if (parts.length === 4) {
-            // Validate network prefix - only 'test' and 'sig' are allowed
-            const network = parts[2];
-            if (network !== 'test' && network !== 'sig') {
-                return null;
-            }
-            satoshi = parts[3];
-        }
-        // Validate the extracted satoshi format
-        if (satoshi) {
-            const validation = validateSatoshiNumber(satoshi);
-            if (!validation.valid) {
-                return null;
-            }
-        }
-        return satoshi;
-    }
-}

package/dist/bitcoin/BroadcastClient.d.ts

@@ -1,30 +0,0 @@
-export interface TransactionStatus {
-    confirmed: boolean;
-    confirmations?: number;
-}
-export interface Broadcaster {
-    (txHex: string): Promise<string>;
-}
-export interface StatusProvider {
-    (txid: string): Promise<TransactionStatus>;
-}
-export interface BroadcastOptions {
-    pollIntervalMs?: number;
-    maxAttempts?: number;
-}
-/**
- * Broadcast client with idempotency and confirmation polling.
- * Designed to be predictable and simple, honoring behavior expected by the
- * ordinalsplus legacy components which are finicky about retries.
- */
-export declare class BroadcastClient {
-    private readonly broadcaster;
-    private readonly statusProvider;
-    private inflight;
-    constructor(broadcaster: Broadcaster, statusProvider: StatusProvider);
-    broadcastIdempotent(txidKey: string, create: () => Promise<string>): Promise<string>;
-    broadcastAndConfirm(txHex: string, options?: BroadcastOptions): Promise<{
-        txid: string;
-        confirmations: number;
-    }>;
-}

package/dist/bitcoin/BroadcastClient.js

@@ -1,35 +0,0 @@
-/**
- * Broadcast client with idempotency and confirmation polling.
- * Designed to be predictable and simple, honoring behavior expected by the
- * ordinalsplus legacy components which are finicky about retries.
- */
-export class BroadcastClient {
-    constructor(broadcaster, statusProvider) {
-        this.broadcaster = broadcaster;
-        this.statusProvider = statusProvider;
-        this.inflight = new Map();
-    }
-    broadcastIdempotent(txidKey, create) {
-        if (this.inflight.has(txidKey))
-            return this.inflight.get(txidKey);
-        const p = (async () => create())();
-        this.inflight.set(txidKey, p);
-        return p.finally(() => this.inflight.delete(txidKey));
-    }
-    async broadcastAndConfirm(txHex, options = {}) {
-        const txid = await this.broadcastIdempotent(txHex, () => this.broadcaster(txHex));
-        const interval = Math.max(100, options.pollIntervalMs ?? 500);
-        const maxAttempts = Math.max(1, options.maxAttempts ?? 20);
-        let attempts = 0;
-        let last = { confirmed: false };
-        while (attempts < maxAttempts) {
-            last = await this.statusProvider(txid);
-            if (last.confirmed) {
-                return { txid, confirmations: last.confirmations ?? 1 };
-            }
-            await new Promise(r => setTimeout(r, interval));
-            attempts++;
-        }
-        return { txid, confirmations: last.confirmations ?? 0 };
-    }
-}

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[];
-    }>;
-}