@secondlayer/sdk 6.26.1 → 6.27.0

package/dist/subgraphs/index.d.ts

@@ -1337,6 +1337,265 @@ type PrintSchemaResponse = {
 	}
 	tip: IndexTip
 };
+/** The decoded `sbtc_events` topics. */
+type SbtcEventTopic = "completed-deposit" | "withdrawal-create" | "withdrawal-accept" | "withdrawal-reject" | "key-rotation" | "update-protocol-contract";
+type SbtcWithdrawalStatus = "REQUESTED" | "ACCEPTED" | "REJECTED";
+/** A completed sBTC peg-in, keyed by `bitcoin_txid` (deposits carry no
+*  `request_id`). One terminal `completed-deposit` event per deposit. */
+type IndexSbtcDeposit = {
+	cursor: string
+	block_height: number
+	block_time?: string | null
+	tx_id: string
+	tx_index: number
+	event_index: number
+	amount: string | null
+	sender: string | null
+	bitcoin_txid: string | null
+	output_index: number | null
+	recipient_btc_version: number | null
+	recipient_btc_hashbytes: string | null
+};
+/** A deposit fetched by Bitcoin txid — always terminal, hence `status`. */
+type IndexSbtcDepositDetail = IndexSbtcDeposit & {
+	status: "COMPLETED"
+};
+/** A peg-out collapsed to one row per `request_id`, with lifecycle `status`
+*  derived from the latest accept/reject. */
+type IndexSbtcWithdrawal = {
+	cursor: string
+	request_id: number
+	status: SbtcWithdrawalStatus
+	amount: string | null
+	sender: string | null
+	recipient_btc_version: number | null
+	recipient_btc_hashbytes: string | null
+	sweep_txid: string | null
+	requested_at?: string | null
+	resolved_at?: string | null
+};
+/** One phase of a withdrawal's lifecycle (the on-Stacks event that drove it). */
+type IndexSbtcWithdrawalPhase = {
+	block_height: number
+	block_time: string | null
+	tx_id: string
+};
+/** A single peg-out's full assembled lifecycle, fetched by `request_id`.
+*  `finalized` is true once terminal and past the reorg margin. */
+type IndexSbtcWithdrawalDetail = {
+	request_id: number
+	status: SbtcWithdrawalStatus
+	amount: string | null
+	sender: string | null
+	recipient_btc_version: number | null
+	recipient_btc_hashbytes: string | null
+	requested: IndexSbtcWithdrawalPhase
+	accepted: (IndexSbtcWithdrawalPhase & {
+		sweep_txid: string | null
+		signer_bitmap: string | null
+	}) | null
+	rejected: IndexSbtcWithdrawalPhase | null
+	settlement: {
+		sweep_txid: string | null
+		btc_confirmations: number | null
+		settlement_confirmed: boolean | null
+	}
+	finalized: boolean
+};
+/** A raw decoded sBTC protocol-state event — the full `sbtc_events` row, one
+*  per event across all topics. */
+type IndexSbtcEvent = {
+	cursor: string
+	block_height: number
+	block_time?: string | null
+	tx_id: string
+	tx_index: number
+	event_index: number
+	topic: SbtcEventTopic
+	request_id: number | null
+	amount: string | null
+	sender: string | null
+	recipient_btc_version: number | null
+	recipient_btc_hashbytes: string | null
+	bitcoin_txid: string | null
+	output_index: number | null
+	sweep_txid: string | null
+	burn_hash: string | null
+	burn_height: number | null
+	signer_bitmap: string | null
+	max_fee: string | null
+	fee: string | null
+	governance_contract_type: number | null
+	governance_new_contract: string | null
+	signer_aggregate_pubkey: string | null
+	signer_threshold: number | null
+	signer_address: string | null
+	signer_keys_count: number | null
+};
+/** The peg "scoreboard" — a single all-time canonical aggregate. */
+type IndexSbtcSummary = {
+	total_deposits: number
+	total_withdrawals_requested: number
+	total_withdrawals_accepted: number
+	total_withdrawals_rejected: number
+	net_peg_flow_sats: string
+	total_locked_sats: string
+	sbtc_supply_sats: string | null
+};
+type SbtcDepositsEnvelope = {
+	deposits: IndexSbtcDeposit[]
+	next_cursor: string | null
+	tip: IndexTip
+	reorgs: IndexReorg[]
+	/** Present only when the sBTC decoder is disabled, explaining an empty feed. */
+	notes?: string
+};
+type SbtcDepositEnvelope = {
+	deposit: IndexSbtcDepositDetail
+	tip: IndexTip
+};
+type SbtcWithdrawalsEnvelope = {
+	withdrawals: IndexSbtcWithdrawal[]
+	next_cursor: string | null
+	tip: IndexTip
+	reorgs: IndexReorg[]
+	notes?: string
+};
+type SbtcWithdrawalEnvelope = {
+	withdrawal: IndexSbtcWithdrawalDetail
+	tip: IndexTip
+};
+type SbtcEventsEnvelope = {
+	events: IndexSbtcEvent[]
+	next_cursor: string | null
+	tip: IndexTip
+	reorgs: IndexReorg[]
+	notes?: string
+};
+type SbtcSummaryEnvelope = {
+	summary: IndexSbtcSummary
+	tip: IndexTip
+	notes?: string
+};
+type SbtcDepositsListParams = {
+	cursor?: string | null
+	fromCursor?: string | null
+	limit?: number
+	/** Clamp to the finality boundary — only settled deposits past the reorg margin. */
+	confirmed?: boolean
+	sender?: string
+	bitcoinTxid?: string
+	fromHeight?: number
+	toHeight?: number
+};
+type SbtcDepositsWalkParams = Omit<SbtcDepositsListParams, "limit"> & {
+	batchSize?: number
+	signal?: AbortSignal
+};
+type SbtcWithdrawalsListParams = {
+	cursor?: string | null
+	fromCursor?: string | null
+	limit?: number
+	confirmed?: boolean
+	status?: SbtcWithdrawalStatus
+	sender?: string
+	requestId?: number
+	fromHeight?: number
+	toHeight?: number
+};
+type SbtcWithdrawalsWalkParams = Omit<SbtcWithdrawalsListParams, "limit"> & {
+	batchSize?: number
+	signal?: AbortSignal
+};
+type SbtcEventsListParams = {
+	cursor?: string | null
+	fromCursor?: string | null
+	limit?: number
+	confirmed?: boolean
+	topic?: SbtcEventTopic
+	sender?: string
+	requestId?: number
+	bitcoinTxid?: string
+	fromHeight?: number
+	toHeight?: number
+};
+type SbtcEventsWalkParams = Omit<SbtcEventsListParams, "limit"> & {
+	batchSize?: number
+	signal?: AbortSignal
+};
+/** `index.sbtc` — the decoded sBTC peg surface (deposits, withdrawals, raw
+*  events, scoreboard). The only productized decoded sBTC peg feed on Stacks. */
+interface SbtcResource {
+	deposits: {
+		list(params?: SbtcDepositsListParams): Promise<SbtcDepositsEnvelope>
+		walk(params?: SbtcDepositsWalkParams): AsyncIterable<IndexSbtcDeposit>
+		/** Fetch a completed deposit by Bitcoin txid; 404 → null. */
+		get(bitcoinTxid: string): Promise<SbtcDepositEnvelope | null>
+	};
+	withdrawals: {
+		list(params?: SbtcWithdrawalsListParams): Promise<SbtcWithdrawalsEnvelope>
+		walk(params?: SbtcWithdrawalsWalkParams): AsyncIterable<IndexSbtcWithdrawal>
+		/** Fetch a withdrawal's full lifecycle by request id; 404 → null. */
+		get(requestId: number): Promise<SbtcWithdrawalEnvelope | null>
+	};
+	events: {
+		list(params?: SbtcEventsListParams): Promise<SbtcEventsEnvelope>
+		walk(params?: SbtcEventsWalkParams): AsyncIterable<IndexSbtcEvent>
+	};
+	/** The peg scoreboard — a single all-time aggregate (no pagination). */
+	summary(): Promise<SbtcSummaryEnvelope>;
+}
+/** Per-function action count within a reward cycle. */
+type IndexPoxFunctionCount = {
+	function_name: string
+	count: number
+};
+/** Aggregate stats for one PoX reward cycle — distinct from `index.stacking`
+*  (decoded per-call PoX-4 actions); this is the reward-cycle rollup. */
+type IndexPoxCycle = {
+	reward_cycle: number
+	/** Total ustx locked across all stack-* calls in this cycle (bigint-safe string). */
+	total_stacked_ustx: string
+	unique_stackers: number
+	unique_delegators: number
+	action_count: number
+	start_block_height: number
+	end_block_height: number
+	/** True when this is the latest reward cycle (still accumulating new actions). */
+	is_current: boolean
+	function_breakdown: IndexPoxFunctionCount[]
+};
+type PoxCyclesEnvelope = {
+	cycles: IndexPoxCycle[]
+	/** The next `reward_cycle` to page from (cycles descend), or null at the end. */
+	next_cursor: number | null
+	tip: IndexTip
+	/** Present only when the PoX-4 decoder is disabled, explaining an empty feed. */
+	notes?: string
+};
+type PoxCycleEnvelope = {
+	cycle: IndexPoxCycle
+	tip: IndexTip
+	notes?: string
+};
+type PoxCyclesListParams = {
+	/** A `reward_cycle` to page from; the page returns cycles below it (descending). */
+	cursor?: number | null
+	limit?: number
+};
+type PoxCyclesWalkParams = Omit<PoxCyclesListParams, "limit"> & {
+	batchSize?: number
+	signal?: AbortSignal
+};
+/** `index.pox` — PoX reward-cycle aggregates. */
+interface PoxResource {
+	cycles: {
+		list(params?: PoxCyclesListParams): Promise<PoxCyclesEnvelope>
+		walk(params?: PoxCyclesWalkParams): AsyncIterable<IndexPoxCycle>
+		/** Fetch one reward cycle's aggregate by number; 404 → null. */
+		get(rewardCycle: number): Promise<PoxCycleEnvelope | null>
+	};
+}
 /**
 * `index.ftTransfers` — callable shorthand for `.list()`, with `.list`/`.walk`
 * still available: `await sl.index.ftTransfers({ contractId })`.
@@ -1445,6 +1704,12 @@ declare class Index extends BaseClient {
 		walk: (params?: MempoolWalkParams) => AsyncIterable<IndexMempoolTransaction>
 		get: (txId: string) => Promise<MempoolTransactionEnvelope | null>
 	};
+	/** Decoded sBTC peg surface — the only productized decoded sBTC peg feed on
+	*  Stacks. `deposits`/`withdrawals`/`events` paginate; `summary` is a scalar. */
+	readonly sbtc: SbtcResource;
+	/** PoX reward-cycle aggregates. Distinct from `stacking` (per-call PoX-4
+	*  actions); `cycles` is the reward-cycle rollup. */
+	readonly pox: PoxResource;
 	private listFtTransfers;
 	private listNftTransfers;
 	private walkFtTransfers;
@@ -1471,6 +1736,18 @@ declare class Index extends BaseClient {
 	private listMempool;
 	private getMempoolTx;
 	private walkMempool;
+	private listSbtcDeposits;
+	private walkSbtcDeposits;
+	private getSbtcDeposit;
+	private listSbtcWithdrawals;
+	private walkSbtcWithdrawals;
+	private getSbtcWithdrawal;
+	private listSbtcEvents;
+	private walkSbtcEvents;
+	private getSbtcSummary;
+	private listPoxCycles;
+	private walkPoxCycles;
+	private getPoxCycle;
 }
 /**
 * Typed client for project management (`/api/projects/*`).

package/dist/subgraphs/index.js

@@ -811,6 +811,30 @@ class Index extends BaseClient {
     walk: (params = {}) => this.walkMempool(params),
     get: (txId) => this.getMempoolTx(txId)
   };
+  sbtc = {
+    deposits: {
+      list: (params = {}) => this.listSbtcDeposits(params),
+      walk: (params = {}) => this.walkSbtcDeposits(params),
+      get: (bitcoinTxid) => this.getSbtcDeposit(bitcoinTxid)
+    },
+    withdrawals: {
+      list: (params = {}) => this.listSbtcWithdrawals(params),
+      walk: (params = {}) => this.walkSbtcWithdrawals(params),
+      get: (requestId) => this.getSbtcWithdrawal(requestId)
+    },
+    events: {
+      list: (params = {}) => this.listSbtcEvents(params),
+      walk: (params = {}) => this.walkSbtcEvents(params)
+    },
+    summary: () => this.getSbtcSummary()
+  };
+  pox = {
+    cycles: {
+      list: (params = {}) => this.listPoxCycles(params),
+      walk: (params = {}) => this.walkPoxCycles(params),
+      get: (rewardCycle) => this.getPoxCycle(rewardCycle)
+    }
+  };
   async listFtTransfers(params = {}) {
     return this.request("GET", `/v1/index/ft-transfers${buildQuery({
       cursor: params.cursor,
@@ -1177,6 +1201,173 @@ class Index extends BaseClient {
       firstPage = false;
     }
   }
+  async listSbtcDeposits(params = {}) {
+    return this.request("GET", `/v1/index/sbtc/deposits${buildQuery({
+      cursor: params.cursor,
+      from_cursor: params.fromCursor,
+      limit: params.limit,
+      confirmed: params.confirmed,
+      sender: params.sender,
+      bitcoin_txid: params.bitcoinTxid,
+      from_height: params.fromHeight,
+      to_height: params.toHeight
+    })}`);
+  }
+  async* walkSbtcDeposits(params = {}) {
+    const batchSize = params.batchSize ?? 200;
+    let cursor = params.cursor ?? params.fromCursor ?? null;
+    let firstPage = true;
+    while (!params.signal?.aborted) {
+      const envelope = await this.listSbtcDeposits({
+        ...params,
+        limit: batchSize,
+        cursor: firstPage ? params.cursor : cursor,
+        fromCursor: firstPage ? params.fromCursor : undefined,
+        fromHeight: firstPage ? firstWalkFromHeight(params) : undefined
+      });
+      for (const deposit of envelope.deposits) {
+        if (params.signal?.aborted)
+          return;
+        yield deposit;
+      }
+      const nextCursor = envelope.next_cursor;
+      if (!nextCursor || nextCursor === cursor || envelope.deposits.length < batchSize) {
+        return;
+      }
+      cursor = nextCursor;
+      firstPage = false;
+    }
+  }
+  async getSbtcDeposit(bitcoinTxid) {
+    try {
+      return await this.request("GET", `/v1/index/sbtc/deposits/${encodeURIComponent(bitcoinTxid)}`);
+    } catch (err) {
+      if (err instanceof ApiError && err.status === 404)
+        return null;
+      throw err;
+    }
+  }
+  async listSbtcWithdrawals(params = {}) {
+    return this.request("GET", `/v1/index/sbtc/withdrawals${buildQuery({
+      cursor: params.cursor,
+      from_cursor: params.fromCursor,
+      limit: params.limit,
+      confirmed: params.confirmed,
+      status: params.status,
+      sender: params.sender,
+      request_id: params.requestId,
+      from_height: params.fromHeight,
+      to_height: params.toHeight
+    })}`);
+  }
+  async* walkSbtcWithdrawals(params = {}) {
+    const batchSize = params.batchSize ?? 200;
+    let cursor = params.cursor ?? params.fromCursor ?? null;
+    let firstPage = true;
+    while (!params.signal?.aborted) {
+      const envelope = await this.listSbtcWithdrawals({
+        ...params,
+        limit: batchSize,
+        cursor: firstPage ? params.cursor : cursor,
+        fromCursor: firstPage ? params.fromCursor : undefined,
+        fromHeight: firstPage ? firstWalkFromHeight(params) : undefined
+      });
+      for (const withdrawal of envelope.withdrawals) {
+        if (params.signal?.aborted)
+          return;
+        yield withdrawal;
+      }
+      const nextCursor = envelope.next_cursor;
+      if (!nextCursor || nextCursor === cursor || envelope.withdrawals.length < batchSize) {
+        return;
+      }
+      cursor = nextCursor;
+      firstPage = false;
+    }
+  }
+  async getSbtcWithdrawal(requestId) {
+    try {
+      return await this.request("GET", `/v1/index/sbtc/withdrawals/${requestId}`);
+    } catch (err) {
+      if (err instanceof ApiError && err.status === 404)
+        return null;
+      throw err;
+    }
+  }
+  async listSbtcEvents(params = {}) {
+    return this.request("GET", `/v1/index/sbtc/events${buildQuery({
+      cursor: params.cursor,
+      from_cursor: params.fromCursor,
+      limit: params.limit,
+      confirmed: params.confirmed,
+      topic: params.topic,
+      sender: params.sender,
+      request_id: params.requestId,
+      bitcoin_txid: params.bitcoinTxid,
+      from_height: params.fromHeight,
+      to_height: params.toHeight
+    })}`);
+  }
+  async* walkSbtcEvents(params = {}) {
+    const batchSize = params.batchSize ?? 200;
+    let cursor = params.cursor ?? params.fromCursor ?? null;
+    let firstPage = true;
+    while (!params.signal?.aborted) {
+      const envelope = await this.listSbtcEvents({
+        ...params,
+        limit: batchSize,
+        cursor: firstPage ? params.cursor : cursor,
+        fromCursor: firstPage ? params.fromCursor : undefined,
+        fromHeight: firstPage ? firstWalkFromHeight(params) : undefined
+      });
+      for (const event of envelope.events) {
+        if (params.signal?.aborted)
+          return;
+        yield event;
+      }
+      const nextCursor = envelope.next_cursor;
+      if (!nextCursor || nextCursor === cursor || envelope.events.length < batchSize) {
+        return;
+      }
+      cursor = nextCursor;
+      firstPage = false;
+    }
+  }
+  async getSbtcSummary() {
+    return this.request("GET", "/v1/index/sbtc/summary");
+  }
+  async listPoxCycles(params = {}) {
+    return this.request("GET", `/v1/index/pox/cycles${buildQuery({
+      cursor: params.cursor,
+      limit: params.limit
+    })}`);
+  }
+  async* walkPoxCycles(params = {}) {
+    const batchSize = params.batchSize ?? 100;
+    let cursor = params.cursor ?? null;
+    while (!params.signal?.aborted) {
+      const envelope = await this.listPoxCycles({ cursor, limit: batchSize });
+      for (const cycle of envelope.cycles) {
+        if (params.signal?.aborted)
+          return;
+        yield cycle;
+      }
+      const nextCursor = envelope.next_cursor;
+      if (nextCursor === null || nextCursor === cursor || envelope.cycles.length < batchSize) {
+        return;
+      }
+      cursor = nextCursor;
+    }
+  }
+  async getPoxCycle(rewardCycle) {
+    try {
+      return await this.request("GET", `/v1/index/pox/cycles/${rewardCycle}`);
+    } catch (err) {
+      if (err instanceof ApiError && err.status === 404)
+        return null;
+      throw err;
+    }
+  }
 }
 
 // src/projects/client.ts
@@ -1833,5 +2024,5 @@ export {
   Subgraphs
 };
 
-//# debugId=B199B845626E122864756E2164756E21
+//# debugId=AF49D51938E916C064756E2164756E21
 //# sourceMappingURL=index.js.map