@secondlayer/sdk 6.2.1 → 6.4.0

package/dist/subgraphs/index.d.ts

@@ -480,6 +480,252 @@ type ContractCallsWalkParams = Omit<ContractCallsListParams, "limit"> & {
 	batchSize?: number
 	signal?: AbortSignal
 };
+/** One canonical block in the sync map. Lean by design — block + parent hash
+*  for chain linkage, burn anchor for Bitcoin confirmations. Use `blocks` for
+*  the full block resource. */
+type IndexCanonicalBlock = {
+	cursor: string
+	block_height: number
+	block_hash: string
+	parent_hash: string
+	burn_block_height: number
+	burn_block_hash: string | null
+};
+type CanonicalEnvelope = {
+	canonical: IndexCanonicalBlock[]
+	next_cursor: string | null
+	tip: IndexTip
+};
+type CanonicalListParams = {
+	cursor?: string | null
+	fromCursor?: string | null
+	limit?: number
+	fromHeight?: number
+	toHeight?: number
+};
+type CanonicalWalkParams = Omit<CanonicalListParams, "limit"> & {
+	batchSize?: number
+	signal?: AbortSignal
+};
+/** A block resource. Metadata is intentionally thin — only chain-linkage and
+*  burn-anchor fields are persisted (no miner / tx_count / signer). */
+type IndexBlock = {
+	cursor: string
+	block_height: number
+	block_hash: string
+	parent_hash: string
+	burn_block_height: number
+	burn_block_hash: string | null
+	block_time: string | null
+	canonical: boolean
+};
+type BlocksEnvelope = {
+	blocks: IndexBlock[]
+	next_cursor: string | null
+	tip: IndexTip
+};
+type BlockEnvelope = {
+	block: IndexBlock
+	tip: IndexTip
+};
+type BlocksListParams = {
+	cursor?: string | null
+	fromCursor?: string | null
+	limit?: number
+	fromHeight?: number
+	toHeight?: number
+};
+type BlocksWalkParams = Omit<BlocksListParams, "limit"> & {
+	batchSize?: number
+	signal?: AbortSignal
+};
+type IndexPostCondition = {
+	type: "stx"
+	principal: string
+	condition_code: number
+	condition_code_name: string | null
+	amount: string
+} | {
+	type: "ft"
+	principal: string
+	asset_identifier: string
+	condition_code: number
+	condition_code_name: string | null
+	amount: string
+} | {
+	type: "nft"
+	principal: string
+	asset_identifier: string
+	asset_value: unknown
+	condition_code: number
+	condition_code_name: string | null
+};
+/** Full transaction document: columnar fields plus `raw_tx`-decoded enrichment.
+*  Payload sub-objects are present only for the matching `tx_type`; enrichment
+*  fields are null when `raw_tx` isn't decodable (e.g. burnchain ops). */
+type IndexTransaction = {
+	cursor: string
+	tx_id: string
+	block_height: number
+	block_time?: string | null
+	tx_index: number
+	tx_type: string
+	sender: string
+	status: string
+	fee: string | null
+	nonce: string | null
+	sponsored: boolean | null
+	anchor_mode: string | null
+	post_condition_mode: string | null
+	post_conditions: IndexPostCondition[]
+	contract_call?: {
+		contract_id: string
+		function_name: string
+		function_args: unknown[]
+		result: unknown
+		result_hex: string | null
+	}
+	token_transfer?: {
+		recipient: string
+		amount: string
+		memo: string
+	}
+	smart_contract?: {
+		contract_id: string | null
+		clarity_version: number | null
+	}
+	coinbase?: {
+		alt_recipient: string | null
+	}
+	tenure_change?: {
+		cause: number
+	}
+};
+type TransactionsEnvelope = {
+	transactions: IndexTransaction[]
+	next_cursor: string | null
+	tip: IndexTip
+	reorgs: never[]
+};
+type TransactionEnvelope = {
+	transaction: IndexTransaction
+	tip: IndexTip
+};
+type TransactionsListParams = {
+	cursor?: string | null
+	fromCursor?: string | null
+	limit?: number
+	type?: string
+	sender?: string
+	contractId?: string
+	fromHeight?: number
+	toHeight?: number
+};
+type TransactionsWalkParams = Omit<TransactionsListParams, "limit"> & {
+	batchSize?: number
+	signal?: AbortSignal
+};
+/** A decoded PoX-4 stacking action (one per stacking contract call). */
+type IndexStackingAction = {
+	cursor: string
+	block_height: number
+	block_time?: string | null
+	burn_block_height: number
+	tx_id: string
+	tx_index: number
+	function_name: string
+	caller: string
+	stacker: string | null
+	delegate_to: string | null
+	amount_ustx: string | null
+	lock_period: number | null
+	pox_addr: {
+		version: number | null
+		hashbytes: string | null
+		btc: string | null
+	}
+	start_cycle: number | null
+	end_cycle: number | null
+	reward_cycle: number | null
+	signer_key: string | null
+	result_ok: boolean
+};
+type StackingEnvelope = {
+	stacking: IndexStackingAction[]
+	next_cursor: string | null
+	tip: IndexTip
+	/** Present only when the PoX-4 decoder is disabled, explaining an empty feed. */
+	notes?: string
+};
+type StackingListParams = {
+	cursor?: string | null
+	fromCursor?: string | null
+	limit?: number
+	functionName?: string
+	stacker?: string
+	caller?: string
+	fromHeight?: number
+	toHeight?: number
+};
+type StackingWalkParams = Omit<StackingListParams, "limit"> & {
+	batchSize?: number
+	signal?: AbortSignal
+};
+/** A pending (unconfirmed) transaction. Like a transaction document but
+*  pre-chain — no block_height/tx_index/result/events — with `received_at` and
+*  a sequence cursor instead of a block position. */
+type IndexMempoolTransaction = {
+	cursor: string
+	tx_id: string
+	tx_type: string
+	sender: string
+	received_at?: string | null
+	fee: string | null
+	nonce: string | null
+	sponsored: boolean | null
+	anchor_mode: string | null
+	post_condition_mode: string | null
+	post_conditions: IndexPostCondition[]
+	contract_call?: {
+		contract_id: string
+		function_name: string
+		function_args: unknown[]
+	}
+	token_transfer?: {
+		recipient: string
+		amount: string
+		memo: string
+	}
+	smart_contract?: {
+		clarity_version: number | null
+	}
+	coinbase?: {
+		alt_recipient: string | null
+	}
+	tenure_change?: {
+		cause: number
+	}
+};
+type MempoolEnvelope = {
+	mempool: IndexMempoolTransaction[]
+	next_cursor: string | null
+	tip: IndexTip
+};
+type MempoolTransactionEnvelope = {
+	transaction: IndexMempoolTransaction
+	tip: IndexTip
+};
+type MempoolListParams = {
+	cursor?: string | null
+	fromCursor?: string | null
+	limit?: number
+	sender?: string
+	type?: string
+};
+type MempoolWalkParams = Omit<MempoolListParams, "limit"> & {
+	batchSize?: number
+	signal?: AbortSignal
+};
 declare class Index extends BaseClient {
 	constructor(options?: Partial<SecondLayerOptions>);
 	readonly ftTransfers: {
@@ -499,6 +745,38 @@ declare class Index extends BaseClient {
 		list: (params?: ContractCallsListParams) => Promise<ContractCallsEnvelope>
 		walk: (params?: ContractCallsWalkParams) => AsyncIterable<IndexContractCall>
 	};
+	/** Canonical block-hash map — sync only the current canonical chain. */
+	readonly canonical: {
+		list: (params?: CanonicalListParams) => Promise<CanonicalEnvelope>
+		walk: (params?: CanonicalWalkParams) => AsyncIterable<IndexCanonicalBlock>
+	};
+	/** Canonical blocks: paginated `list`/`walk`, plus `get` by height or hash
+	*  (resolves to null on 404). */
+	readonly blocks: {
+		list: (params?: BlocksListParams) => Promise<BlocksEnvelope>
+		walk: (params?: BlocksWalkParams) => AsyncIterable<IndexBlock>
+		get: (ref: string | number) => Promise<BlockEnvelope | null>
+	};
+	/** Full transaction documents: paginated `list`/`walk`, plus `get` by tx_id
+	*  (resolves to null on 404). */
+	readonly transactions: {
+		list: (params?: TransactionsListParams) => Promise<TransactionsEnvelope>
+		walk: (params?: TransactionsWalkParams) => AsyncIterable<IndexTransaction>
+		get: (txId: string) => Promise<TransactionEnvelope | null>
+	};
+	/** Decoded PoX-4 stacking actions. Empty (with a `notes` hint) when the
+	*  platform's PoX-4 decoder is disabled. */
+	readonly stacking: {
+		list: (params?: StackingListParams) => Promise<StackingEnvelope>
+		walk: (params?: StackingWalkParams) => AsyncIterable<IndexStackingAction>
+	};
+	/** Pending (unconfirmed) transactions: paginated `list`/`walk`, plus `get` by
+	*  tx_id (resolves to null when the tx has confirmed or dropped). */
+	readonly mempool: {
+		list: (params?: MempoolListParams) => Promise<MempoolEnvelope>
+		walk: (params?: MempoolWalkParams) => AsyncIterable<IndexMempoolTransaction>
+		get: (txId: string) => Promise<MempoolTransactionEnvelope | null>
+	};
 	private listFtTransfers;
 	private listNftTransfers;
 	private walkFtTransfers;
@@ -507,6 +785,19 @@ declare class Index extends BaseClient {
 	private walkEvents;
 	private listContractCalls;
 	private walkContractCalls;
+	private listCanonical;
+	private walkCanonical;
+	private listBlocks;
+	private getBlock;
+	private walkBlocks;
+	private listTransactions;
+	private getTransaction;
+	private walkTransactions;
+	private listStacking;
+	private walkStacking;
+	private listMempool;
+	private getMempoolTx;
+	private walkMempool;
 }
 declare const STREAMS_EVENT_TYPES: readonly ["stx_transfer", "stx_mint", "stx_burn", "stx_lock", "ft_transfer", "ft_mint", "ft_burn", "nft_transfer", "nft_mint", "nft_burn", "print"];
 type StreamsEventType = (typeof STREAMS_EVENT_TYPES)[number];

package/dist/subgraphs/index.js

@@ -489,6 +489,29 @@ class Index extends BaseClient {
     list: (params = {}) => this.listContractCalls(params),
     walk: (params = {}) => this.walkContractCalls(params)
   };
+  canonical = {
+    list: (params = {}) => this.listCanonical(params),
+    walk: (params = {}) => this.walkCanonical(params)
+  };
+  blocks = {
+    list: (params = {}) => this.listBlocks(params),
+    walk: (params = {}) => this.walkBlocks(params),
+    get: (ref) => this.getBlock(ref)
+  };
+  transactions = {
+    list: (params = {}) => this.listTransactions(params),
+    walk: (params = {}) => this.walkTransactions(params),
+    get: (txId) => this.getTransaction(txId)
+  };
+  stacking = {
+    list: (params = {}) => this.listStacking(params),
+    walk: (params = {}) => this.walkStacking(params)
+  };
+  mempool = {
+    list: (params = {}) => this.listMempool(params),
+    walk: (params = {}) => this.walkMempool(params),
+    get: (txId) => this.getMempoolTx(txId)
+  };
   async listFtTransfers(params = {}) {
     return this.request("GET", `/v1/index/ft-transfers${buildQuery({
       cursor: params.cursor,
@@ -640,6 +663,208 @@ class Index extends BaseClient {
       firstPage = false;
     }
   }
+  async listCanonical(params = {}) {
+    return this.request("GET", `/v1/index/canonical${buildQuery({
+      cursor: params.cursor,
+      from_cursor: params.fromCursor,
+      limit: params.limit,
+      from_height: params.fromHeight,
+      to_height: params.toHeight
+    })}`);
+  }
+  async* walkCanonical(params = {}) {
+    const batchSize = params.batchSize ?? 200;
+    let cursor = params.cursor ?? params.fromCursor ?? null;
+    let firstPage = true;
+    while (!params.signal?.aborted) {
+      const envelope = await this.listCanonical({
+        ...params,
+        limit: batchSize,
+        cursor: firstPage ? params.cursor : cursor,
+        fromCursor: firstPage ? params.fromCursor : undefined,
+        fromHeight: firstPage ? firstWalkFromHeight(params) : undefined
+      });
+      for (const block of envelope.canonical) {
+        if (params.signal?.aborted)
+          return;
+        yield block;
+      }
+      const nextCursor = envelope.next_cursor;
+      if (!nextCursor || nextCursor === cursor || envelope.canonical.length < batchSize) {
+        return;
+      }
+      cursor = nextCursor;
+      firstPage = false;
+    }
+  }
+  async listBlocks(params = {}) {
+    return this.request("GET", `/v1/index/blocks${buildQuery({
+      cursor: params.cursor,
+      from_cursor: params.fromCursor,
+      limit: params.limit,
+      from_height: params.fromHeight,
+      to_height: params.toHeight
+    })}`);
+  }
+  async getBlock(ref) {
+    try {
+      return await this.request("GET", `/v1/index/blocks/${encodeURIComponent(String(ref))}`);
+    } catch (err) {
+      if (err instanceof ApiError && err.status === 404)
+        return null;
+      throw err;
+    }
+  }
+  async* walkBlocks(params = {}) {
+    const batchSize = params.batchSize ?? 200;
+    let cursor = params.cursor ?? params.fromCursor ?? null;
+    let firstPage = true;
+    while (!params.signal?.aborted) {
+      const envelope = await this.listBlocks({
+        ...params,
+        limit: batchSize,
+        cursor: firstPage ? params.cursor : cursor,
+        fromCursor: firstPage ? params.fromCursor : undefined,
+        fromHeight: firstPage ? firstWalkFromHeight(params) : undefined
+      });
+      for (const block of envelope.blocks) {
+        if (params.signal?.aborted)
+          return;
+        yield block;
+      }
+      const nextCursor = envelope.next_cursor;
+      if (!nextCursor || nextCursor === cursor || envelope.blocks.length < batchSize) {
+        return;
+      }
+      cursor = nextCursor;
+      firstPage = false;
+    }
+  }
+  async listTransactions(params = {}) {
+    return this.request("GET", `/v1/index/transactions${buildQuery({
+      cursor: params.cursor,
+      from_cursor: params.fromCursor,
+      limit: params.limit,
+      type: params.type,
+      sender: params.sender,
+      contract_id: params.contractId,
+      from_height: params.fromHeight,
+      to_height: params.toHeight
+    })}`);
+  }
+  async getTransaction(txId) {
+    try {
+      return await this.request("GET", `/v1/index/transactions/${encodeURIComponent(txId)}`);
+    } catch (err) {
+      if (err instanceof ApiError && err.status === 404)
+        return null;
+      throw err;
+    }
+  }
+  async* walkTransactions(params = {}) {
+    const batchSize = params.batchSize ?? 200;
+    let cursor = params.cursor ?? params.fromCursor ?? null;
+    let firstPage = true;
+    while (!params.signal?.aborted) {
+      const envelope = await this.listTransactions({
+        ...params,
+        limit: batchSize,
+        cursor: firstPage ? params.cursor : cursor,
+        fromCursor: firstPage ? params.fromCursor : undefined,
+        fromHeight: firstPage ? firstWalkFromHeight(params) : undefined
+      });
+      for (const tx of envelope.transactions) {
+        if (params.signal?.aborted)
+          return;
+        yield tx;
+      }
+      const nextCursor = envelope.next_cursor;
+      if (!nextCursor || nextCursor === cursor || envelope.transactions.length < batchSize) {
+        return;
+      }
+      cursor = nextCursor;
+      firstPage = false;
+    }
+  }
+  async listStacking(params = {}) {
+    return this.request("GET", `/v1/index/stacking${buildQuery({
+      cursor: params.cursor,
+      from_cursor: params.fromCursor,
+      limit: params.limit,
+      function_name: params.functionName,
+      stacker: params.stacker,
+      caller: params.caller,
+      from_height: params.fromHeight,
+      to_height: params.toHeight
+    })}`);
+  }
+  async* walkStacking(params = {}) {
+    const batchSize = params.batchSize ?? 200;
+    let cursor = params.cursor ?? params.fromCursor ?? null;
+    let firstPage = true;
+    while (!params.signal?.aborted) {
+      const envelope = await this.listStacking({
+        ...params,
+        limit: batchSize,
+        cursor: firstPage ? params.cursor : cursor,
+        fromCursor: firstPage ? params.fromCursor : undefined,
+        fromHeight: firstPage ? firstWalkFromHeight(params) : undefined
+      });
+      for (const action of envelope.stacking) {
+        if (params.signal?.aborted)
+          return;
+        yield action;
+      }
+      const nextCursor = envelope.next_cursor;
+      if (!nextCursor || nextCursor === cursor || envelope.stacking.length < batchSize) {
+        return;
+      }
+      cursor = nextCursor;
+      firstPage = false;
+    }
+  }
+  async listMempool(params = {}) {
+    return this.request("GET", `/v1/index/mempool${buildQuery({
+      cursor: params.cursor,
+      from_cursor: params.fromCursor,
+      limit: params.limit,
+      sender: params.sender,
+      type: params.type
+    })}`);
+  }
+  async getMempoolTx(txId) {
+    try {
+      return await this.request("GET", `/v1/index/mempool/${encodeURIComponent(txId)}`);
+    } catch (err) {
+      if (err instanceof ApiError && err.status === 404)
+        return null;
+      throw err;
+    }
+  }
+  async* walkMempool(params = {}) {
+    const batchSize = params.batchSize ?? 200;
+    let cursor = params.cursor ?? params.fromCursor ?? null;
+    let firstPage = true;
+    while (!params.signal?.aborted) {
+      const envelope = await this.listMempool({
+        ...params,
+        limit: batchSize,
+        cursor: firstPage ? params.cursor : cursor,
+        fromCursor: firstPage ? params.fromCursor : undefined
+      });
+      for (const tx of envelope.mempool) {
+        if (params.signal?.aborted)
+          return;
+        yield tx;
+      }
+      const nextCursor = envelope.next_cursor;
+      if (!nextCursor || nextCursor === cursor || envelope.mempool.length < batchSize) {
+        return;
+      }
+      cursor = nextCursor;
+      firstPage = false;
+    }
+  }
 }
 
 // src/streams/client.ts
@@ -1187,5 +1412,5 @@ export {
   Subgraphs
 };
 
-//# debugId=9C60733D992A531964756E2164756E21
+//# debugId=7E918A66EC7A1E1864756E2164756E21
 //# sourceMappingURL=index.js.map