@originals/sdk 1.1.0

package/dist/bitcoin/BitcoinManager.js

@@ -0,0 +1,262 @@
+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

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,35 @@
+/**
+ * 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

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,105 @@
+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

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,80 @@
+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

@@ -0,0 +1,14 @@
+/**
+ * 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

@@ -0,0 +1,31 @@
+/**
+ * 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

@@ -0,0 +1,38 @@
+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[];
+    }>;
+}