Add block-related endpoints

package.json

@@ -8,11 +8,16 @@
   "files": ["dist"],
   "scripts": {
     "build": "bun build ./src/index.ts --outdir ./dist --target node",
-    "test": "bun test",
+    "test": "bun test ./src/test/**/*.test.ts",
     "format": "prettier --write 'src/**/*.ts'",
     "lint": "eslint . && tsc -b",
     "prepublishOnly": "bun run build"
   },
+  "imports": {
+    "#src/*": "./src/*",
+    "#schemas/*": "./src/schemas/*",
+    "#types/*": "./src/types/*"
+  },
   "dependencies": {
     "typescript-eslint": "^8.22.0",
     "zod": "^3.24.1"

src/endpoints.ts

@@ -0,0 +1,10 @@
+export const endpoints = {
+  address: (address: string) => `/address/${address}`,
+  block: (heightOrHash: number | string) => `/block/${heightOrHash}`,
+  blockcount: '/blockcount',
+  blockhashLatest: '/blockhash',
+  blockhashByHeight: (height: number) => `/blockhash/${height}`,
+  blockheight: '/blockheight',
+  blocks: '/blocks',
+  blocktime: '/blocktime',
+} as const;

src/index.ts

@@ -1,47 +1,16 @@
 import { z } from 'zod';
+import { endpoints } from 'src/endpoints';
+import {
+  BlockSchema,
+  BlockHashSchema,
+  AddressInfoSchema,
+  BlocksResponseSchema,
+} from 'schemas';
+import type { Block, BlockHash, AddressInfo, BlocksResponse } from 'types';
 
-export const InputSchema = z.object({
-  previous_output: z.string(),
-  script_sig: z.string(),
-  sequence: z.number().int().nonnegative(),
-  witness: z.array(z.string()),
-});
-
-export const OutputSchema = z.object({
-  value: z.number().int().nonnegative(),
-  script_pubkey: z.string(),
-});
-
-export const TransactionSchema = z.object({
-  version: z.number().int().nonnegative(),
-  lock_time: z.number().int().nonnegative(),
-  input: z.array(InputSchema),
-  output: z.array(OutputSchema),
-});
-
-const isHexString = (str: string) => /^[0-9a-fA-F]+$/.test(str);
-
-export const blockHashSchema = z
-  .string()
-  .length(64, 'Block hash must be exactly 64 characters long')
-  .refine(
-    isHexString,
-    'Block hash must contain only hexadecimal characters (0-9, a-f, A-F)',
-  );
-
-export type BlockHash = z.infer<typeof blockHashSchema>;
-
-export const BlockSchema = z.object({
-  best_height: z.number().int().nonnegative(),
-  hash: blockHashSchema,
-  height: z.number().int().nonnegative(),
-  inscriptions: z.array(z.string()),
-  runes: z.array(z.string()),
-  target: z.string(),
-  transactions: z.array(TransactionSchema),
-});
-
-export type Block = z.infer<typeof BlockSchema>;
+type ApiResponse<T> =
+  | { success: true; data: T }
+  | { success: false; error: string };
 
 export class OrdClient {
   private headers: HeadersInit;
@@ -56,14 +25,65 @@ export class OrdClient {
     };
   }
 
-  async getBlock(heightOrHash: number | BlockHash): Promise<Block> {
-    const response = await fetch(`${this.baseUrl}/block/${heightOrHash}`, {
+  private async fetch<T extends z.ZodType>(
+    endpoint: string,
+    schema: T,
+  ): Promise<z.infer<T>> {
+    const response = await fetch(`${this.baseUrl}${endpoint}`, {
       headers: this.headers,
     });
+
     if (!response.ok) {
-      throw new Error();
+      throw new Error(`API request failed: ${response.statusText}`);
+    }
+
+    const text = await response.text();
+    const result = schema.safeParse(text);
+
+    if (!result.success) {
+      try {
+        const json = JSON.parse(text);
+        const jsonResult = schema.safeParse(json);
+        if (jsonResult.success) {
+          return jsonResult.data;
+        }
+      } catch {}
+
+      throw new Error(`Validation error: ${result.error.message}`);
     }
-    const data = await response.json();
-    return BlockSchema.parse(data);
+
+    return result.data;
+  }
+
+  async getAddressInfo(address: string): Promise<AddressInfo> {
+    return this.fetch(endpoints.address(address), AddressInfoSchema);
+  }
+
+  async getBlock(heightOrHash: number | BlockHash): Promise<Block> {
+    return this.fetch(endpoints.block(heightOrHash), BlockSchema);
+  }
+
+  async getBlockCount(): Promise<number> {
+    return this.fetch(endpoints.blockcount, z.number().int().nonnegative());
+  }
+
+  async getBlockHashByHeight(height: number): Promise<BlockHash> {
+    return this.fetch(endpoints.blockhashByHeight(height), BlockHashSchema);
+  }
+
+  async getLatestBlockHash(): Promise<BlockHash> {
+    return this.fetch(endpoints.blockhashLatest, BlockHashSchema);
+  }
+
+  async getLatestBlockHeight(): Promise<number> {
+    return this.fetch(endpoints.blockheight, z.number().int().nonnegative());
+  }
+
+  async getLatestBlocks(): Promise<BlocksResponse> {
+    return this.fetch(endpoints.blocks, BlocksResponseSchema);
+  }
+
+  async getLatestBlockTime(): Promise<number> {
+    return this.fetch(endpoints.blocktime, z.number().int());
   }
 }

src/schemas/address.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+
+export const RuneBalanceSchema = z.tuple([z.string(), z.string(), z.string()]);
+
+export const AddressInfoSchema = z.object({
+  outputs: z.array(z.string()),
+  inscriptions: z.array(z.string()),
+  sat_balance: z.number().int().nonnegative(),
+  runes_balances: z.array(RuneBalanceSchema),
+});

src/schemas/block.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+import { TransactionSchema } from 'schemas';
+
+const isHexString = (str: string) => /^[0-9a-fA-F]+$/.test(str);
+
+export const BlockHashSchema = z
+  .string()
+  .length(64, 'Block hash must be exactly 64 characters long')
+  .refine(
+    isHexString,
+    'Block hash must contain only hexadecimal characters (0-9, a-f, A-F)',
+  );
+
+export const BlockSchema = z.object({
+  best_height: z.number().int().nonnegative(),
+  hash: BlockHashSchema,
+  height: z.number().int().nonnegative(),
+  inscriptions: z.array(z.string()),
+  runes: z.array(z.string()),
+  target: z.string(),
+  transactions: z.array(TransactionSchema),
+});
+
+export const BlocksResponseSchema = z.object({
+  last: z.number().int().nonnegative(),
+  blocks: z.array(BlockHashSchema),
+  featured_blocks: z.record(BlockHashSchema, z.array(z.string())),
+});

src/schemas/index.ts

@@ -0,0 +1,3 @@
+export * from 'schemas/transaction';
+export * from 'schemas/block';
+export * from 'schemas/address';