@secondlayer/sdk 6.18.0 → 6.20.0

package/README.md

@@ -328,8 +328,15 @@ const { data } = await sl.subgraphs.list();
 // Get
 const subgraph = await sl.subgraphs.get("my-subgraph");
 
-// Query table
-const rows = await sl.subgraphs.queryTable("my-subgraph", "transfers", {
+// Open read (/v1) — keyless for public subgraphs; pass apiKey for your private ones
+const { rows, next_cursor, tip } = await sl.subgraphs.rows("my-subgraph", "transfers", {
+  order: "desc",
+  limit: 50,
+  // cursor: next_cursor — pass back to resume
+});
+
+// Authed control-plane query (/api)
+const page = await sl.subgraphs.queryTable("my-subgraph", "transfers", {
   sort: "block_height",
   order: "desc",
   limit: 50,
@@ -344,8 +351,12 @@ const spec = await sl.subgraphs.openapi("my-subgraph");
 const source = await sl.subgraphs.getSource("my-subgraph");
 const gaps = await sl.subgraphs.gaps("my-subgraph");
 
-// Deploy
-const result = await sl.subgraphs.deploy({ name, sources, schema, handlerCode });
+// Deploy — managed deploys default visibility "public", BYO default "private"
+const result = await sl.subgraphs.deploy({ name, sources, schema, handlerCode, visibility: "public" });
+
+// Flip visibility — publish claims the global public name (409 PUBLIC_NAME_TAKEN if claimed)
+await sl.subgraphs.publish("my-subgraph");
+await sl.subgraphs.unpublish("my-subgraph");
 ```
 
 Stream rows live with the typed client — each table exposes `subscribe`
@@ -483,6 +494,52 @@ verifySecondlayerSignature(
 Prefer the per-subscription HMAC (Standard Webhooks) secret instead? Use
 `verifyWebhookSignature(rawBody, headers, secret)` — raw body first.
 
+## x402 pay-per-call (accountless)
+
+Call the public `/v1/*` reads with **no API key, no account, no Stripe** — pay a
+few hundredths of a cent per request from a Stacks wallet. Payment is **gasless**
+(you sign; we sponsor the STX fee) and uses standard **x402 v2** on `stacks:1`.
+Supported assets: **sBTC** (default), **USDCx**, **STX**.
+
+> Keyed (`sk-sl_`) requests bypass x402 and bill through your plan — x402 is for
+> accountless callers.
+
+Drop-in `fetch` that pays on `402` automatically:
+
+```typescript
+import { withX402, readX402Receipt } from "@secondlayer/sdk";
+import { privateKeyToAccount } from "@secondlayer/stacks/accounts";
+
+const x402fetch = withX402(fetch, {
+  account: privateKeyToAccount(process.env.AGENT_STACKS_KEY!), // funded with sBTC/USDCx
+  preferAssets: ["sBTC", "USDCx", "STX"],   // optional (this is the default)
+  maxAmountPerCall: { sBTC: 2000n },        // optional spend guard (atomic units)
+});
+
+const res = await x402fetch(
+  "https://api.secondlayer.tools/v1/index/events?event_type=ft_transfer",
+);
+const data = await res.json();
+readX402Receipt(res); // { success, txid, payer, network } | null
+```
+
+Or a small client returning `{ data, payment }`:
+
+```typescript
+import { createX402Client } from "@secondlayer/sdk";
+
+const sl = createX402Client({ account, baseUrl: "https://api.secondlayer.tools" });
+const { data, payment } = await sl.get("/v1/index/events", {
+  query: { event_type: "ft_transfer" },
+});
+```
+
+The SDK selects an offer by `preferAssets` (skipping any over `maxAmountPerCall`,
+else throws `X402SpendGuardError`), auto-resolves your account nonce, signs
+origin-only, and retries. A paid call settles on-chain before returning
+(confirmed-tier today, ~seconds; near-instant optimistic serve for Index/Streams
+is rolling out). Discover capabilities at `GET /x402/supported`.
+
 ## Error Handling
 
 ```typescript

package/dist/index.d.ts

@@ -52,6 +52,16 @@ interface SubgraphOperationStatus {
 	createdAt: string;
 	updatedAt: string;
 }
+/** /v1 cursor envelope for subgraph table reads. */
+interface SubgraphRowsEnvelope<T = unknown> {
+	rows: T[];
+	next_cursor: string | null;
+	tip: {
+		block_height: number
+		subgraph_height: number
+		blocks_behind: number
+	};
+}
 interface BundleSubgraphResponse {
 	ok: true;
 	name: string;
@@ -94,6 +104,29 @@ declare class Subgraphs extends BaseClient {
 	}): Promise<{
 		message: string
 	}>;
+	/**
+	* Publish: claim the name in the global public namespace and open anon
+	* reads on /v1/subgraphs/:name. 409 PUBLIC_NAME_TAKEN if another account
+	* holds the public name.
+	*/
+	publish(name: string): Promise<{
+		name: string
+		visibility: "public"
+		url: string
+	}>;
+	/** Make reads private again (owning account's bearer key required). */
+	unpublish(name: string): Promise<{
+		name: string
+		visibility: "private"
+	}>;
+	/**
+	* Open /v1 read: cursor-paginated rows. Anon works for public subgraphs;
+	* pass an apiKey on the client for private ones. Resume with the returned
+	* `next_cursor`.
+	*/
+	rows<T = unknown>(name: string, table: string, params?: Omit<SubgraphQueryParams, "offset" | "sort"> & {
+		cursor?: string
+	}): Promise<SubgraphRowsEnvelope<T>>;
 	/** Recent reindex/backfill operations for a subgraph, newest first. */
 	operations(name: string): Promise<{
 		operations: SubgraphOperationStatus[]
@@ -232,6 +265,13 @@ declare class Contracts extends BaseClient {
 	constructor(options?: Partial<SecondLayerOptions>);
 	/** Find contracts conforming to `trait`. `trait` is required (server 400s without it). */
 	list(params: ContractsListParams): Promise<ContractsEnvelope>;
+	/**
+	* Fetch a single contract from the registry by id (the prod-safe ABI source).
+	* Pass `{ includeAbi: true }` for the full ABI blob. Resolves null on 404.
+	*/
+	get(contractId: string, opts?: {
+		includeAbi?: boolean
+	}): Promise<ContractSummary | null>;
 }
 /**
 * Typed client for the Foundation Datasets REST API (`/v1/datasets/*`).
@@ -382,6 +422,85 @@ declare class Datasets extends BaseClient {
 	private paramsToQuery;
 	private cursorDataset;
 }
+import { RewardSet } from "@secondlayer/shared/node/consensus";
+import { MerkleProofStep } from "@secondlayer/shared/node/nakamoto";
+/**
+* Trustless transaction-inclusion proof verification.
+*
+* Given a proof from `GET /v1/index/transactions/:txid/proof`, the consumer
+* re-derives everything itself — it does NOT trust any value Secondlayer
+* computed. Anchored level: (1) recompute the txid from the raw tx bytes, (2)
+* fold it up the merkle path to the header's `tx_merkle_root`, (3) recompute the
+* header's `block_hash` and `index_block_hash` from the raw header — "this tx is
+* included in a header any node can corroborate". Consensus level (when the proof
+* carries a `consensus` field, or a `rewardSet` is passed): additionally recover
+* the header's signer signatures and confirm ≥70% of reward-set signer weight
+* signed the block.
+*
+* Note: uses Node's crypto via `@secondlayer/shared` (same as the Streams
+* signature verify); intended for Node/server verification.
+*/
+interface TransactionProof {
+	txid: string;
+	index_block_hash: string;
+	block_height: number;
+	tx_index: number;
+	/** Raw consensus-serialized transaction bytes (hex). */
+	raw_tx: string;
+	/** Raw Nakamoto block-header bytes (hex) — parsed + re-hashed by the verifier. */
+	raw_header: string;
+	/** Authentication path from the tx leaf to `tx_merkle_root`. */
+	tx_merkle_path: MerkleProofStep[];
+	/** Present when consensus-level verification is available: the reward cycle and
+	*  its signer set, against which the header's signer signatures are checked. */
+	consensus?: {
+		reward_cycle: number
+		reward_set: RewardSet
+	};
+}
+interface TransactionProofVerifyResult {
+	/** Highest level actually verified. "consensus" requires the proof's
+	*  `consensus` field and a met signer-weight threshold. */
+	level: "anchored" | "consensus";
+	/** Recomputed txid === proof.txid. */
+	txidMatches: boolean;
+	/** Merkle path folds the txid to the header's tx_merkle_root. */
+	includedInHeader: boolean;
+	/** Recomputed block_hash + index_block_hash match the header / proof. */
+	headerSelfConsistent: boolean;
+	/** Basis points (0–10000) of reward-set signer weight that signed the block.
+	*  Only set when the proof carries a `consensus` field. */
+	signerWeightBps?: number;
+	/** ≥70% of signer weight signed. Only set with a `consensus` field. */
+	thresholdMet?: boolean;
+	/** Which reward set the signer check used: "provided" (caller-resolved →
+	*  fully trustless) or "embedded" (the one Secondlayer put in the proof). */
+	rewardSetSource?: "provided" | "embedded";
+	/** All applicable checks passed (incl. the threshold when consensus is present). */
+	ok: boolean;
+	errors: string[];
+}
+/**
+* Resolve a reward set directly from a stacks-node (`/v3/stacker_set/{cycle}`),
+* so a caller can verify the consensus layer against a node IT trusts rather than
+* the reward set Secondlayer embedded in the proof. Pass the result as
+* `verifyTransactionProof(proof, { rewardSet })`.
+*/
+declare function fetchRewardSet(opts: {
+	nodeUrl: string
+	cycle: number
+	fetchImpl?: typeof fetch
+}): Promise<RewardSet | null>;
+/**
+* Verify a transaction-inclusion proof. Every check is recomputed client-side,
+* so a `true` result does not rely on trusting Secondlayer. Pass
+* `{ rewardSet }` (resolved via {@link fetchRewardSet} from your own node) to
+* verify the consensus layer against a reward set you trust rather than the one
+* embedded in the proof.
+*/
+declare function verifyTransactionProof(proof: TransactionProof, opts?: {
+	rewardSet?: RewardSet
+}): TransactionProofVerifyResult;
 type IndexTip = {
 	block_height: number
 	lag_seconds: number
@@ -882,6 +1001,30 @@ type MempoolWalkParams = Omit<MempoolListParams, "limit"> & {
 	batchSize?: number
 	signal?: AbortSignal
 };
+/**
+* `index.ftTransfers` — callable shorthand for `.list()`, with `.list`/`.walk`
+* still available: `await sl.index.ftTransfers({ contractId })`.
+*
+* The API accepts `contract_id`/`sender`/`recipient` equality filters only —
+* no amount filtering and no asset-slug resolution on /v1/index/ft-transfers.
+*/
+interface FtTransfersResource {
+	(params?: FtTransfersListParams): Promise<FtTransfersEnvelope>;
+	list(params?: FtTransfersListParams): Promise<FtTransfersEnvelope>;
+	walk(params?: FtTransfersWalkParams): AsyncIterable<FtTransfer>;
+}
+/** `index.nftTransfers` — callable shorthand for `.list()` (see {@link FtTransfersResource}). */
+interface NftTransfersResource {
+	(params?: NftTransfersListParams): Promise<NftTransfersEnvelope>;
+	list(params?: NftTransfersListParams): Promise<NftTransfersEnvelope>;
+	walk(params?: NftTransfersWalkParams): AsyncIterable<NftTransfer>;
+}
+/** `index.events` — callable shorthand for `.list()`; `eventType` is required. */
+interface IndexEventsResource {
+	(params: EventsListParams): Promise<EventsEnvelope>;
+	list(params: EventsListParams): Promise<EventsEnvelope>;
+	walk(params: EventsWalkParams): AsyncIterable<IndexEvent>;
+}
 /** Per-event-type filter vocabulary in the {@link IndexDiscovery} doc. */
 type IndexEventTypeFilters = {
 	columns?: string[]
@@ -906,19 +1049,13 @@ declare class Index extends BaseClient {
 	* learn what's queryable (and which types accept `trait`) instead of hardcoding.
 	*/
 	discover(): Promise<IndexDiscovery>;
-	readonly ftTransfers: {
-		list: (params?: FtTransfersListParams) => Promise<FtTransfersEnvelope>
-		walk: (params?: FtTransfersWalkParams) => AsyncIterable<FtTransfer>
-	};
-	readonly nftTransfers: {
-		list: (params?: NftTransfersListParams) => Promise<NftTransfersEnvelope>
-		walk: (params?: NftTransfersWalkParams) => AsyncIterable<NftTransfer>
-	};
-	/** Generic decoded events by `event_type` (the full /v1/index/events surface). */
-	readonly events: {
-		list: (params: EventsListParams) => Promise<EventsEnvelope>
-		walk: (params: EventsWalkParams) => AsyncIterable<IndexEvent>
-	};
+	/** Callable: `index.ftTransfers(params)` ≡ `index.ftTransfers.list(params)`. */
+	readonly ftTransfers: FtTransfersResource;
+	/** Callable: `index.nftTransfers(params)` ≡ `index.nftTransfers.list(params)`. */
+	readonly nftTransfers: NftTransfersResource;
+	/** Generic decoded events by `event_type` (the full /v1/index/events surface).
+	*  Callable: `index.events(params)` ≡ `index.events.list(params)`. */
+	readonly events: IndexEventsResource;
 	readonly contractCalls: {
 		list: (params?: ContractCallsListParams) => Promise<ContractCallsEnvelope>
 		walk: (params?: ContractCallsWalkParams) => AsyncIterable<IndexContractCall>
@@ -941,6 +1078,7 @@ declare class Index extends BaseClient {
 		list: (params?: TransactionsListParams) => Promise<TransactionsEnvelope>
 		walk: (params?: TransactionsWalkParams) => AsyncIterable<IndexTransaction>
 		get: (txId: string) => Promise<TransactionEnvelope | null>
+		getProof: (txId: string) => Promise<TransactionProof | null>
 	};
 	/** Decoded PoX-4 stacking actions. Empty (with a `notes` hint) when the
 	*  platform's PoX-4 decoder is disabled. */
@@ -970,6 +1108,11 @@ declare class Index extends BaseClient {
 	private walkBlocks;
 	private listTransactions;
 	private getTransaction;
+	/** Fetch the inclusion proof for a tx (raw tx + Nakamoto header + merkle path)
+	*  to verify client-side with `verifyTransactionProof`. 404 → null. A 503
+	*  (`PROOF_TX_SET_INCOMPLETE` / `PROOF_NODE_UNAVAILABLE`) surfaces as an
+	*  ApiError — the proof can't be assembled on this deployment right now. */
+	private getTransactionProof;
 	private walkTransactions;
 	private listStacking;
 	private walkStacking;
@@ -1297,6 +1440,36 @@ type StreamsEventsConsumeParams = {
 	maxEmptyPolls?: number
 	signal?: AbortSignal
 };
+/**
+* One yielded page from {@link StreamsClient.consume} — the
+* `GET /v1/streams/events` envelope verbatim, with `next_cursor` renamed to
+* `cursor` (the checkpoint to persist and resume from).
+*/
+type StreamsBatch = {
+	/** Canonical events of this page, in cursor order. */
+	events: StreamsEvent[]
+	/** Checkpoint after this page — pass back as `consume({ cursor })` to resume. */
+	cursor: string | null
+	tip: StreamsTip
+	/** Chain reorgs reported alongside this page; empty when none. */
+	reorgs: StreamsReorg[]
+};
+type StreamsConsumeParams = {
+	/** Resume strictly after this cursor; omit to start from the oldest seekable page. */
+	cursor?: string | null
+	types?: readonly StreamsEventType[]
+	notTypes?: readonly StreamsEventType[]
+	contractId?: StreamsFilterValue
+	sender?: StreamsFilterValue
+	recipient?: StreamsFilterValue
+	assetIdentifier?: string
+	/** Events per page (the `limit` query param). Default 100. */
+	batchSize?: number
+	/** Poll interval while caught up at the tip, in ms. Default 2000. */
+	intervalMs?: number
+	/** Abort to end the iteration. */
+	signal?: AbortSignal
+};
 type StreamsEventsConsumeResult = {
 	cursor: string | null
 	pages: number
@@ -1365,6 +1538,21 @@ type StreamsDumps = {
 	download(file: StreamsDumpFile): Promise<Uint8Array>
 };
 type StreamsClient = {
+	/**
+	* Follow Streams as an async iterator of page batches.
+	*
+	* Yields one {@link StreamsBatch} per `GET /v1/streams/events` page — the
+	* existing envelope (`events`, `next_cursor` → `cursor`, `tip`, `reorgs`)
+	* with zero extra API calls. Batches are chosen over per-block groupings
+	* because the envelope is page-keyed, so every yield is exactly one fetch.
+	* Empty pages are skipped; at the tip the iterator re-polls every
+	* `intervalMs` (default 2000) until aborted via `signal`.
+	*
+	* Reorgs are surfaced on the batch (`batch.reorgs`) but the cursor is not
+	* rewound automatically — use `events.consume` with `onReorg` for managed
+	* rollback semantics.
+	*/
+	consume(params?: StreamsConsumeParams): AsyncIterableIterator<StreamsBatch>
 	events: {
 		list(params?: StreamsEventsListParams): Promise<StreamsEventsEnvelope>
 		byTxId(txId: string): Promise<StreamsEventsListEnvelope>
@@ -1861,6 +2049,152 @@ declare const Cursor: {
 	}
 };
 type DecodedEventRow = DecodedFtTransfer | DecodedNftTransfer | DecodedStxTransfer | DecodedStxMint | DecodedStxBurn | DecodedStxLock | DecodedFtMint | DecodedFtBurn | DecodedNftMint | DecodedNftBurn | DecodedPrint;
+import { X402TokenSymbol } from "@secondlayer/shared/x402";
+import { LocalAccount } from "@secondlayer/stacks/accounts";
+import { StacksChain } from "@secondlayer/stacks/chains";
+/**
+* Client for the x402 pay-per-request rail. Turns a 402 challenge into a signed
+* `PAYMENT-SIGNATURE` and retries — gasless (the agent signs origin-only; the
+* facilitator sponsors the STX fee) and accountless (no key/Stripe/session).
+*
+* Three layers:
+*  - `withX402(fetch, opts)` — drop-in fetch that auto-pays on 402.
+*  - `createX402Client(opts)` — `.get/.post` returning `{ data, payment }`.
+*  - `buildSignedX402Payment` / `readX402Challenge` — primitives for custom transports.
+*/
+type X402Accept = {
+	scheme: "exact"
+	network: string
+	asset: string
+	/** Atomic units. */
+	amount: string
+	payTo: string
+	maxTimeoutSeconds: number
+	extra: {
+		nonce: string
+	}
+};
+type X402Challenge = {
+	x402Version: number
+	accepts: X402Accept[]
+	error?: string
+};
+/** Decoded `PAYMENT-RESPONSE` settlement receipt. */
+type X402Receipt = {
+	success: boolean
+	/** Settlement tier: `optimistic` (served on broadcast-accept, reconciled
+	*  async) or `confirmed` (canonical). Absent on older deployments. */
+	state?: "optimistic" | "confirmed"
+	txid: string
+	payer: string
+	network: string
+};
+/** Bitcoin-native first — sBTC is the compelling micropay asset; USDCx the
+*  dollar peg; STX the fallback. Override via `preferAssets`. */
+declare const DEFAULT_PREFER_ASSETS: X402TokenSymbol[];
+/** Thrown when no offered asset is within the caller's spend guard / preferences. */
+declare class X402SpendGuardError extends Error {
+	constructor(message: string);
+}
+/** Read the x402 challenge from a 402 response — prefer the wire header, fall
+*  back to the JSON body. */
+declare function readX402Challenge(res: Response): Promise<X402Challenge | null>;
+/** Read the settlement receipt from a paid 200 response. */
+declare function readX402Receipt(res: Response): X402Receipt | null;
+type SelectOfferOptions = {
+	preferAssets?: X402TokenSymbol[]
+	maxAmountPerCall?: Partial<Record<X402TokenSymbol, bigint>>
+};
+/** Choose an `accepts[]` entry by preference order, skipping any that exceed the
+*  per-asset spend cap. Throws {@link X402SpendGuardError} if none qualify. */
+declare function selectOffer(challenge: X402Challenge, opts?: SelectOfferOptions): {
+	accept: X402Accept
+	symbol: X402TokenSymbol
+};
+/** Fetch the payer account's next nonce from a Stacks node (`/v2/accounts`). */
+declare function resolveAccountNonce(address: string, nodeUrl?: string): Promise<number>;
+type BuildSignedX402PaymentOptions = {
+	challenge: X402Challenge
+	account: LocalAccount
+	/** The payer account's next nonce. */
+	accountNonce: bigint | number | string
+	/** Preferred asset string (e.g. an sBTC/USDCx id). Defaults to the first offer. */
+	asset?: string
+	chain?: StacksChain
+};
+/** Build a signed, base64 `PAYMENT-SIGNATURE` header for one `accepts[]` entry. */
+declare function buildSignedX402Payment(opts: BuildSignedX402PaymentOptions): Promise<{
+	header: string
+	accept: X402Accept
+}>;
+type WithX402Options = SelectOfferOptions & {
+	account: LocalAccount
+	/** Override the payer nonce; auto-resolved from `nodeUrl` when omitted. */
+	accountNonce?: bigint | number | string
+	/** Node for auto-nonce lookup. Defaults to {@link DEFAULT_NONCE_NODE_URL}. */
+	nodeUrl?: string
+	chain?: StacksChain
+	/** Fired just before the paid retry (the call then blocks on confirmed-tier
+	*  settle, or returns near-instantly on an optimistic surface). */
+	onSettling?: (info: {
+		asset: string
+		amount: string
+	}) => void
+	/** Abort the paid retry after this long. */
+	timeoutMs?: number
+};
+type X402Fetch = (input: string | URL, init?: RequestInit) => Promise<Response>;
+/**
+* Wrap a `fetch` so requests transparently pay on 402: select an offer (by
+* `preferAssets` + `maxAmountPerCall`), resolve the nonce, sign origin-only, and
+* retry once with `PAYMENT-SIGNATURE`. Returns the final `Response` (read the
+* receipt with {@link readX402Receipt}).
+*
+* @example
+* const x402fetch = withX402(fetch, { account });
+* const res = await x402fetch("https://api.secondlayer.tools/v1/index/events?event_type=ft_transfer");
+*/
+declare function withX402(baseFetch: typeof fetch, opts: WithX402Options): X402Fetch;
+type X402ClientOptions = WithX402Options & {
+	baseUrl: string
+	/** Override the underlying fetch (tests). */
+	fetch?: typeof fetch
+};
+type X402Result<T = unknown> = {
+	data: T
+	/** Settlement receipt, or null if the response carried none. */
+	payment: X402Receipt | null
+	response: Response
+};
+type X402Client = {
+	get<T = unknown>(path: string, o?: {
+		query?: Record<string, string>
+	}): Promise<X402Result<T>>
+	post<T = unknown>(path: string, o?: {
+		body?: unknown
+	}): Promise<X402Result<T>>
+};
+/**
+* A small client over {@link withX402}: `.get/.post` against `baseUrl`, returning
+* parsed JSON plus the settlement receipt.
+*
+* @example
+* const sl = createX402Client({ account, baseUrl: "https://api.secondlayer.tools" });
+* const { data, payment } = await sl.get("/v1/index/events", { query: { event_type: "ft_transfer" } });
+*/
+declare function createX402Client(opts: X402ClientOptions): X402Client;
+/** Caller-supplied fetch that re-runs the request with the given extra headers. */
+type X402FetchFn = (extraHeaders: Record<string, string>) => Promise<Response>;
+type PayAndRetryOptions = Omit<WithX402Options, never> & {
+	/** Required here (use `withX402` for auto-nonce). */
+	accountNonce: bigint | number | string
+};
+/**
+* Low-level: run a request via a caller-controlled fetch; if it 402s, pay and
+* retry once. Prefer {@link withX402} for the common case (it auto-resolves the
+* nonce + selects the asset). Kept for custom transports.
+*/
+declare function payAndRetry(doFetch: X402FetchFn, opts: PayAndRetryOptions): Promise<Response>;
 import { SubgraphAgentSchema as SubgraphAgentSchema3, SubgraphSpecFormat as SubgraphSpecFormat2, SubgraphSpecOptions as SubgraphSpecOptions3 } from "@secondlayer/shared/subgraphs/spec";
 import { ByoBreakingChangeDetails } from "@secondlayer/shared/errors";
 /**
@@ -2026,85 +2360,6 @@ declare function verifyWebhookSignature(rawBody: string, headers: WebhookHeaderI
 * ```
 */
 declare function verifySecondlayerSignature(rawBody: string, headers: WebhookHeaderInput, publicKeyPem: string): boolean;
-import { RewardSet } from "@secondlayer/shared/node/consensus";
-import { MerkleProofStep } from "@secondlayer/shared/node/nakamoto";
-/**
-* Trustless transaction-inclusion proof verification.
-*
-* Given a proof from `GET /v1/index/transactions/:txid/proof`, the consumer
-* re-derives everything itself — it does NOT trust any value Secondlayer
-* computed. Anchored level: (1) recompute the txid from the raw tx bytes, (2)
-* fold it up the merkle path to the header's `tx_merkle_root`, (3) recompute the
-* header's `block_hash` and `index_block_hash` from the raw header — "this tx is
-* included in a header any node can corroborate". Consensus level (when the proof
-* carries a `consensus` field, or a `rewardSet` is passed): additionally recover
-* the header's signer signatures and confirm ≥70% of reward-set signer weight
-* signed the block.
-*
-* Note: uses Node's crypto via `@secondlayer/shared` (same as the Streams
-* signature verify); intended for Node/server verification.
-*/
-interface TransactionProof {
-	txid: string;
-	index_block_hash: string;
-	block_height: number;
-	tx_index: number;
-	/** Raw consensus-serialized transaction bytes (hex). */
-	raw_tx: string;
-	/** Raw Nakamoto block-header bytes (hex) — parsed + re-hashed by the verifier. */
-	raw_header: string;
-	/** Authentication path from the tx leaf to `tx_merkle_root`. */
-	tx_merkle_path: MerkleProofStep[];
-	/** Present when consensus-level verification is available: the reward cycle and
-	*  its signer set, against which the header's signer signatures are checked. */
-	consensus?: {
-		reward_cycle: number
-		reward_set: RewardSet
-	};
-}
-interface TransactionProofVerifyResult {
-	/** Highest level actually verified. "consensus" requires the proof's
-	*  `consensus` field and a met signer-weight threshold. */
-	level: "anchored" | "consensus";
-	/** Recomputed txid === proof.txid. */
-	txidMatches: boolean;
-	/** Merkle path folds the txid to the header's tx_merkle_root. */
-	includedInHeader: boolean;
-	/** Recomputed block_hash + index_block_hash match the header / proof. */
-	headerSelfConsistent: boolean;
-	/** Basis points (0–10000) of reward-set signer weight that signed the block.
-	*  Only set when the proof carries a `consensus` field. */
-	signerWeightBps?: number;
-	/** ≥70% of signer weight signed. Only set with a `consensus` field. */
-	thresholdMet?: boolean;
-	/** Which reward set the signer check used: "provided" (caller-resolved →
-	*  fully trustless) or "embedded" (the one Secondlayer put in the proof). */
-	rewardSetSource?: "provided" | "embedded";
-	/** All applicable checks passed (incl. the threshold when consensus is present). */
-	ok: boolean;
-	errors: string[];
-}
-/**
-* Resolve a reward set directly from a stacks-node (`/v3/stacker_set/{cycle}`),
-* so a caller can verify the consensus layer against a node IT trusts rather than
-* the reward set Secondlayer embedded in the proof. Pass the result as
-* `verifyTransactionProof(proof, { rewardSet })`.
-*/
-declare function fetchRewardSet(opts: {
-	nodeUrl: string
-	cycle: number
-	fetchImpl?: typeof fetch
-}): Promise<RewardSet | null>;
-/**
-* Verify a transaction-inclusion proof. Every check is recomputed client-side,
-* so a `true` result does not rely on trusting Secondlayer. Pass
-* `{ rewardSet }` (resolved via {@link fetchRewardSet} from your own node) to
-* verify the consensus layer against a reward set you trust rather than the one
-* embedded in the proof.
-*/
-declare function verifyTransactionProof(proof: TransactionProof, opts?: {
-	rewardSet?: RewardSet
-}): TransactionProofVerifyResult;
 import { RewardSet as RewardSet2 } from "@secondlayer/shared/node/consensus";
 /** Make a cvToValue result JSON-serializable: Clarity (u)ints decode to bigint,
 *  which JSON.stringify can't handle — convert recursively to strings. */
@@ -2112,4 +2367,4 @@ declare function toJsonSafe(value: unknown): unknown;
 /** Decode a hex-encoded Clarity value to JSON-safe JS (uints as strings,
 *  buffers as `0x…` hex, tuples as objects). Returns the input hex on failure. */
 declare function decodeClarityValue(hex: string): unknown;
-export { verifyWebhookSignature, verifyTransactionProof, verifySecondlayerSignature, trigger, toJsonSafe, isStxTransfer, isStxMint, isStxLock, isStxBurn, isPrint, isNftTransfer, isNftMint, isNftBurn, isFtTransfer, isFtMint, isFtBurn, getSubgraph, fetchRewardSet, decodeStxTransfer, decodeStxMint, decodeStxLock, decodeStxBurn, decodePrint, decodeNftTransfer, decodeNftMint, decodeNftBurn, decodeFtTransfer, decodeFtMint, decodeFtBurn, decodeClarityValue, createStreamsClient, VersionConflictError, ValidationError, UpdateSubscriptionRequest2 as UpdateSubscriptionRequest, UpdateProjectParams, TransactionsWalkParams, TransactionsListParams, TransactionsEnvelope, TransactionProofVerifyResult, TransactionProof, TransactionEnvelope, Subscriptions, SubscriptionSummary2 as SubscriptionSummary, SubscriptionStatus, SubscriptionRuntime, SubscriptionKind, SubscriptionFormat, SubscriptionDetail2 as SubscriptionDetail, Subgraphs, SubgraphSpecOptions3 as SubgraphSpecOptions, SubgraphSpecFormat2 as SubgraphSpecFormat, SubgraphOperationStatus, SubgraphAgentSchema3 as SubgraphAgentSchema, StreamsUsage, StreamsTip, StreamsSignatureError, StreamsServerError, StreamsReorgsListParams, StreamsReorgsListEnvelope, StreamsReorgContext, StreamsReorg, StreamsEventsSubscribeParams, StreamsEventsStreamParams, StreamsEventsListParams, StreamsEventsListEnvelope, StreamsEventsEnvelope, StreamsEventsConsumeResult, StreamsEventsConsumeParams, StreamsEventType, StreamsEventPayload, StreamsEvent, StreamsDumpsManifest, StreamsDumps, StreamsDumpFile, StreamsClient, StreamsCanonicalBlock, StreamsBatchContext, StackingWalkParams, StackingListParams, StackingEnvelope, SecondLayerOptions, SecondLayer, ScopedKeyProduct, RotateSecretResponse2 as RotateSecretResponse, RewardSet2 as RewardSet, ReplayResult2 as ReplayResult, RateLimitError, Projects, ProjectTeamMember, ProjectTeam, ProjectInvitation, Project, Pox4CallsParams, NftTransfersWalkParams, NftTransfersListParams, NftTransfersEnvelope, NftTransferPayload, NftTransferEvent, NftTransfer, MempoolWalkParams, MempoolTransactionEnvelope, MempoolListParams, MempoolEnvelope, IndexUsage, IndexTransaction, IndexTip, IndexStackingAction, IndexReorg, IndexPostCondition, IndexMempoolTransaction, IndexEventTypeFilters, IndexEventType, IndexEvent, IndexDiscovery, IndexContractCall, IndexCanonicalBlock, IndexBlock, Index, FtTransfersWalkParams, FtTransfersListParams, FtTransfersEnvelope, FtTransferPayload, FtTransferEvent, FtTransfer, FetchLike2 as FetchLike, EventsWalkParams, EventsListParams, EventsEnvelope, DeliveryRow2 as DeliveryRow, DecodedStxTransferPayload, DecodedStxTransfer, DecodedStxMintPayload, DecodedStxMint, DecodedStxLockPayload, DecodedStxLock, DecodedStxBurnPayload, DecodedStxBurn, DecodedPrintValue, DecodedPrintPayload, DecodedPrint, DecodedNftTransferPayload, DecodedNftTransfer, DecodedNftMintPayload, DecodedNftMint, DecodedNftBurnPayload, DecodedNftBurn, DecodedFtTransferPayload, DecodedFtTransfer, DecodedFtMintPayload, DecodedFtMint, DecodedFtBurnPayload, DecodedFtBurn, DecodedEventRow, DecodedEventColumns, DeadRow2 as DeadRow, Datasets, DatasetRow, CursorListParams, CursorEnvelope, Cursor, CreateSubscriptionResponse2 as CreateSubscriptionResponse, CreateSubscriptionRequest2 as CreateSubscriptionRequest, CreateProjectParams, CreateApiKeyResponse, CreateApiKeyParams, ContractsListParams, ContractsEnvelope, Contracts, ContractSummary, ContractConformance, ContractCallsWalkParams, ContractCallsListParams, ContractCallsEnvelope, ContextSnapshot, ContextProject, ContextApiKey, ContextAccount, ChainTriggerType, ChainTrigger, CanonicalWalkParams, CanonicalListParams, CanonicalEnvelope, CURSOR_SLUGS, ByoBreakingChangeError, ByoBreakingChangeDetails, BlocksWalkParams, BlocksListParams, BlocksEnvelope, BlockEnvelope, AuthError, ApiKeys, ApiKeySummary, ApiError, ActiveSubgraphOperation };
+export { withX402, verifyWebhookSignature, verifyTransactionProof, verifySecondlayerSignature, trigger, toJsonSafe, selectOffer, resolveAccountNonce, readX402Receipt, readX402Challenge, payAndRetry, isStxTransfer, isStxMint, isStxLock, isStxBurn, isPrint, isNftTransfer, isNftMint, isNftBurn, isFtTransfer, isFtMint, isFtBurn, getSubgraph, fetchRewardSet, decodeStxTransfer, decodeStxMint, decodeStxLock, decodeStxBurn, decodePrint, decodeNftTransfer, decodeNftMint, decodeNftBurn, decodeFtTransfer, decodeFtMint, decodeFtBurn, decodeClarityValue, createX402Client, createStreamsClient, buildSignedX402Payment, X402SpendGuardError, X402Result, X402Receipt, X402Fetch, X402ClientOptions, X402Client, X402Challenge, X402Accept, WithX402Options, VersionConflictError, ValidationError, UpdateSubscriptionRequest2 as UpdateSubscriptionRequest, UpdateProjectParams, TransactionsWalkParams, TransactionsListParams, TransactionsEnvelope, TransactionProofVerifyResult, TransactionProof, TransactionEnvelope, Subscriptions, SubscriptionSummary2 as SubscriptionSummary, SubscriptionStatus, SubscriptionRuntime, SubscriptionKind, SubscriptionFormat, SubscriptionDetail2 as SubscriptionDetail, Subgraphs, SubgraphSpecOptions3 as SubgraphSpecOptions, SubgraphSpecFormat2 as SubgraphSpecFormat, SubgraphOperationStatus, SubgraphAgentSchema3 as SubgraphAgentSchema, StreamsUsage, StreamsTip, StreamsSignatureError, StreamsServerError, StreamsReorgsListParams, StreamsReorgsListEnvelope, StreamsReorgContext, StreamsReorg, StreamsEventsSubscribeParams, StreamsEventsStreamParams, StreamsEventsListParams, StreamsEventsListEnvelope, StreamsEventsEnvelope, StreamsEventsConsumeResult, StreamsEventsConsumeParams, StreamsEventType, StreamsEventPayload, StreamsEvent, StreamsDumpsManifest, StreamsDumps, StreamsDumpFile, StreamsConsumeParams, StreamsClient, StreamsCanonicalBlock, StreamsBatchContext, StreamsBatch, StackingWalkParams, StackingListParams, StackingEnvelope, SelectOfferOptions, SecondLayerOptions, SecondLayer, ScopedKeyProduct, RotateSecretResponse2 as RotateSecretResponse, RewardSet2 as RewardSet, ReplayResult2 as ReplayResult, RateLimitError, Projects, ProjectTeamMember, ProjectTeam, ProjectInvitation, Project, Pox4CallsParams, PayAndRetryOptions, NftTransfersWalkParams, NftTransfersResource, NftTransfersListParams, NftTransfersEnvelope, NftTransferPayload, NftTransferEvent, NftTransfer, MempoolWalkParams, MempoolTransactionEnvelope, MempoolListParams, MempoolEnvelope, IndexUsage, IndexTransaction, IndexTip, IndexStackingAction, IndexReorg, IndexPostCondition, IndexMempoolTransaction, IndexEventsResource, IndexEventTypeFilters, IndexEventType, IndexEvent, IndexDiscovery, IndexContractCall, IndexCanonicalBlock, IndexBlock, Index, FtTransfersWalkParams, FtTransfersResource, FtTransfersListParams, FtTransfersEnvelope, FtTransferPayload, FtTransferEvent, FtTransfer, FetchLike2 as FetchLike, EventsWalkParams, EventsListParams, EventsEnvelope, DeliveryRow2 as DeliveryRow, DecodedStxTransferPayload, DecodedStxTransfer, DecodedStxMintPayload, DecodedStxMint, DecodedStxLockPayload, DecodedStxLock, DecodedStxBurnPayload, DecodedStxBurn, DecodedPrintValue, DecodedPrintPayload, DecodedPrint, DecodedNftTransferPayload, DecodedNftTransfer, DecodedNftMintPayload, DecodedNftMint, DecodedNftBurnPayload, DecodedNftBurn, DecodedFtTransferPayload, DecodedFtTransfer, DecodedFtMintPayload, DecodedFtMint, DecodedFtBurnPayload, DecodedFtBurn, DecodedEventRow, DecodedEventColumns, DeadRow2 as DeadRow, Datasets, DatasetRow, DEFAULT_PREFER_ASSETS, CursorListParams, CursorEnvelope, Cursor, CreateSubscriptionResponse2 as CreateSubscriptionResponse, CreateSubscriptionRequest2 as CreateSubscriptionRequest, CreateProjectParams, CreateApiKeyResponse, CreateApiKeyParams, ContractsListParams, ContractsEnvelope, Contracts, ContractSummary, ContractConformance, ContractCallsWalkParams, ContractCallsListParams, ContractCallsEnvelope, ContextSnapshot, ContextProject, ContextApiKey, ContextAccount, ChainTriggerType, ChainTrigger, CanonicalWalkParams, CanonicalListParams, CanonicalEnvelope, CURSOR_SLUGS, ByoBreakingChangeError, ByoBreakingChangeDetails, BuildSignedX402PaymentOptions, BlocksWalkParams, BlocksListParams, BlocksEnvelope, BlockEnvelope, AuthError, ApiKeys, ApiKeySummary, ApiError, ActiveSubgraphOperation };