@originals/sdk 1.4.2 → 1.4.3

package/tests/unit/bitcoin/OrdinalsClient.test.ts

@@ -1,381 +0,0 @@
-import { describe, test, expect, beforeEach, afterEach, spyOn, mock } from 'bun:test';
-import { OrdinalsClient } from '../../../src/bitcoin/OrdinalsClient';
-import { encode as cborEncode } from '../../../src/utils/cbor';
-
-const client = new OrdinalsClient('http://localhost:3000', 'regtest');
-
-describe('OrdinalsClient (real HTTP behavior with mocked fetch)', () => {
-  const json = (data: any, ok = true) => ({ ok, json: async () => data });
-  const text = (data: string, ok = true, status?: number) => ({ ok, status: status ?? (ok ? 200 : 500), text: async () => data });
-  const bin = (bytes: Uint8Array, ok = true) => ({ ok, arrayBuffer: async () => bytes.buffer });
-
-  beforeEach(() => {
-    spyOn(global, 'fetch' as any).mockImplementation(async (input: any) => {
-      const url = String(input);
-      // sat info
-      if (url.endsWith('/sat/123')) {
-        return json({ data: { inscription_ids: ['insc-123', 'insc-456'] } });
-      }
-      if (url.endsWith('/sat/direct')) {
-        return json({ inscription_ids: [] });
-      }
-      if (url.endsWith('/sat/nonarray')) {
-        return json({ data: { inscription_ids: 'oops' } });
-      }
-      if (url.endsWith('/sat/0')) {
-        return { ok: false, json: async () => ({}) } as any; // triggers empty path
-      }
-
-      // inscription info
-      if (url.endsWith('/inscription/insc-777')) {
-        return json({
-          data: {
-            inscription_id: 'insc-777',
-            content_type: 'text/plain',
-            content_url: 'http://localhost:3000/content/insc-777',
-            sat: 777,
-            owner_output: 'tx777:1',
-            block_height: 1234
-          }
-        });
-      }
-      if (url.endsWith('/inscription/insc-404')) {
-        return { ok: false, json: async () => ({}) } as any;
-      }
-      if (url.endsWith('/inscription/insc-123')) {
-        return json({
-          data: {
-            inscription_id: 'insc-123',
-            content_type: 'text/plain',
-            content_url: 'http://localhost:3000/content/insc-123',
-            sat: 123,
-            owner_output: 'tx123:0'
-          }
-        });
-      }
-      if (url.endsWith('/inscription/insc-456')) {
-        return json({
-          data: {
-            inscription_id: 'insc-456',
-            content_type: 'text/plain',
-            content_url: 'http://localhost:3000/content/insc-456',
-            sat: 456,
-            owner_output: 'tx456:0'
-          }
-        });
-      }
-      if (url.endsWith('/inscription/insc-888')) {
-        return json({
-          data: {
-            inscription_id: 'insc-888',
-            content_type: 'text/plain',
-            content_url: 'http://localhost:3000/content/insc-888',
-            sat: 888,
-            owner_output: 'tx888:2'
-          }
-        });
-      }
-      if (url.endsWith('/inscription/insc-nosat')) {
-        return json({
-          data: {
-            // missing sat on purpose
-            inscription_id: 'insc-nosat',
-            content_type: 'text/plain',
-            content_url: 'http://localhost:3000/content/insc-nosat',
-            owner_output: 'txns:0'
-          }
-        });
-      }
-      if (url.endsWith('/inscription/insc-no-id')) {
-        return json({
-          data: {
-            // missing inscription_id to trigger identifier fallback
-            content_type: 'text/plain',
-            content_url: 'http://localhost:3000/content/insc-no-id',
-            sat: 55,
-            owner_output: 'txnid:0'
-          }
-        });
-      }
-      if (url.endsWith('/inscription/insc-fail-content')) {
-        return json({
-          data: {
-            inscription_id: 'insc-fail-content',
-            content_type: 'text/plain',
-            content_url: 'http://localhost:3000/content/insc-fail-content',
-            sat: 1,
-            owner_output: 'badformat' // no colon
-          }
-        });
-      }
-      if (url.endsWith('/inscription/insc-no-content-url')) {
-        return json({
-          data: {
-            inscription_id: 'insc-no-content-url',
-            content_type: 'text/plain',
-            sat: 2
-          }
-        });
-      }
-      if (url.endsWith('/inscription/insc-no-content-type')) {
-        return json({
-          data: {
-            inscription_id: 'insc-no-content-type',
-            // content_type omitted to trigger default path
-            content_url: 'http://localhost:3000/content/insc-no-content-type',
-            sat: 3,
-            owner_output: 'txnct:0'
-          }
-        });
-      }
-      // metadata endpoints (hex-encoded CBOR)
-      if (url.endsWith('/r/metadata/insc-metadata-object')) {
-        const obj = { id: 'insc-metadata-object', test: true };
-        const hex = Buffer.from(cborEncode(obj)).toString('hex');
-        return text(hex);
-      }
-      if (url.endsWith('/r/metadata/insc-metadata-hex')) {
-        const obj = { id: 'insc-metadata-hex', ok: 1 };
-        const hex = Buffer.from(cborEncode(obj)).toString('hex');
-        return text(hex);
-      }
-      if (url.endsWith('/r/metadata/insc-metadata-hex0x')) {
-        const obj = { id: 'insc-metadata-hex0x', ok: true };
-        const hex = '0x' + Buffer.from(cborEncode(obj)).toString('hex');
-        return text(hex);
-      }
-      if (url.endsWith('/r/metadata/insc-hex-invalid')) {
-        return text('zz');
-      }
-      if (url.endsWith('/r/metadata/insc-hex-odd')) {
-        return text('f');
-      }
-      if (url.endsWith('/r/metadata/insc-m-noinfo')) {
-        return text('', false, 404) as any;
-      }
-      if (url.endsWith('/r/metadata/insc-cbor-fetch-fail')) {
-        return text('', false, 500) as any;
-      }
-
-      // content bytes
-      if (url.endsWith('/content/insc-777')) {
-        return bin(new Uint8Array([1, 2, 3]));
-      }
-      if (url.endsWith('/content/insc-888')) {
-        return bin(new Uint8Array([4, 5]));
-      }
-      if (url.endsWith('/content/insc-123')) {
-        return bin(new Uint8Array([10]));
-      }
-      if (url.endsWith('/content/insc-456')) {
-        return bin(new Uint8Array([11]));
-      }
-      if (url.endsWith('/content/insc-nosat')) {
-        return bin(new Uint8Array([12]));
-      }
-      if (url.endsWith('/content/insc-no-id')) {
-        return bin(new Uint8Array([13]));
-      }
-      if (url.endsWith('/content/insc-fail-content')) {
-        return { ok: false, arrayBuffer: async () => new ArrayBuffer(0) } as any;
-      }
-      if (url.endsWith('/content/insc-no-content-url')) {
-        return bin(new Uint8Array([7, 7]));
-      }
-      if (url.endsWith('/content/insc-no-content-type')) {
-        return bin(new Uint8Array([8, 8]));
-      }
-      if (url.endsWith('/content/insc-metadata-object')) {
-        return bin(new Uint8Array([0]));
-      }
-      if (url.endsWith('/content/insc-metadata-hex')) {
-        return bin(new Uint8Array([9]));
-      }
-      if (url.endsWith('/content/insc-metadata-cbor-content')) {
-        const obj = { fromContent: true };
-        return bin(cborEncode(obj));
-      }
-      if (url.endsWith('/content/insc-hex-invalid')) {
-        const obj = { fromContentFallback: true };
-        return bin(cborEncode(obj));
-      }
-      if (url.endsWith('/content/insc-hex-odd')) {
-        // not used since content_type is text/plain; but provide ok anyway
-        return bin(new Uint8Array([1]));
-      }
-      if (url.endsWith('/content/insc-cbor-fetch-fail')) {
-        return { ok: false, arrayBuffer: async () => new ArrayBuffer(0) } as any;
-      }
-      if (url.endsWith('/content/insc-cbor-no-content-url')) {
-        const obj = { fromContentFallbackRpcUrl: true };
-        return bin(cborEncode(obj));
-      }
-
-      return json({}, false) as any;
-    });
-  });
-
-  afterEach(() => {
-    (global.fetch as any).mockRestore?.();
-  });
-
-  test('getInscriptionById returns inscription via HTTP', async () => {
-    const insc = await client.getInscriptionById('insc-777');
-    expect(insc).toEqual(
-      expect.objectContaining({ inscriptionId: 'insc-777', contentType: 'text/plain', txid: 'tx777', vout: 1 })
-    );
-  });
-
-  test('getInscriptionById returns null on 404 info', async () => {
-    const insc = await client.getInscriptionById('insc-404');
-    expect(insc).toBeNull();
-  });
-
-  test('getInscriptionById returns null for empty id', async () => {
-    const insc = await client.getInscriptionById('');
-    expect(insc).toBeNull();
-  });
-
-  test('getInscriptionsBySatoshi fetches ids then resolves each', async () => {
-    const list = await client.getInscriptionsBySatoshi('123');
-    expect(list.length).toBe(2);
-    expect(list[0].inscriptionId).toBe('insc-123');
-  });
-
-  test('getInscriptionsBySatoshi returns empty when sat has no inscriptions', async () => {
-    const list = await client.getInscriptionsBySatoshi('0');
-    expect(list).toEqual([]);
-  });
-
-  test('broadcastTransaction returns txid (still a thin wrapper)', async () => {
-    await expect(client.broadcastTransaction({ txid: 't', vin: [], vout: [], fee: 0 })).resolves.toEqual('t');
-  });
-
-  test('broadcastTransaction falls back when txid missing', async () => {
-    // @ts-ignore
-    await expect(client.broadcastTransaction({ vin: [], vout: [], fee: 0 })).resolves.toEqual('txid');
-  });
-
-  test('getTransactionStatus returns status (placeholder)', async () => {
-    const status = await client.getTransactionStatus('txid');
-    expect(status.confirmed).toBeDefined();
-  });
-
-  test('estimateFee returns a number and clamps floor', async () => {
-    await expect(client.estimateFee(1)).resolves.toEqual(expect.any(Number));
-    await expect(client.estimateFee()).resolves.toEqual(expect.any(Number));
-    await expect(client.estimateFee(0)).resolves.toBeGreaterThanOrEqual(10);
-  });
-
-  test('getSatInfo returns ids when available and empty on 404', async () => {
-    const info = await client.getSatInfo('123');
-    expect(info.inscription_ids).toEqual(['insc-123', 'insc-456']);
-    const empty = await client.getSatInfo('0');
-    expect(empty.inscription_ids).toEqual([]);
-    const direct = await client.getSatInfo('direct');
-    expect(direct.inscription_ids).toEqual([]);
-    const nonarray = await client.getSatInfo('nonarray');
-    expect(nonarray.inscription_ids).toEqual([]);
-  });
-
-  test('resolveInscription returns mapped inscription with content bytes', async () => {
-    const insc = await client.resolveInscription('insc-888');
-    expect(insc).toEqual(expect.objectContaining({ inscriptionId: 'insc-888', txid: 'tx888', vout: 2 }));
-    expect(insc!.content).toBeInstanceOf(Buffer);
-    expect(insc!.content.length).toBe(2);
-  });
-
-  test('resolveInscription handles missing colon in owner_output and failed content fetch', async () => {
-    await expect(client.resolveInscription('insc-fail-content')).rejects.toThrow('Failed to fetch inscription content');
-  });
-
-  test('resolveInscription falls back to default content url when not provided', async () => {
-    const insc = await client.resolveInscription('insc-no-content-url');
-    expect(insc).toEqual(expect.objectContaining({ inscriptionId: 'insc-no-content-url' }));
-    expect(insc!.content.length).toBe(2);
-  });
-
-  test('resolveInscription defaults contentType when missing', async () => {
-    const insc = await client.resolveInscription('insc-no-content-type');
-    expect(insc!.contentType).toBe('application/octet-stream');
-    expect(insc!.content.length).toBe(2);
-  });
-
-  test('resolveInscription stringifies missing sat and falls back id when missing', async () => {
-    const missingSat = await client.resolveInscription('insc-nosat');
-    expect(missingSat!.satoshi).toBe('');
-    const missingId = await client.resolveInscription('insc-no-id');
-    expect(missingId!.inscriptionId).toBe('insc-no-id');
-  });
-
-  test('getMetadata prefers metadata object from API', async () => {
-    const meta = await client.getMetadata('insc-metadata-object');
-    expect(meta).toEqual(expect.objectContaining({ id: 'insc-metadata-object', test: true }));
-  });
-
-  test('getMetadata decodes hex CBOR when provided', async () => {
-    const meta = await client.getMetadata('insc-metadata-hex');
-    expect(meta).toEqual(expect.objectContaining({ id: 'insc-metadata-hex', ok: 1 }));
-  });
-
-  test('getMetadata decodes 0x-prefixed hex CBOR', async () => {
-    const meta = await client.getMetadata('insc-metadata-hex0x');
-    expect(meta).toEqual(expect.objectContaining({ id: 'insc-metadata-hex0x', ok: true }));
-  });
-
-  test('getMetadata returns null on invalid hex (no fallbacks)', async () => {
-    const meta = await client.getMetadata('insc-hex-invalid');
-    expect(meta).toBeNull();
-  });
-
-  test('getMetadata ignores odd-length hex and returns null for non-cbor type', async () => {
-    const meta = await client.getMetadata('insc-hex-odd');
-    expect(meta).toBeNull();
-  });
-
-  test('getMetadata content fetch fail path returns null', async () => {
-    const meta = await client.getMetadata('insc-cbor-fetch-fail');
-    expect(meta).toBeNull();
-  });
-
-  test('getMetadata returns null when info endpoint not ok', async () => {
-    const meta = await client.getMetadata('insc-m-noinfo');
-    expect(meta).toBeNull();
-  });
-
-  // getMetadata now only uses metadata endpoints; no content-based fallback
-
-  test('resolveInscription returns null for empty identifier', async () => {
-    const insc = await client.resolveInscription('');
-    expect(insc).toBeNull();
-  });
-
-  test('getMetadata returns null for empty id', async () => {
-    const meta = await client.getMetadata('');
-    expect(meta).toBeNull();
-  });
-});
-
-/** Inlined from OrdinalsClient.more.part.ts */
-
-describe('OrdinalsClient additional branches', () => {
-  const originalFetch = global.fetch as any;
-  afterEach(() => { (global as any).fetch = originalFetch; });
-
-  test('getInscriptionById returns null for falsy id', async () => {
-    const c = new OrdinalsClient('http://ord', 'mainnet');
-    const v = await c.getInscriptionById('');
-    expect(v).toBeNull();
-  });
-
-  test('getMetadata handles quoted json string and bad hex', async () => {
-    const c = new OrdinalsClient('http://ord', 'mainnet');
-    (global as any).fetch = mock(async (u: string) => {
-      if (u.endsWith('/r/metadata/ins-1')) return { ok: true, text: async () => '"not-hex"' } as any;
-      if (u.includes('/sat/')) return { ok: true, json: async () => ({ inscription_ids: [] }) } as any;
-      return { ok: true, json: async () => ({}) } as any;
-    });
-    const v = await c.getMetadata('ins-1');
-    expect(v).toBeNull();
-  });
-});

package/tests/unit/bitcoin/OrdinalsClientProvider.test.ts

@@ -1,102 +0,0 @@
-import { describe, test, expect, mock } from 'bun:test';
-import { OrdinalsClientProvider } from '../../../src/bitcoin/providers/OrdinalsProvider';
-import { OrdinalsClient } from '../../../src/bitcoin/OrdinalsClient';
-
-describe('OrdinalsClientProvider', () => {
-  const client: OrdinalsClient = new OrdinalsClient('http://ord', 'regtest') as any;
-  (client.getSatInfo as any) = mock(async (_: string) => ({ inscription_ids: ['a'] }));
-  (client.getInscriptionById as any) = mock(async (id: string) => ({ inscriptionId: id, satoshi: '1', content: Buffer.alloc(0), contentType: 'text/plain', txid: 't', vout: 0 }));
-  (client.getMetadata as any) = mock(async (_: string) => ({ ok: true } as any));
-  (client.estimateFee as any) = mock(async (_?: number) => 123);
-
-  test('getSatInfo proxies with retry', async () => {
-    const p = new OrdinalsClientProvider(client, { retries: 0, baseUrl: 'http://ord' });
-    const v = await p.getSatInfo('1');
-    expect(v.inscription_ids).toEqual(['a']);
-  });
-
-  test('getSatInfo retries once on failure to cover isRetriable', async () => {
-    (client.getSatInfo as any).mockImplementationOnce(async () => { throw new Error('fail'); });
-    const p = new OrdinalsClientProvider(client, { retries: 1, baseUrl: 'http://ord' });
-    const v = await p.getSatInfo('1');
-    expect(v.inscription_ids).toEqual(['a']);
-  });
-
-  test('resolveInscription validates fields and builds content_url', async () => {
-    const p = new OrdinalsClientProvider(client, { baseUrl: 'http://ord/' });
-    const v = await p.resolveInscription('ins-1');
-    expect(v).toEqual(expect.objectContaining({ id: 'ins-1', content_url: 'http://ord/content/ins-1', content_type: 'text/plain', sat: expect.any(Number) }));
-  });
-
-  test('resolveInscription errors when missing baseUrl', async () => {
-    const p = new OrdinalsClientProvider(client, {} as any);
-    await expect(p.resolveInscription('ins-1')).rejects.toThrow('baseUrl is required');
-  });
-
-  test('resolveInscription errors on missing fields', async () => {
-    (client.getInscriptionById as any).mockImplementationOnce(async () => ({ inscriptionId: 'id' } as any));
-    const p = new OrdinalsClientProvider(client, { baseUrl: 'http://ord', retries: 0 } as any);
-    await expect(p.resolveInscription('id')).rejects.toThrow('Inscription missing satoshi');
-  });
-
-  test('resolveInscription errors on invalid satoshi value', async () => {
-    (client.getInscriptionById as any).mockImplementationOnce(async (id: string) => ({ inscriptionId: id, satoshi: 'NaN', content: Buffer.alloc(0), contentType: 'text/plain', txid: 't', vout: 0 }));
-    const p = new OrdinalsClientProvider(client, { baseUrl: 'http://ord', retries: 0 } as any);
-    await expect(p.resolveInscription('id')).rejects.toThrow('Invalid satoshi value');
-  });
-
-  test('resolveInscription errors on missing contentType', async () => {
-    (client.getInscriptionById as any).mockImplementationOnce(async (id: string) => ({ inscriptionId: id, satoshi: '1', content: Buffer.alloc(0), txid: 't', vout: 0 }));
-    const p = new OrdinalsClientProvider(client, { baseUrl: 'http://ord', retries: 0 } as any);
-    await expect(p.resolveInscription('id')).rejects.toThrow('Inscription missing contentType');
-  });
-
-  test('getMetadata proxies with retry', async () => {
-    const p = new OrdinalsClientProvider(client, { baseUrl: 'http://ord' });
-    const v = await p.getMetadata('id');
-    expect(v).toEqual({ ok: true });
-  });
-
-  test('getMetadata retries on first failure to cover isRetriable', async () => {
-    (client.getMetadata as any).mockImplementationOnce(async () => { throw new Error('fail meta'); });
-    const p = new OrdinalsClientProvider(client, { baseUrl: 'http://ord', retries: 1 });
-    const v = await p.getMetadata('id');
-    expect(v).toEqual({ ok: true });
-  });
-
-  test('estimateFee proxies with retry', async () => {
-    const p = new OrdinalsClientProvider(client, { baseUrl: 'http://ord' });
-    const v = await p.estimateFee(2);
-    expect(v).toBe(123);
-  });
-
-  test('estimateFee retries on first failure to cover isRetriable', async () => {
-    (client.estimateFee as any).mockImplementationOnce(async () => { throw new Error('fee fail'); });
-    const p = new OrdinalsClientProvider(client, { baseUrl: 'http://ord', retries: 1 });
-    const v = await p.estimateFee(2);
-    expect(v).toBe(123);
-  });
-
-  test('retries default when options.retries not provided', async () => {
-    const p = new OrdinalsClientProvider(client as any);
-    const v = await p.getSatInfo('1');
-    expect(v.inscription_ids).toEqual(['a']);
-  });
-
-  test('resolveInscription constructs content_url from baseUrl as-is', async () => {
-    const p = new OrdinalsClientProvider(client, { baseUrl: 'http://ord//' });
-    const v = await p.resolveInscription('x');
-    expect(v.content_url).toBe('http://ord//content/x');
-  });
-})
-
-/** Inlined from OrdinalsClientProvider.more-branches.part.ts */
-
-describe('OrdinalsClientProvider extra branches', () => {
-  test('resolveInscription throws when client returns null', async () => {
-    const client: OrdinalsClient = new OrdinalsClient('http://ord', 'regtest') as any;
-    (client.getInscriptionById as any) = mock(async () => null as any);
-    const p = new OrdinalsClientProvider(client, { baseUrl: 'http://ord' });
-    await expect(p.resolveInscription('missing')).rejects.toThrow('Inscription not found');
-  });
-});

package/tests/unit/bitcoin/PSBTBuilder.test.ts

@@ -1,84 +0,0 @@
-import { describe, test, expect } from 'bun:test';
-import { PSBTBuilder } from '../../../src/bitcoin/PSBTBuilder';
-
-describe('PSBTBuilder', () => {
-  const utxo = (txid: string, vout: number, value: number) => ({ txid, vout, value });
-
-  test('throws on no UTXOs', () => {
-    const b = new PSBTBuilder();
-    expect(() => b.build({ utxos: [], outputs: [{ address: 'addr', value: 1_000 }], changeAddress: 'change', feeRate: 1, network: 'regtest' })).toThrow('No UTXOs');
-  });
-
-  test('throws on no outputs', () => {
-    const b = new PSBTBuilder();
-    expect(() => b.build({ utxos: [utxo('t', 0, 1000)], outputs: [], changeAddress: 'change', feeRate: 1, network: 'regtest' })).toThrow('No outputs');
-  });
-
-  test('throws on insufficient funds', () => {
-    const b = new PSBTBuilder();
-    expect(() => b.build({
-      utxos: [utxo('a', 0, 500)],
-      outputs: [{ address: 'to', value: 600 }],
-      changeAddress: 'change',
-      feeRate: 1,
-      network: 'regtest'
-    })).toThrow('Insufficient funds');
-  });
-
-  test('includes change when change >= dust', () => {
-    const b = new PSBTBuilder();
-    const res = b.build({
-      utxos: [
-        // Intentionally unsorted to exercise comparator function
-        utxo('b', 1, 2_000),
-        utxo('a', 0, 10_000)
-      ],
-      outputs: [{ address: 'to', value: 1_000 }],
-      changeAddress: 'change',
-      feeRate: 1,
-      network: 'regtest'
-    });
-    expect(res.selectedUtxos.length).toBe(1);
-    expect(res.changeOutput).toBeDefined();
-    expect(res.fee).toBeGreaterThan(0);
-    // decode psbt-like payload for sanity
-    const json = Buffer.from(res.psbtBase64, 'base64').toString('utf8');
-    const payload = JSON.parse(json);
-    expect(payload.outputs.some((o: any) => o.address === 'change')).toBe(true);
-  });
-
-  test('adds dust to fee when change < dust', () => {
-    const b = new PSBTBuilder();
-    const res = b.build({
-      utxos: [utxo('a', 0, 700)],
-      outputs: [{ address: 'to', value: 600 }],
-      changeAddress: 'change',
-      feeRate: 1,
-      network: 'regtest'
-    });
-    expect(res.changeOutput).toBeUndefined();
-    expect(res.fee).toBe(100);
-  });
-
-  test('falls back when Buffer/btoa not available', () => {
-    const b = new PSBTBuilder();
-    const originalBuffer = (global as any).Buffer;
-    const originalBtoa = (global as any).btoa;
-    (global as any).Buffer = undefined;
-    (global as any).btoa = undefined;
-    try {
-      const res = b.build({
-        utxos: [utxo('a', 0, 10_000)],
-        outputs: [{ address: 'to', value: 1_000 }],
-        changeAddress: 'change',
-        feeRate: 1,
-        network: 'regtest'
-      });
-      expect(res.psbtBase64.startsWith('psbt:')).toBe(true);
-    } finally {
-      (global as any).Buffer = originalBuffer;
-      (global as any).btoa = originalBtoa;
-    }
-  });
-});
-